\section{KConfig\-Skeleton Class Reference}
\label{classKConfigSkeleton}\index{KConfigSkeleton@{KConfigSkeleton}}
Class for handling preferences settings for an application.  


{\tt \#include $<$kconfigskeleton.h$>$}

Collaboration diagram for KConfig\-Skeleton:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=261pt]{classKConfigSkeleton__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf KConfig\-Skeleton} (const {\bf QString} \&configname=QString::null)
\item 
{\bf KConfig\-Skeleton} ({\bf KShared\-Config::Ptr} config)
\item 
virtual {\bf $\sim$KConfig\-Skeleton} ()
\item 
void {\bf set\-Defaults} ()
\item 
void {\bf read\-Config} ()
\item 
void {\bf write\-Config} ()
\item 
void {\bf set\-Current\-Group} (const {\bf QString} \&group)
\item 
{\bf QString} {\bf current\-Group} ()
\item 
void {\bf add\-Item} ({\bf KConfig\-Skeleton\-Item} $\ast$, const {\bf QString} \&name=QString::null)
\item 
{\bf Item\-String} $\ast$ {\bf add\-Item\-String} (const {\bf QString} \&name, {\bf QString} \&reference, const {\bf QString} \&default\-Value={\bf QString::from\-Latin1}(\char`\"{}\char`\"{}), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Password} $\ast$ {\bf add\-Item\-Password} (const {\bf QString} \&name, {\bf QString} \&reference, const {\bf QString} \&default\-Value={\bf QString::from\-Latin1}(\char`\"{}\char`\"{}), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Path} $\ast$ {\bf add\-Item\-Path} (const {\bf QString} \&name, {\bf QString} \&reference, const {\bf QString} \&default\-Value={\bf QString::from\-Latin1}(\char`\"{}\char`\"{}), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Property} $\ast$ {\bf add\-Item\-Property} (const {\bf QString} \&name, {\bf QVariant} \&reference, const {\bf QVariant} \&default\-Value={\bf QVariant}(), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Bool} $\ast$ {\bf add\-Item\-Bool} (const {\bf QString} \&name, bool \&reference, bool default\-Value=false, const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Int} $\ast$ {\bf add\-Item\-Int} (const {\bf QString} \&name, int \&reference, int default\-Value=0, const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-UInt} $\ast$ {\bf add\-Item\-UInt} (const {\bf QString} \&name, unsigned int \&reference, unsigned int default\-Value=0, const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Long} $\ast$ {\bf add\-Item\-Long} (const {\bf QString} \&name, long \&reference, long default\-Value=0, const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-ULong} $\ast$ {\bf add\-Item\-ULong} (const {\bf QString} \&name, unsigned long \&reference, unsigned long default\-Value=0, const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Int64} $\ast$ {\bf add\-Item\-Int64} (const {\bf QString} \&name, Q\_\-INT64 \&reference, Q\_\-INT64 default\-Value=0, const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-UInt64} $\ast$ {\bf add\-Item\-UInt64} (const {\bf QString} \&name, Q\_\-UINT64 \&reference, Q\_\-UINT64 default\-Value=0, const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Double} $\ast$ {\bf add\-Item\-Double} (const {\bf QString} \&name, double \&reference, double default\-Value=0.0, const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Color} $\ast$ {\bf add\-Item\-Color} (const {\bf QString} \&name, {\bf QColor} \&reference, const {\bf QColor} \&default\-Value={\bf QColor}(128, 128, 128), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Font} $\ast$ {\bf add\-Item\-Font} (const {\bf QString} \&name, {\bf QFont} \&reference, const {\bf QFont} \&default\-Value=KGlobal\-Settings::general\-Font(), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Rect} $\ast$ {\bf add\-Item\-Rect} (const {\bf QString} \&name, {\bf QRect} \&reference, const {\bf QRect} \&default\-Value={\bf QRect}(), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Point} $\ast$ {\bf add\-Item\-Point} (const {\bf QString} \&name, {\bf QPoint} \&reference, const {\bf QPoint} \&default\-Value={\bf QPoint}(), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Size} $\ast$ {\bf add\-Item\-Size} (const {\bf QString} \&name, {\bf QSize} \&reference, const {\bf QSize} \&default\-Value={\bf QSize}(), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Date\-Time} $\ast$ {\bf add\-Item\-Date\-Time} (const {\bf QString} \&name, {\bf QDate\-Time} \&reference, const {\bf QDate\-Time} \&default\-Value={\bf QDate\-Time}(), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-String\-List} $\ast$ {\bf add\-Item\-String\-List} (const {\bf QString} \&name, {\bf QString\-List} \&reference, const {\bf QString\-List} \&default\-Value={\bf QString\-List}(), const {\bf QString} \&key=QString::null)
\item 
{\bf Item\-Int\-List} $\ast$ {\bf add\-Item\-Int\-List} (const {\bf QString} \&name, {\bf QValue\-List}$<$ int $>$ \&reference, const {\bf QValue\-List}$<$ int $>$ \&default\-Value={\bf QValue\-List}$<$ int $>$(), const {\bf QString} \&key=QString::null)
\item 
{\bf KConfig} $\ast$ {\bf config} () const 
\item 
{\bf KConfig\-Skeleton\-Item::List} {\bf items} () const 
\item 
bool {\bf is\-Immutable} (const {\bf QString} \&name)
\item 
{\bf KConfig\-Skeleton\-Item} $\ast$ {\bf find\-Item} (const {\bf QString} \&name)
\item 
bool {\bf use\-Defaults} (bool b)
\end{CompactItemize}
\subsection*{Protected Member Functions}
\begin{CompactItemize}
\item 
virtual void {\bf usr\-Use\-Defaults} (bool)
\item 
virtual void {\bf usr\-Set\-Defaults} ()\label{classKConfigSkeleton_b1}

\item 
virtual void {\bf usr\-Read\-Config} ()
\item 
virtual void {\bf usr\-Write\-Config} ()
\end{CompactItemize}
\subsection*{Classes}
\begin{CompactItemize}
\item 
class {\bf Item\-Bool}
\begin{CompactList}\small\item\em Class for handling a bool preferences item. \item\end{CompactList}\item 
class {\bf Item\-Color}
\begin{CompactList}\small\item\em Class for handling a color preferences item. \item\end{CompactList}\item 
class {\bf Item\-Date\-Time}
\begin{CompactList}\small\item\em Class for handling a {\bf QDate\-Time} preferences item. \item\end{CompactList}\item 
class {\bf Item\-Double}
\begin{CompactList}\small\item\em Class for handling a floating point preference item. \item\end{CompactList}\item 
class {\bf Item\-Enum}
\begin{CompactList}\small\item\em Class for handling enums. \item\end{CompactList}\item 
class {\bf Item\-Font}
\begin{CompactList}\small\item\em Class for handling a font preferences item. \item\end{CompactList}\item 
class {\bf Item\-Int}
\begin{CompactList}\small\item\em Class for handling an integer preferences item. \item\end{CompactList}\item 
class {\bf Item\-Int64}
\begin{CompactList}\small\item\em Class for handling an 64-bit integer preferences item. \item\end{CompactList}\item 
class {\bf Item\-Int\-List}
\begin{CompactList}\small\item\em Class for handling an integer list preferences item. \item\end{CompactList}\item 
class {\bf Item\-Long}
\begin{CompactList}\small\item\em Class for hanlding a long integer preferences item. \item\end{CompactList}\item 
class {\bf Item\-Password}
\begin{CompactList}\small\item\em Class for handling a password preferences item. \item\end{CompactList}\item 
class {\bf Item\-Path}
\begin{CompactList}\small\item\em Class for handling a path preferences item. \item\end{CompactList}\item 
class {\bf Item\-Path\-List}
\begin{CompactList}\small\item\em Class for handling a path list preferences item. \item\end{CompactList}\item 
class {\bf Item\-Point}
\begin{CompactList}\small\item\em Class for handling a {\bf QPoint} preferences item. \item\end{CompactList}\item 
class {\bf Item\-Property}
\begin{CompactList}\small\item\em Class for handling a {\bf QVariant} preferences item. \item\end{CompactList}\item 
class {\bf Item\-Rect}
\begin{CompactList}\small\item\em Class for handling a {\bf QRect} preferences item. \item\end{CompactList}\item 
class {\bf Item\-Size}
\begin{CompactList}\small\item\em Class for handling a {\bf QSize} preferences item. \item\end{CompactList}\item 
class {\bf Item\-String}
\begin{CompactList}\small\item\em Class for handling a string preferences item. \item\end{CompactList}\item 
class {\bf Item\-String\-List}
\begin{CompactList}\small\item\em Class for handling a string list preferences item. \item\end{CompactList}\item 
class {\bf Item\-UInt}
\begin{CompactList}\small\item\em Class for handling an unsingend integer preferences item. \item\end{CompactList}\item 
class {\bf Item\-UInt64}
\begin{CompactList}\small\item\em Class for handling unsigned 64-bit integer preferences item. \item\end{CompactList}\item 
class {\bf Item\-ULong}
\begin{CompactList}\small\item\em Class for handling an unsigned long integer preferences item. \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
Class for handling preferences settings for an application. 

\begin{Desc}
\item[Author:]Cornelius Schumacher \end{Desc}
\begin{Desc}
\item[See also:]{\bf KConfig\-Skeleton\-Item}{\rm (p.\,\pageref{classKConfigSkeletonItem})}\end{Desc}
This class provides an interface to preferences settings. Preferences items can be registered by the {\bf add\-Item()}{\rm (p.\,\pageref{classKConfigSkeleton_a8})} function corresponding to the data type of the seetting. KConfig\-Skeleton then handles reading and writing of config files and setting of default values.

Normally you will subclass KConfig\-Skeleton, add data members for the preferences settings and register the members in the constructor of the subclass.

Example: 

\footnotesize\begin{verbatim} class MyPrefs : public KConfigSkeleton
 {
   public:
     MyPrefs()
     {
       setCurrentGroup("MyGroup");
       addItemBool("MySetting1",mMyBool,false);
       addItemColor("MySetting2",mMyColor,QColor(1,2,3));
 
       setCurrentGroup("MyOtherGroup");
       addItemFont("MySetting3",mMyFont,QFont("helvetica",12));
     }
 
     bool mMyBool;
     QColor mMyColor;
     QFont mMyFont;
 }
\end{verbatim}
\normalsize


It might be convenient in many cases to make this subclass of KConfig\-Skeleton a singleton for global access from all over the application without passing references to the KConfig\-Skeleton object around.

You can write the data to the configuration file by calling {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} and read the data from the configuration file by calling {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})}.

If you have items, which are not covered by the existing {\bf add\-Item()}{\rm (p.\,\pageref{classKConfigSkeleton_a8})} functions you can add customized code for reading, writing and default setting by implementing the functions {\bf usr\-Use\-Defaults()}{\rm (p.\,\pageref{classKConfigSkeleton_b0})}, {\bf usr\-Read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_b2})} and {\bf usr\-Write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_b3})}.

Internally preferences settings are stored in instances of subclasses of {\bf KConfig\-Skeleton\-Item}{\rm (p.\,\pageref{classKConfigSkeletonItem})}. You can also add {\bf KConfig\-Skeleton\-Item}{\rm (p.\,\pageref{classKConfigSkeletonItem})} subclasses for your own types and call the generic {\bf add\-Item()}{\rm (p.\,\pageref{classKConfigSkeleton_a8})} to register them.

In many cases you don't have to write the specific KConfig\-Skeleton subclasses yourself, but you can use {\bf The KDE Configuration Compiler}{\rm (p.\,\pageref{kconfig_compiler})} to automatically generate the C++ code from an XML description of the configuration options. 



Definition at line 365 of file kconfigskeleton.h.

\subsection{Constructor \& Destructor Documentation}
\index{KConfigSkeleton@{KConfig\-Skeleton}!KConfigSkeleton@{KConfigSkeleton}}
\index{KConfigSkeleton@{KConfigSkeleton}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KConfig\-Skeleton::KConfig\-Skeleton (const {\bf QString} \& {\em configname} = {\tt QString::null})}\label{classKConfigSkeleton_a0}


Constructor. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em configname}]name of config file. If no name is given, the default config file as returned by kapp()-$>${\bf config()}{\rm (p.\,\pageref{classKConfigSkeleton_a29})} is used. \end{description}
\end{Desc}


Definition at line 881 of file kconfigskeleton.cpp.

References endl(), KShared\-Config::open\-Config(), and KGlobal::shared\-Config().\index{KConfigSkeleton@{KConfig\-Skeleton}!KConfigSkeleton@{KConfigSkeleton}}
\index{KConfigSkeleton@{KConfigSkeleton}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KConfig\-Skeleton::KConfig\-Skeleton ({\bf KShared\-Config::Ptr} {\em config})}\label{classKConfigSkeleton_a1}


Constructor. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em config}]configuration object to use. \end{description}
\end{Desc}


Definition at line 896 of file kconfigskeleton.cpp.

References endl().\index{KConfigSkeleton@{KConfig\-Skeleton}!~KConfigSkeleton@{$\sim$KConfigSkeleton}}
\index{~KConfigSkeleton@{$\sim$KConfigSkeleton}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KConfig\-Skeleton::$\sim${\bf KConfig\-Skeleton} ()\hspace{0.3cm}{\tt  [virtual]}}\label{classKConfigSkeleton_a2}


Destructor. 



Definition at line 904 of file kconfigskeleton.cpp.

References QValue\-List::begin(), and QValue\-List::end().

\subsection{Member Function Documentation}
\index{KConfigSkeleton@{KConfig\-Skeleton}!setDefaults@{setDefaults}}
\index{setDefaults@{setDefaults}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Skeleton::set\-Defaults ()}\label{classKConfigSkeleton_a3}


Set all registered items to their default values. 



Definition at line 939 of file kconfigskeleton.cpp.

References QValue\-List::begin(), and QValue\-List::end().\index{KConfigSkeleton@{KConfig\-Skeleton}!readConfig@{readConfig}}
\index{readConfig@{readConfig}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Skeleton::read\-Config ()}\label{classKConfigSkeleton_a4}


Read preferences from config file. 

All registered items are set to the values read from disk. 

Definition at line 949 of file kconfigskeleton.cpp.

References QValue\-List::begin(), QValue\-List::end(), endl(), and usr\-Read\-Config().

Referenced by write\-Config().\index{KConfigSkeleton@{KConfig\-Skeleton}!writeConfig@{writeConfig}}
\index{writeConfig@{writeConfig}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Skeleton::write\-Config ()}\label{classKConfigSkeleton_a5}


Write preferences to config file. 

The values of all registered items are written to disk. 

Definition at line 967 of file kconfigskeleton.cpp.

References QValue\-List::begin(), QValue\-List::end(), endl(), read\-Config(), and usr\-Write\-Config().

Referenced by KConfig\-Dialog\-Manager::update\-Settings().\index{KConfigSkeleton@{KConfig\-Skeleton}!setCurrentGroup@{setCurrentGroup}}
\index{setCurrentGroup@{setCurrentGroup}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Skeleton::set\-Current\-Group (const {\bf QString} \& {\em group})}\label{classKConfigSkeleton_a6}


Set the config file group for subsequent {\bf add\-Item()}{\rm (p.\,\pageref{classKConfigSkeleton_a8})} calls. 

It is valid until {\bf set\-Current\-Group()}{\rm (p.\,\pageref{classKConfigSkeleton_a6})} is called with a new argument. Call this before you add any items. The default value is \char`\"{}No Group\char`\"{}. 

Definition at line 913 of file kconfigskeleton.cpp.\index{KConfigSkeleton@{KConfig\-Skeleton}!currentGroup@{currentGroup}}
\index{currentGroup@{currentGroup}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KConfig\-Skeleton::current\-Group ()\hspace{0.3cm}{\tt  [inline]}}\label{classKConfigSkeleton_a7}


Returns the current group used for {\bf add\-Item()}{\rm (p.\,\pageref{classKConfigSkeleton_a8})} calls. 



Definition at line 837 of file kconfigskeleton.h.\index{KConfigSkeleton@{KConfig\-Skeleton}!addItem@{addItem}}
\index{addItem@{addItem}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Skeleton::add\-Item ({\bf KConfig\-Skeleton\-Item} $\ast$, const {\bf QString} \& {\em name} = {\tt QString::null})}\label{classKConfigSkeleton_a8}


Register a custom {\bf KConfig\-Skeleton\-Item}{\rm (p.\,\pageref{classKConfigSkeletonItem})} with a given name. 

If the name parameter is null, take the name from {\bf KConfig\-Skeleton\-Item::key()}{\rm (p.\,\pageref{classKConfigSkeletonItem_a5})}. Note that all names must be unique but that multiple entries can have the same key if they reside in different groups. 

Definition at line 988 of file kconfigskeleton.cpp.

References QValue\-List::append(), and QDict::insert().

Referenced by add\-Item\-Bool(), add\-Item\-Color(), add\-Item\-Date\-Time(), add\-Item\-Double(), add\-Item\-Font(), add\-Item\-Int(), add\-Item\-Int64(), add\-Item\-Int\-List(), add\-Item\-Long(), add\-Item\-Password(), add\-Item\-Path(), add\-Item\-Point(), add\-Item\-Property(), add\-Item\-Rect(), add\-Item\-Size(), add\-Item\-String(), add\-Item\-String\-List(), add\-Item\-UInt(), add\-Item\-UInt64(), and add\-Item\-ULong().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemString@{addItemString}}
\index{addItemString@{addItemString}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-String} $\ast$ KConfig\-Skeleton::add\-Item\-String (const {\bf QString} \& {\em name}, {\bf QString} \& {\em reference}, const {\bf QString} \& {\em default\-Value} = {\tt {\bf QString::from\-Latin1}(\char`\"{}\char`\"{})}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a9}


Register an item of type {\bf QString}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 996 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Empty().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemPassword@{addItemPassword}}
\index{addItemPassword@{addItemPassword}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Password} $\ast$ KConfig\-Skeleton::add\-Item\-Password (const {\bf QString} \& {\em name}, {\bf QString} \& {\em reference}, const {\bf QString} \& {\em default\-Value} = {\tt {\bf QString::from\-Latin1}(\char`\"{}\char`\"{})}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a10}


Register a password item of type {\bf QString}. 

The string value is written encrypted to the config file. Note that the current encryption scheme is very weak.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1007 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemPath@{addItemPath}}
\index{addItemPath@{addItemPath}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Path} $\ast$ KConfig\-Skeleton::add\-Item\-Path (const {\bf QString} \& {\em name}, {\bf QString} \& {\em reference}, const {\bf QString} \& {\em default\-Value} = {\tt {\bf QString::from\-Latin1}(\char`\"{}\char`\"{})}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a11}


Register a path item of type {\bf QString}. 

The string value is interpreted as a path. This means, dollar expension is activated for this value, so that e.g. \$HOME gets expanded.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1017 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemProperty@{addItemProperty}}
\index{addItemProperty@{addItemProperty}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Property} $\ast$ KConfig\-Skeleton::add\-Item\-Property (const {\bf QString} \& {\em name}, {\bf QVariant} \& {\em reference}, const {\bf QVariant} \& {\em default\-Value} = {\tt {\bf QVariant}()}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a12}


Register a property item of type {\bf QVariant}. 

Note that only the following {\bf QVariant} types are allowed: String, String\-List, Font, Point, Rect, Size, Color, Int, UInt, Bool, Double, Date\-Time and Date.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1027 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemBool@{addItemBool}}
\index{addItemBool@{addItemBool}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Bool} $\ast$ KConfig\-Skeleton::add\-Item\-Bool (const {\bf QString} \& {\em name}, bool \& {\em reference}, bool {\em default\-Value} = {\tt false}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a13}


Register an item of type bool. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1037 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemInt@{addItemInt}}
\index{addItemInt@{addItemInt}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Int} $\ast$ KConfig\-Skeleton::add\-Item\-Int (const {\bf QString} \& {\em name}, int \& {\em reference}, int {\em default\-Value} = {\tt 0}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a14}


Register an item of type int. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1047 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemUInt@{addItemUInt}}
\index{addItemUInt@{addItemUInt}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-UInt} $\ast$ KConfig\-Skeleton::add\-Item\-UInt (const {\bf QString} \& {\em name}, unsigned int \& {\em reference}, unsigned int {\em default\-Value} = {\tt 0}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a15}


Register an item of type unsigned int. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1057 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemLong@{addItemLong}}
\index{addItemLong@{addItemLong}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Long} $\ast$ KConfig\-Skeleton::add\-Item\-Long (const {\bf QString} \& {\em name}, long \& {\em reference}, long {\em default\-Value} = {\tt 0}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a16}


Register an item of type long. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1087 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemULong@{addItemULong}}
\index{addItemULong@{addItemULong}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-ULong} $\ast$ KConfig\-Skeleton::add\-Item\-ULong (const {\bf QString} \& {\em name}, unsigned long \& {\em reference}, unsigned long {\em default\-Value} = {\tt 0}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a17}


Register an item of type unsigned long. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1097 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemInt64@{addItemInt64}}
\index{addItemInt64@{addItemInt64}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Int64} $\ast$ KConfig\-Skeleton::add\-Item\-Int64 (const {\bf QString} \& {\em name}, Q\_\-INT64 \& {\em reference}, Q\_\-INT64 {\em default\-Value} = {\tt 0}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a18}


Register an item of type Q\_\-INT64. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1067 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemUInt64@{addItemUInt64}}
\index{addItemUInt64@{addItemUInt64}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-UInt64} $\ast$ KConfig\-Skeleton::add\-Item\-UInt64 (const {\bf QString} \& {\em name}, Q\_\-UINT64 \& {\em reference}, Q\_\-UINT64 {\em default\-Value} = {\tt 0}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a19}


Register an item of type Q\_\-UINT64. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1077 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemDouble@{addItemDouble}}
\index{addItemDouble@{addItemDouble}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Double} $\ast$ KConfig\-Skeleton::add\-Item\-Double (const {\bf QString} \& {\em name}, double \& {\em reference}, double {\em default\-Value} = {\tt 0.0}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a20}


Register an item of type double. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1107 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemColor@{addItemColor}}
\index{addItemColor@{addItemColor}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Color} $\ast$ KConfig\-Skeleton::add\-Item\-Color (const {\bf QString} \& {\em name}, {\bf QColor} \& {\em reference}, const {\bf QColor} \& {\em default\-Value} = {\tt {\bf QColor}(128,~128,~128)}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a21}


Register an item of type {\bf QColor}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1117 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemFont@{addItemFont}}
\index{addItemFont@{addItemFont}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Font} $\ast$ KConfig\-Skeleton::add\-Item\-Font (const {\bf QString} \& {\em name}, {\bf QFont} \& {\em reference}, const {\bf QFont} \& {\em default\-Value} = {\tt KGlobalSettings::generalFont()}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a22}


Register an item of type {\bf QFont}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1127 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemRect@{addItemRect}}
\index{addItemRect@{addItemRect}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Rect} $\ast$ KConfig\-Skeleton::add\-Item\-Rect (const {\bf QString} \& {\em name}, {\bf QRect} \& {\em reference}, const {\bf QRect} \& {\em default\-Value} = {\tt {\bf QRect}()}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a23}


Register an item of type {\bf QRect}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1137 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemPoint@{addItemPoint}}
\index{addItemPoint@{addItemPoint}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Point} $\ast$ KConfig\-Skeleton::add\-Item\-Point (const {\bf QString} \& {\em name}, {\bf QPoint} \& {\em reference}, const {\bf QPoint} \& {\em default\-Value} = {\tt {\bf QPoint}()}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a24}


Register an item of type {\bf QPoint}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1147 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemSize@{addItemSize}}
\index{addItemSize@{addItemSize}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Size} $\ast$ KConfig\-Skeleton::add\-Item\-Size (const {\bf QString} \& {\em name}, {\bf QSize} \& {\em reference}, const {\bf QSize} \& {\em default\-Value} = {\tt {\bf QSize}()}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a25}


Register an item of type {\bf QSize}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1157 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemDateTime@{addItemDateTime}}
\index{addItemDateTime@{addItemDateTime}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Date\-Time} $\ast$ KConfig\-Skeleton::add\-Item\-Date\-Time (const {\bf QString} \& {\em name}, {\bf QDate\-Time} \& {\em reference}, const {\bf QDate\-Time} \& {\em default\-Value} = {\tt {\bf QDate\-Time}()}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a26}


Register an item of type {\bf QDate\-Time}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1167 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemStringList@{addItemStringList}}
\index{addItemStringList@{addItemStringList}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-String\-List} $\ast$ KConfig\-Skeleton::add\-Item\-String\-List (const {\bf QString} \& {\em name}, {\bf QString\-List} \& {\em reference}, const {\bf QString\-List} \& {\em default\-Value} = {\tt {\bf QString\-List}()}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a27}


Register an item of type {\bf QString\-List}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1177 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!addItemIntList@{addItemIntList}}
\index{addItemIntList@{addItemIntList}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton::Item\-Int\-List} $\ast$ KConfig\-Skeleton::add\-Item\-Int\-List (const {\bf QString} \& {\em name}, {\bf QValue\-List}$<$ int $>$ \& {\em reference}, const {\bf QValue\-List}$<$ int $>$ \& {\em default\-Value} = {\tt {\bf QValue\-List}$<$~int~$>$()}, const {\bf QString} \& {\em key} = {\tt QString::null})}\label{classKConfigSkeleton_a28}


Register an item of type {\bf QValue\-List$<$int$>$}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name used to indentify this setting. Names must be unique. \item[{\em reference}]Pointer to the variable, which is set by {\bf read\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a4})} calls and read by {\bf write\-Config()}{\rm (p.\,\pageref{classKConfigSkeleton_a5})} calls. \item[{\em default\-Value}]Default value, which is used when the config file does not yet contain the key of this item. \item[{\em key}]Key used in config file. If key is null, name is used as key. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The created item \end{Desc}


Definition at line 1187 of file kconfigskeleton.cpp.

References add\-Item(), and QString::is\-Null().\index{KConfigSkeleton@{KConfig\-Skeleton}!config@{config}}
\index{config@{config}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig} $\ast$ KConfig\-Skeleton::config () const}\label{classKConfigSkeleton_a29}


Return the {\bf KConfig}{\rm (p.\,\pageref{classKConfig})} object used for reading and writing the settings. 



Definition at line 918 of file kconfigskeleton.cpp.\index{KConfigSkeleton@{KConfig\-Skeleton}!items@{items}}
\index{items@{items}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton\-Item::List} KConfig\-Skeleton::items () const\hspace{0.3cm}{\tt  [inline]}}\label{classKConfigSkeleton_a30}


Return list of items managed by this KConfig\-Skeleton object. 



Definition at line 1164 of file kconfigskeleton.h.\index{KConfigSkeleton@{KConfig\-Skeleton}!isImmutable@{isImmutable}}
\index{isImmutable@{isImmutable}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Skeleton::is\-Immutable (const {\bf QString} \& {\em name})}\label{classKConfigSkeleton_a31}


Return whether a certain item is immutable. 



Definition at line 1197 of file kconfigskeleton.cpp.

References find\-Item(), and KConfig\-Skeleton\-Item::is\-Immutable().\index{KConfigSkeleton@{KConfig\-Skeleton}!findItem@{findItem}}
\index{findItem@{findItem}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Skeleton\-Item} $\ast$ KConfig\-Skeleton::find\-Item (const {\bf QString} \& {\em name})}\label{classKConfigSkeleton_a32}


Lookup item by name. 



Definition at line 1203 of file kconfigskeleton.cpp.

References QDict::find().

Referenced by KConfig\-Dialog\-Manager::has\-Changed(), is\-Immutable(), KConfig\-Dialog\-Manager::parse\-Children(), KConfig\-Dialog\-Manager::update\-Settings(), and KConfig\-Dialog\-Manager::update\-Widgets().\index{KConfigSkeleton@{KConfig\-Skeleton}!useDefaults@{useDefaults}}
\index{useDefaults@{useDefaults}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Skeleton::use\-Defaults (bool {\em b})}\label{classKConfigSkeleton_a33}


Indicate whether this object should reflect the actual values or the default values. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em b}]If true this object reflects the default values. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The state prior to this call \end{Desc}


Definition at line 923 of file kconfigskeleton.cpp.

References QValue\-List::begin(), QValue\-List::end(), and usr\-Use\-Defaults().

Referenced by KConfig\-Dialog\-Manager::is\-Default(), and KConfig\-Dialog\-Manager::update\-Widgets\-Default().\index{KConfigSkeleton@{KConfig\-Skeleton}!usrUseDefaults@{usrUseDefaults}}
\index{usrUseDefaults@{usrUseDefaults}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KConfig\-Skeleton::usr\-Use\-Defaults (bool)\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classKConfigSkeleton_b0}


Implemented by subclasses that use special defaults. 

It should replace the default values with the actual values and vice versa. 

Definition at line 1193 of file kconfigskeleton.h.

Referenced by use\-Defaults().\index{KConfigSkeleton@{KConfig\-Skeleton}!usrReadConfig@{usrReadConfig}}
\index{usrReadConfig@{usrReadConfig}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KConfig\-Skeleton::usr\-Read\-Config ()\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classKConfigSkeleton_b2}


Implemented by subclasses that read special config values. 



Definition at line 1204 of file kconfigskeleton.h.

Referenced by read\-Config().\index{KConfigSkeleton@{KConfig\-Skeleton}!usrWriteConfig@{usrWriteConfig}}
\index{usrWriteConfig@{usrWriteConfig}!KConfigSkeleton@{KConfig\-Skeleton}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KConfig\-Skeleton::usr\-Write\-Config ()\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classKConfigSkeleton_b3}


Implemented by subclasses that write special config values. 



Definition at line 1211 of file kconfigskeleton.h.

Referenced by write\-Config().

The documentation for this class was generated from the following files:\begin{CompactItemize}
\item 
kconfigskeleton.h\item 
kconfigskeleton.cpp\end{CompactItemize}
