\section{KConfig\-Base Class Reference}
\label{classKConfigBase}\index{KConfigBase@{KConfigBase}}
{\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} Configuration Management abstract base class.  


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

Inheritance diagram for KConfig\-Base:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=156pt]{classKConfigBase__inherit__graph}
\end{center}
\end{figure}
Collaboration diagram for KConfig\-Base:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=162pt]{classKConfigBase__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item 
enum {\bf Config\-State} \{ {\bf No\-Access}, 
{\bf Read\-Only}, 
{\bf Read\-Write}
 \}
\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf KConfig\-Base} ()
\item 
virtual {\bf $\sim$KConfig\-Base} ()
\item 
void {\bf set\-Group} (const {\bf QString} \&group)
\item 
void {\bf set\-Desktop\-Group} ()
\item 
{\bf QString} {\bf group} () const 
\item 
bool {\bf has\-Group} (const {\bf QString} \&group) const 
\item 
virtual {\bf QString\-List} {\bf group\-List} () const =0
\item 
{\bf QString} {\bf locale} () const 
\item 
{\bf QString} {\bf read\-Entry} (const {\bf QString} \&p\-Key, const {\bf QString} \&a\-Default=QString::null) const 
\item 
{\bf QString} {\bf read\-Entry} (const char $\ast$p\-Key, const {\bf QString} \&a\-Default=QString::null) const 
\item 
{\bf QVariant} {\bf read\-Property\-Entry} (const {\bf QString} \&p\-Key, QVariant::Type) const 
\item 
{\bf QVariant} {\bf read\-Property\-Entry} (const char $\ast$p\-Key, QVariant::Type) const 
\item 
{\bf QVariant} {\bf read\-Property\-Entry} (const {\bf QString} \&p\-Key, const {\bf QVariant} \&a\-Default) const 
\item 
{\bf QVariant} {\bf read\-Property\-Entry} (const char $\ast$p\-Key, const {\bf QVariant} \&a\-Default) const 
\item 
int {\bf read\-List\-Entry} (const {\bf QString} \&p\-Key, {\bf QStr\-List} \&list, char sep= ',') const 
\item 
int {\bf read\-List\-Entry} (const char $\ast$p\-Key, {\bf QStr\-List} \&list, char sep= ',') const 
\item 
{\bf QString\-List} {\bf read\-List\-Entry} (const {\bf QString} \&p\-Key, char sep= ',') const 
\item 
{\bf QString\-List} {\bf read\-List\-Entry} (const char $\ast$p\-Key, char sep= ',') const 
\item 
{\bf QString\-List} {\bf read\-List\-Entry} (const char $\ast$p\-Key, const {\bf QString\-List} \&a\-Default, char sep= ',') const 
\item 
{\bf QValue\-List}$<$ int $>$ {\bf read\-Int\-List\-Entry} (const {\bf QString} \&p\-Key) const 
\item 
{\bf QValue\-List}$<$ int $>$ {\bf read\-Int\-List\-Entry} (const char $\ast$p\-Key) const 
\item 
{\bf QString} {\bf read\-Path\-Entry} (const {\bf QString} \&p\-Key, const {\bf QString} \&a\-Default=QString::null) const 
\item 
{\bf QString} {\bf read\-Path\-Entry} (const char $\ast$p\-Key, const {\bf QString} \&a\-Default=QString::null) const 
\item 
{\bf QString\-List} {\bf read\-Path\-List\-Entry} (const {\bf QString} \&p\-Key, char sep= ',') const 
\item 
{\bf QString\-List} {\bf read\-Path\-List\-Entry} (const char $\ast$p\-Key, char sep= ',') const 
\item 
int {\bf read\-Num\-Entry} (const {\bf QString} \&p\-Key, int n\-Default=0) const 
\item 
int {\bf read\-Num\-Entry} (const char $\ast$p\-Key, int n\-Default=0) const 
\item 
unsigned int {\bf read\-Unsigned\-Num\-Entry} (const {\bf QString} \&p\-Key, unsigned int n\-Default=0) const 
\item 
unsigned int {\bf read\-Unsigned\-Num\-Entry} (const char $\ast$p\-Key, unsigned int n\-Default=0) const 
\item 
long {\bf read\-Long\-Num\-Entry} (const {\bf QString} \&p\-Key, long n\-Default=0) const 
\item 
long {\bf read\-Long\-Num\-Entry} (const char $\ast$p\-Key, long n\-Default=0) const 
\item 
unsigned long {\bf read\-Unsigned\-Long\-Num\-Entry} (const {\bf QString} \&p\-Key, unsigned long n\-Default=0) const 
\item 
unsigned long {\bf read\-Unsigned\-Long\-Num\-Entry} (const char $\ast$p\-Key, unsigned long n\-Default=0) const 
\item 
Q\_\-INT64 {\bf read\-Num64Entry} (const {\bf QString} \&p\-Key, Q\_\-INT64 n\-Default=0) const 
\item 
Q\_\-INT64 {\bf read\-Num64Entry} (const char $\ast$p\-Key, Q\_\-INT64 n\-Default=0) const 
\item 
Q\_\-UINT64 {\bf read\-Unsigned\-Num64Entry} (const {\bf QString} \&p\-Key, Q\_\-UINT64 n\-Default=0) const 
\item 
Q\_\-UINT64 {\bf read\-Unsigned\-Num64Entry} (const char $\ast$p\-Key, Q\_\-UINT64 n\-Default=0) const 
\item 
double {\bf read\-Double\-Num\-Entry} (const {\bf QString} \&p\-Key, double n\-Default=0.0) const 
\item 
double {\bf read\-Double\-Num\-Entry} (const char $\ast$p\-Key, double n\-Default=0.0) const 
\item 
{\bf QFont} {\bf read\-Font\-Entry} (const {\bf QString} \&p\-Key, const {\bf QFont} $\ast$p\-Default=0L) const 
\item 
{\bf QFont} {\bf read\-Font\-Entry} (const char $\ast$p\-Key, const {\bf QFont} $\ast$p\-Default=0L) const 
\item 
bool {\bf read\-Bool\-Entry} (const {\bf QString} \&p\-Key, bool b\-Default=false) const 
\item 
bool {\bf read\-Bool\-Entry} (const char $\ast$p\-Key, bool b\-Default=false) const 
\item 
{\bf QRect} {\bf read\-Rect\-Entry} (const {\bf QString} \&p\-Key, const {\bf QRect} $\ast$p\-Default=0L) const 
\item 
{\bf QRect} {\bf read\-Rect\-Entry} (const char $\ast$p\-Key, const {\bf QRect} $\ast$p\-Default=0L) const 
\item 
{\bf QPoint} {\bf read\-Point\-Entry} (const {\bf QString} \&p\-Key, const {\bf QPoint} $\ast$p\-Default=0L) const 
\item 
{\bf QPoint} {\bf read\-Point\-Entry} (const char $\ast$p\-Key, const {\bf QPoint} $\ast$p\-Default=0L) const 
\item 
{\bf QSize} {\bf read\-Size\-Entry} (const {\bf QString} \&p\-Key, const {\bf QSize} $\ast$p\-Default=0L) const 
\item 
{\bf QSize} {\bf read\-Size\-Entry} (const char $\ast$p\-Key, const {\bf QSize} $\ast$p\-Default=0L) const 
\item 
{\bf QColor} {\bf read\-Color\-Entry} (const {\bf QString} \&p\-Key, const {\bf QColor} $\ast$p\-Default=0L) const 
\item 
{\bf QColor} {\bf read\-Color\-Entry} (const char $\ast$p\-Key, const {\bf QColor} $\ast$p\-Default=0L) const 
\item 
{\bf QDate\-Time} {\bf read\-Date\-Time\-Entry} (const {\bf QString} \&p\-Key, const {\bf QDate\-Time} $\ast$p\-Default=0L) const 
\item 
{\bf QDate\-Time} {\bf read\-Date\-Time\-Entry} (const char $\ast$p\-Key, const {\bf QDate\-Time} $\ast$p\-Default=0L) const 
\item 
{\bf QString} {\bf read\-Entry\-Untranslated} (const {\bf QString} \&p\-Key, const {\bf QString} \&a\-Default=QString::null) const 
\item 
{\bf QString} {\bf read\-Entry\-Untranslated} (const char $\ast$p\-Key, const {\bf QString} \&a\-Default=QString::null) const 
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QString} \&p\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QString} \&p\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QVariant} \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QVariant} \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QStr\-List} \&r\-Value, char sep= ',', bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QStr\-List} \&r\-Value, char sep= ',', bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QString\-List} \&r\-Value, char sep= ',', bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QString\-List} \&r\-Value, char sep= ',', bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QValue\-List}$<$ int $>$ \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QValue\-List}$<$ int $>$ \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const char $\ast$p\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const char $\ast$p\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, int n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, int n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, unsigned int n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, unsigned int n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, long n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, long n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, unsigned long n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, unsigned long n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, Q\_\-INT64 n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, Q\_\-INT64 n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, Q\_\-UINT64 n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, Q\_\-UINT64 n\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, double n\-Value, bool b\-Persistent=true, bool b\-Global=false, char format= 'g', int precision=6, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, double n\-Value, bool b\-Persistent=true, bool b\-Global=false, char format= 'g', int precision=6, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, bool b\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, bool b\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QFont} \&r\-Font, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QFont} \&r\-Font, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QColor} \&r\-Color, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QColor} \&r\-Color, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QDate\-Time} \&r\-Date\-Time, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QDate\-Time} \&r\-Date\-Time, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QRect} \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QRect} \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QPoint} \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QPoint} \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const {\bf QString} \&p\-Key, const {\bf QSize} \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Entry} (const char $\ast$p\-Key, const {\bf QSize} \&r\-Value, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Path\-Entry} (const {\bf QString} \&p\-Key, const {\bf QString} \&path, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Path\-Entry} (const char $\ast$p\-Key, const {\bf QString} \&path, bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Path\-Entry} (const {\bf QString} \&p\-Key, const {\bf QString\-List} \&r\-Value, char sep= ',', bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf write\-Path\-Entry} (const char $\ast$p\-Key, const {\bf QString\-List} \&r\-Value, char sep= ',', bool b\-Persistent=true, bool b\-Global=false, bool b\-NLS=false)
\item 
void {\bf delete\-Entry} (const {\bf QString} \&p\-Key, bool b\-NLS=false, bool b\-Global=false)
\item 
void {\bf delete\-Entry} (const char $\ast$p\-Key, bool b\-NLS=false, bool b\-Global=false)
\item 
bool {\bf delete\-Group} (const {\bf QString} \&group, bool b\-Deep=true, bool b\-Global=false)
\item 
void {\bf set\-Dollar\-Expansion} (bool \_\-b\-Expand=true)
\item 
bool {\bf is\-Dollar\-Expansion} () const 
\item 
virtual void {\bf rollback} (bool b\-Deep=true)
\item 
virtual void {\bf sync} ()
\item 
bool {\bf is\-Dirty} () const 
\item 
virtual void {\bf set\-Read\-Only} (bool \_\-ro)
\item 
bool {\bf is\-Read\-Only} () const 
\item 
bool {\bf has\-Key} (const {\bf QString} \&key) const 
\item 
virtual {\bf QMap}$<$ {\bf QString}, {\bf QString} $>$ {\bf entry\-Map} (const {\bf QString} \&group) const =0
\item 
virtual void {\bf reparse\-Configuration} ()=0
\item 
bool {\bf is\-Immutable} () const 
\item 
bool {\bf group\-Is\-Immutable} (const {\bf QString} \&group) const 
\item 
bool {\bf entry\-Is\-Immutable} (const {\bf QString} \&key) const 
\item 
{\bf Config\-State} {\bf get\-Config\-State} () const 
\item 
bool {\bf check\-Config\-Files\-Writable} (bool warn\-User)
\item 
void {\bf set\-Read\-Defaults} (bool b)
\item 
bool {\bf read\-Defaults} () const 
\item 
void {\bf revert\-To\-Default} (const {\bf QString} \&key)
\item 
bool {\bf has\-Default} (const {\bf QString} \&key) const 
\item 
void {\bf set\-Group} (const {\bf QCString} \&p\-Group)
\item 
void {\bf set\-Group} (const char $\ast$p\-Group)\label{classKConfigBase_a122}

\item 
bool {\bf has\-Group} (const {\bf QCString} \&\_\-p\-Group) const \label{classKConfigBase_a123}

\item 
bool {\bf has\-Group} (const char $\ast$\_\-p\-Group) const \label{classKConfigBase_a124}

\item 
bool {\bf has\-Key} (const char $\ast$p\-Key) const \label{classKConfigBase_a125}

\end{CompactItemize}
\subsection*{Protected Member Functions}
\begin{CompactItemize}
\item 
void {\bf set\-Locale} ()
\item 
virtual void {\bf set\-Dirty} (bool \_\-b\-Dirty=true)
\item 
virtual void {\bf parse\-Config\-Files} ()
\item 
virtual KEntry\-Map {\bf internal\-Entry\-Map} (const {\bf QString} \&p\-Group) const =0
\item 
virtual KEntry\-Map {\bf internal\-Entry\-Map} () const =0
\item 
virtual void {\bf put\-Data} (const {\bf KEntry\-Key} \&\_\-key, const {\bf KEntry} \&\_\-data, bool \_\-check\-Group=true)=0
\item 
virtual {\bf KEntry} {\bf lookup\-Data} (const {\bf KEntry\-Key} \&\_\-key) const =0
\item 
virtual bool {\bf internal\-Has\-Group} (const {\bf QCString} \&group) const =0\label{classKConfigBase_b7}

\item 
{\bf QCString} {\bf read\-Entry\-Utf8} (const char $\ast$p\-Key) const \label{classKConfigBase_b8}

\item 
virtual void {\bf virtual\_\-hook} (int id, void $\ast$data)\label{classKConfigBase_b9}

\end{CompactItemize}
\subsection*{Protected Attributes}
\begin{CompactItemize}
\item 
{\bf KConfig\-Back\-End} $\ast$ {\bf back\-End}
\item 
{\bf QCString} {\bf m\-Group}
\item 
{\bf QCString} {\bf a\-Locale\-String}
\item 
bool {\bf b\-Dirty}
\item 
bool {\bf b\-Locale\-Initialized}\label{classKConfigBase_p4}

\item 
bool {\bf b\-Read\-Only}\label{classKConfigBase_p5}

\item 
bool {\bf b\-Expand}\label{classKConfigBase_p6}

\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
class {\bf KConfig\-Back\-End}\label{classKConfigBase_n0}

\item 
class {\bf KConfig\-INIBack\-End}\label{classKConfigBase_n1}

\item 
class {\bf KConfig\-Group}\label{classKConfigBase_n2}

\end{CompactItemize}


\subsection{Detailed Description}
{\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} Configuration Management abstract base class. 

This class forms the base for all KDE configuration. It is an abstract base class, meaning that you cannot directly instantiate objects of this class. Either use {\bf KConfig}{\rm (p.\,\pageref{classKConfig})} (for usual KDE configuration) or {\bf KSimple\-Config}{\rm (p.\,\pageref{classKSimpleConfig})} (for special needs as in ksamba), or even {\bf KShared\-Config}{\rm (p.\,\pageref{classKSharedConfig})} (stores values in shared memory).

All configuration entries are key, value pairs. Each entry also belongs to a specific group of related entries. All configuration entries that do not explicitly specify which group they are in are in a special group called the default group.

If there is a \$ character in an entry, KConfig\-Base tries to expand environment variable and uses its value instead of its name. You can avoid this feature by having two consecutive \$ characters in your config file which get expanded to one.

\begin{Desc}
\item[Note:]the '=' char is not allowed in keys and the ']' char is not allowed in a group name.\end{Desc}
\begin{Desc}
\item[Author:]Kalle Dalheimer $<${\tt kalle@kde.org}$>$, Preston Brown $<${\tt pbrown@kde.org}$>$ \end{Desc}
\begin{Desc}
\item[See also:]{\bf KGlobal::config()}{\rm (p.\,\pageref{classKGlobal_e2})} 

{\bf KConfig}{\rm (p.\,\pageref{classKConfig})} 

{\bf KSimple\-Config}{\rm (p.\,\pageref{classKSimpleConfig})} 

{\bf KShared\-Config}{\rm (p.\,\pageref{classKSharedConfig})} \end{Desc}




Definition at line 70 of file kconfigbase.h.

\subsection{Member Enumeration Documentation}
\index{KConfigBase@{KConfig\-Base}!ConfigState@{ConfigState}}
\index{ConfigState@{ConfigState}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum {\bf KConfig\-Base::Config\-State}}\label{classKConfigBase_w3}


Possible return values for {\bf get\-Config\-State()}{\rm (p.\,\pageref{classKConfigBase_a115})}. 

\begin{Desc}
\item[See also:]{\bf get\-Config\-State()}{\rm (p.\,\pageref{classKConfigBase_a115})} \end{Desc}


Definition at line 1804 of file kconfigbase.h.

\subsection{Constructor \& Destructor Documentation}
\index{KConfigBase@{KConfig\-Base}!KConfigBase@{KConfigBase}}
\index{KConfigBase@{KConfigBase}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KConfig\-Base::KConfig\-Base ()}\label{classKConfigBase_a0}


Construct a KConfig\-Base object. 



Definition at line 50 of file kconfigbase.cpp.

References back\-End, b\-Dirty, and set\-Group().\index{KConfigBase@{KConfig\-Base}!~KConfigBase@{$\sim$KConfigBase}}
\index{~KConfigBase@{$\sim$KConfigBase}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KConfig\-Base::$\sim${\bf KConfig\-Base} ()\hspace{0.3cm}{\tt  [virtual]}}\label{classKConfigBase_a1}


Destructs the KConfig\-Base object. 



Definition at line 57 of file kconfigbase.cpp.

\subsection{Member Function Documentation}
\index{KConfigBase@{KConfig\-Base}!setGroup@{setGroup}}
\index{setGroup@{setGroup}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::set\-Group (const {\bf QString} \& {\em group})}\label{classKConfigBase_a2}


Specifies the group in which keys will be read and written. 

Subsequent calls to {\bf read\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a8})} and {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} will be applied only in the activated group.

Switch back to the default group by passing a null string. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em group}]The name of the new group. \end{description}
\end{Desc}


Definition at line 79 of file kconfigbase.cpp.

References group(), QString::is\-Empty(), m\-Group, and QString::utf8().

Referenced by KConfig::check\-Update(), KNotify\-Client::get\-Default\-File(), KNotify\-Client::get\-Default\-Presentation(), KNotify\-Client::get\-File(), KNotify\-Client::get\-Presentation(), KIcon\-Effect::init(), KApplication::invoke\-Mailer(), KConfig\-Base(), KIcon\-Theme::KIcon\-Theme(), KLocale::languages\-Two\-Alpha(), and KDesktop\-File::set\-Action\-Group().\index{KConfigBase@{KConfig\-Base}!setDesktopGroup@{setDesktopGroup}}
\index{setDesktopGroup@{setDesktopGroup}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::set\-Desktop\-Group ()}\label{classKConfigBase_a3}


Sets the group to the \char`\"{}Desktop Entry\char`\"{} group used for desktop configuration files for applications, mime types, etc. 



Definition at line 104 of file kconfigbase.cpp.

References m\-Group.

Referenced by KDesktop\-File::copy\-To(), and KDesktop\-File::KDesktop\-File().\index{KConfigBase@{KConfig\-Base}!group@{group}}
\index{group@{group}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KConfig\-Base::group () const}\label{classKConfigBase_a4}


Returns the name of the group in which we are searching for keys and from which we are retrieving entries. 

\begin{Desc}
\item[Returns:]The current group. \end{Desc}


Definition at line 100 of file kconfigbase.cpp.

References QString::from\-Utf8(), and m\-Group.

Referenced by KConfig::check\-Update(), delete\-Group(), group\-Is\-Immutable(), has\-Group(), and set\-Group().\index{KConfigBase@{KConfig\-Base}!hasGroup@{hasGroup}}
\index{hasGroup@{hasGroup}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::has\-Group (const {\bf QString} \& {\em group}) const}\label{classKConfigBase_a5}


Returns true if the specified group is known about. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em group}]The group to search for. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true if the group exists. \end{Desc}


Definition at line 134 of file kconfigbase.cpp.

References group(), and QString::utf8().

Referenced by KDesktop\-File::has\-Action\-Group().\index{KConfigBase@{KConfig\-Base}!groupList@{groupList}}
\index{groupList@{groupList}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual {\bf QString\-List} KConfig\-Base::group\-List () const\hspace{0.3cm}{\tt  [pure virtual]}}\label{classKConfigBase_a6}


Returns a list of groups that are known about. 

\begin{Desc}
\item[Returns:]The list of groups. \end{Desc}


Implemented in {\bf KConfig} {\rm (p.\,\pageref{classKConfig_a4})}.\index{KConfigBase@{KConfig\-Base}!locale@{locale}}
\index{locale@{locale}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KConfig\-Base::locale () const}\label{classKConfigBase_a7}


Returns a the current locale. 

\begin{Desc}
\item[Returns:]A string representing the current locale. \end{Desc}


Definition at line 74 of file kconfigbase.cpp.

References a\-Locale\-String, and QString::from\-Utf8().

Referenced by has\-Default(), and revert\-To\-Default().\index{KConfigBase@{KConfig\-Base}!readEntry@{readEntry}}
\index{readEntry@{readEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KConfig\-Base::read\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QString} \& {\em a\-Default} = {\tt QString::null}) const}\label{classKConfigBase_a8}


Reads the value of an entry specified by {\tt p\-Key} in the current group. 

If you want to read a path, please use {\bf read\-Path\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a21})}.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em a\-Default}]A default value returned if the key was not found. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. Can be QString::null if a\-Default is null. \end{Desc}


Definition at line 203 of file kconfigbase.cpp.

Referenced by KGlobal\-Settings::context\-Menu\-Key(), KIcon\-Theme::current(), KDesktop\-File::has\-Application\-Type(), KDesktop\-File::has\-Device\-Type(), KDesktop\-File::has\-Link\-Type(), KDesktop\-File::has\-Mime\-Type\-Type(), KIcon\-Effect::init(), KApplication::invoke\-Mailer(), KIcon\-Theme::KIcon\-Theme(), KGlobal\-Settings::mouse\-Settings(), read\-Color\-Entry(), KDesktop\-File::read\-Comment(), KDesktop\-File::read\-Device(), read\-Font\-Entry(), KDesktop\-File::read\-Generic\-Name(), KDesktop\-File::read\-Icon(), read\-List\-Entry(), KDesktop\-File::read\-Name(), read\-Num64Entry(), read\-Path\-Entry(), read\-Property\-Entry(), KDesktop\-File::read\-Type(), read\-Unsigned\-Num64Entry(), and KDesktop\-File::try\-Exec().\index{KConfigBase@{KConfig\-Base}!readEntry@{readEntry}}
\index{readEntry@{readEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KConfig\-Base::read\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QString} \& {\em a\-Default} = {\tt QString::null}) const}\label{classKConfigBase_a9}


Reads the value of an entry specified by {\tt p\-Key} in the current group. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em a\-Default}]A default value returned if the key was not found. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. Can be QString::null if a\-Default is null. \end{Desc}


Definition at line 209 of file kconfigbase.cpp.

References QString::ascii(), KEntry\-Key::b\-Default, KEntry::b\-Expand, KEntry\-Key::b\-Local, KEntry\-Key::c\_\-key, QString::find(), KString\-Handler::from8Bit(), QString::from\-Utf8(), QString::is\-Empty(), QString::is\-Null(), QCString::is\-Null(), QString::length(), lookup\-Data(), m\-Group, QString::mid(), KEntry::m\-Value, QText\-Stream::read(), read\-Defaults(), QString::remove(), QString::replace(), set\-Locale(), and KGlobal::static\-QString().\index{KConfigBase@{KConfig\-Base}!readPropertyEntry@{readPropertyEntry}}
\index{readPropertyEntry@{readPropertyEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QVariant} KConfig\-Base::read\-Property\-Entry (const {\bf QString} \& {\em p\-Key}, QVariant::Type) const}\label{classKConfigBase_a10}


Reads the value of an entry specified by {\tt p\-Key} in the current group. 

The value is treated as if it is of the given type.

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

\begin{Desc}
\item[{\bf Deprecated}]\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]An invalid {\bf QVariant} if the key was not found or if the read value cannot be converted to the given QVariant::Type. \end{Desc}


Definition at line 333 of file kconfigbase.cpp.

Referenced by read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readPropertyEntry@{readPropertyEntry}}
\index{readPropertyEntry@{readPropertyEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QVariant} KConfig\-Base::read\-Property\-Entry (const char $\ast$ {\em p\-Key}, QVariant::Type) const}\label{classKConfigBase_a11}


Reads the value of an entry specified by {\tt p\-Key} in the current group. 

The value is treated as if it is of the given type.

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

\begin{Desc}
\item[{\bf Deprecated}]\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]An invalid {\bf QVariant} if the key was not found or if the read value cannot be converted to the given QVariant::Type. \end{Desc}


Definition at line 339 of file kconfigbase.cpp.

References QVariant::cast(), has\-Key(), and read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readPropertyEntry@{readPropertyEntry}}
\index{readPropertyEntry@{readPropertyEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QVariant} KConfig\-Base::read\-Property\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QVariant} \& {\em a\-Default}) const}\label{classKConfigBase_a12}


Reads the value of an entry specified by {\tt p\-Key} in the current group. 

The value is treated as if it is of the type of the given default value.

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

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em a\-Default}]A default value returned if the key was not found or if the read value cannot be converted to the QVariant::Type. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for the key or the default value if the key was not found. \end{Desc}


Definition at line 348 of file kconfigbase.cpp.

References read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readPropertyEntry@{readPropertyEntry}}
\index{readPropertyEntry@{readPropertyEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QVariant} KConfig\-Base::read\-Property\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QVariant} \& {\em a\-Default}) const}\label{classKConfigBase_a13}


Reads the value of an entry specified by {\tt p\-Key} in the current group. 

The value is treated as if it is of the type of the given default value.

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

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em a\-Default}]A default value returned if the key was not found or if the read value cannot be converted to the QVariant::Type. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for the key or the default value if the key was not found. \end{Desc}


Definition at line 354 of file kconfigbase.cpp.

References QValue\-List::append(), QVariant::as\-Color(), QVariant::as\-Date\-Time(), QVariant::as\-Font(), QVariant::as\-Point(), QVariant::as\-Rect(), QVariant::as\-Size(), QDate\-Time::date(), has\-Key(), read\-Bool\-Entry(), read\-Color\-Entry(), read\-Date\-Time\-Entry(), read\-Double\-Num\-Entry(), read\-Entry(), read\-Font\-Entry(), read\-List\-Entry(), read\-Num64Entry(), read\-Num\-Entry(), read\-Point\-Entry(), read\-Rect\-Entry(), read\-Size\-Entry(), read\-Unsigned\-Num64Entry(), and read\-Unsigned\-Num\-Entry().\index{KConfigBase@{KConfig\-Base}!readListEntry@{readListEntry}}
\index{readListEntry@{readListEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KConfig\-Base::read\-List\-Entry (const {\bf QString} \& {\em p\-Key}, {\bf QStr\-List} \& {\em list}, char {\em sep} = {\tt ','}) const}\label{classKConfigBase_a14}


Reads a list of strings. 

\begin{Desc}
\item[{\bf Deprecated}]\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em list}]In this object, the read list will be returned. \item[{\em sep}]The list separator (default \char`\"{},\char`\"{}) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The number of entries in the list. \end{Desc}


Definition at line 433 of file kconfigbase.cpp.

Referenced by KConfig::check\-Update(), KIcon\-Theme::KIcon\-Theme(), KLocale::languages\-Two\-Alpha(), KDesktop\-File::read\-Actions(), read\-Date\-Time\-Entry(), read\-Int\-List\-Entry(), read\-List\-Entry(), read\-Path\-List\-Entry(), read\-Property\-Entry(), KDesktop\-File::sort\-Order(), and KDesktop\-File::try\-Exec().\index{KConfigBase@{KConfig\-Base}!readListEntry@{readListEntry}}
\index{readListEntry@{readListEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KConfig\-Base::read\-List\-Entry (const char $\ast$ {\em p\-Key}, {\bf QStr\-List} \& {\em list}, char {\em sep} = {\tt ','}) const}\label{classKConfigBase_a15}


Reads a list of strings. 

\begin{Desc}
\item[{\bf Deprecated}]\end{Desc}
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em list}]In this object, the read list will be returned. \item[{\em sep}]The list separator (default \char`\"{},\char`\"{}) \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The number of entries in the list. \end{Desc}


Definition at line 439 of file kconfigbase.cpp.

References QCString::append(), has\-Key(), QCString::is\-Empty(), QCString::length(), and QCString::truncate().\index{KConfigBase@{KConfig\-Base}!readListEntry@{readListEntry}}
\index{readListEntry@{readListEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString\-List} KConfig\-Base::read\-List\-Entry (const {\bf QString} \& {\em p\-Key}, char {\em sep} = {\tt ','}) const}\label{classKConfigBase_a16}


Reads a list of strings. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The list. Empty if the entry does not exist. \end{Desc}


Definition at line 478 of file kconfigbase.cpp.

References read\-List\-Entry().\index{KConfigBase@{KConfig\-Base}!readListEntry@{readListEntry}}
\index{readListEntry@{readListEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString\-List} KConfig\-Base::read\-List\-Entry (const char $\ast$ {\em p\-Key}, char {\em sep} = {\tt ','}) const}\label{classKConfigBase_a17}


Reads a list of strings. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The list. Empty if the entry does not exist. \end{Desc}


Definition at line 483 of file kconfigbase.cpp.

References has\-Key(), QString::is\-Empty(), QString::length(), read\-Entry(), QString::reserve(), QString::squeeze(), KGlobal::static\-QString(), and QString::truncate().\index{KConfigBase@{KConfig\-Base}!readListEntry@{readListEntry}}
\index{readListEntry@{readListEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString\-List} KConfig\-Base::read\-List\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QString\-List} \& {\em a\-Default}, char {\em sep} = {\tt ','}) const}\label{classKConfigBase_a18}


Reads a list of strings, but returns a default if the key did not exist. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em a\-Default}]The default value to use if the key does not exist. \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The list. Contains {\tt a\-Default} if the Key does not exist. \end{Desc}
\begin{Desc}
\item[Since:]3.3 \end{Desc}


Definition at line 524 of file kconfigbase.cpp.

References has\-Key(), and read\-List\-Entry().\index{KConfigBase@{KConfig\-Base}!readIntListEntry@{readIntListEntry}}
\index{readIntListEntry@{readIntListEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QValue\-List}$<$ int $>$ KConfig\-Base::read\-Int\-List\-Entry (const {\bf QString} \& {\em p\-Key}) const}\label{classKConfigBase_a19}


Reads a list of Integers. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The list. Empty if the entry does not exist. \end{Desc}


Definition at line 533 of file kconfigbase.cpp.

Referenced by KIcon\-Theme::KIcon\-Theme().\index{KConfigBase@{KConfig\-Base}!readIntListEntry@{readIntListEntry}}
\index{readIntListEntry@{readIntListEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QValue\-List}$<$ int $>$ KConfig\-Base::read\-Int\-List\-Entry (const char $\ast$ {\em p\-Key}) const}\label{classKConfigBase_a20}


Reads a list of Integers. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The list. Empty if the entry does not exist. \end{Desc}


Definition at line 538 of file kconfigbase.cpp.

References read\-List\-Entry().\index{KConfigBase@{KConfig\-Base}!readPathEntry@{readPathEntry}}
\index{readPathEntry@{readPathEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KConfig\-Base::read\-Path\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QString} \& {\em a\-Default} = {\tt QString::null}) const}\label{classKConfigBase_a21}


Reads a path. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a path. This means, dollar expansion is activated for this value, so that e.g. \$HOME gets expanded.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em a\-Default}]A default value returned if the key was not found. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. Can be QString::null if a\-Default is null. \end{Desc}


Definition at line 550 of file kconfigbase.cpp.

Referenced by KCharsets::codec\-For\-Name(), KNotify\-Client::get\-Default\-File(), KNotify\-Client::get\-File(), KApplication::invoke\-Mailer(), KIcon\-Theme::KIcon\-Theme(), KDesktop\-File::read\-Doc\-Path(), KDesktop\-File::read\-Path(), KDesktop\-File::read\-URL(), and KDesktop\-File::try\-Exec().\index{KConfigBase@{KConfig\-Base}!readPathEntry@{readPathEntry}}
\index{readPathEntry@{readPathEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KConfig\-Base::read\-Path\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QString} \& {\em a\-Default} = {\tt QString::null}) const}\label{classKConfigBase_a22}


Reads a path. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a path. This means, dollar expansion is activated for this value, so that e.g. \$HOME gets expanded.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em a\-Default}]A default value returned if the key was not found. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. Can be QString::null if a\-Default is null. \end{Desc}


Definition at line 555 of file kconfigbase.cpp.

References read\-Entry().\index{KConfigBase@{KConfig\-Base}!readPathListEntry@{readPathListEntry}}
\index{readPathListEntry@{readPathListEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString\-List} KConfig\-Base::read\-Path\-List\-Entry (const {\bf QString} \& {\em p\-Key}, char {\em sep} = {\tt ','}) const}\label{classKConfigBase_a23}


Reads a list of string paths. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a list of paths. This means, dollar expansion is activated for this value, so that e.g. \$HOME gets expanded.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The list. Empty if the entry does not exist. \end{Desc}
\begin{Desc}
\item[Since:]3.1.3 \end{Desc}


Definition at line 564 of file kconfigbase.cpp.

Referenced by KIcon\-Theme::KIcon\-Theme().\index{KConfigBase@{KConfig\-Base}!readPathListEntry@{readPathListEntry}}
\index{readPathListEntry@{readPathListEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString\-List} KConfig\-Base::read\-Path\-List\-Entry (const char $\ast$ {\em p\-Key}, char {\em sep} = {\tt ','}) const}\label{classKConfigBase_a24}


Reads a list of string paths. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a list of paths. This means, dollar expansion is activated for this value, so that e.g. \$HOME gets expanded.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The list. Empty if the entry does not exist. \end{Desc}
\begin{Desc}
\item[Since:]3.1.3 \end{Desc}


Definition at line 569 of file kconfigbase.cpp.

References read\-List\-Entry().\index{KConfigBase@{KConfig\-Base}!readNumEntry@{readNumEntry}}
\index{readNumEntry@{readNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KConfig\-Base::read\-Num\-Entry (const {\bf QString} \& {\em p\-Key}, int {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a25}


Reads a numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 578 of file kconfigbase.cpp.

Referenced by KGlobal\-Settings::auto\-Select\-Delay(), KGlobal\-Settings::button\-Layout(), KGlobal\-Settings::completion\-Mode(), KGlobal\-Settings::contrast(), KGlobal\-Settings::dnd\-Event\-Delay(), KNotify\-Client::get\-Default\-Presentation(), KNotify\-Client::get\-Presentation(), KGlobal\-Settings::insert\-Tear\-Off\-Handle(), KIcon\-Theme::KIcon\-Theme(), read\-Property\-Entry(), KGlobal\-Settings::splash\-Screen\-Desktop\-Geometry(), and KGlobal\-Settings::visual\-Activate\-Speed().\index{KConfigBase@{KConfig\-Base}!readNumEntry@{readNumEntry}}
\index{readNumEntry@{readNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KConfig\-Base::read\-Num\-Entry (const char $\ast$ {\em p\-Key}, int {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a26}


Reads a numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 583 of file kconfigbase.cpp.

References QCString::is\-Null(), and QCString::to\-Int().\index{KConfigBase@{KConfig\-Base}!readUnsignedNumEntry@{readUnsignedNumEntry}}
\index{readUnsignedNumEntry@{readUnsignedNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned int KConfig\-Base::read\-Unsigned\-Num\-Entry (const {\bf QString} \& {\em p\-Key}, unsigned int {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a27}


Reads an unsigned numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 599 of file kconfigbase.cpp.

Referenced by read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readUnsignedNumEntry@{readUnsignedNumEntry}}
\index{readUnsignedNumEntry@{readUnsignedNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned int KConfig\-Base::read\-Unsigned\-Num\-Entry (const char $\ast$ {\em p\-Key}, unsigned int {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a28}


Reads an unsigned numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 604 of file kconfigbase.cpp.

References QCString::is\-Null(), and QCString::to\-UInt().\index{KConfigBase@{KConfig\-Base}!readLongNumEntry@{readLongNumEntry}}
\index{readLongNumEntry@{readLongNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}long KConfig\-Base::read\-Long\-Num\-Entry (const {\bf QString} \& {\em p\-Key}, long {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a29}


Reads a numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 618 of file kconfigbase.cpp.\index{KConfigBase@{KConfig\-Base}!readLongNumEntry@{readLongNumEntry}}
\index{readLongNumEntry@{readLongNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}long KConfig\-Base::read\-Long\-Num\-Entry (const char $\ast$ {\em p\-Key}, long {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a30}


Reads a numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 623 of file kconfigbase.cpp.

References QCString::is\-Null(), and QCString::to\-Long().\index{KConfigBase@{KConfig\-Base}!readUnsignedLongNumEntry@{readUnsignedLongNumEntry}}
\index{readUnsignedLongNumEntry@{readUnsignedLongNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned long KConfig\-Base::read\-Unsigned\-Long\-Num\-Entry (const {\bf QString} \& {\em p\-Key}, unsigned long {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a31}


Read an unsigned numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 637 of file kconfigbase.cpp.\index{KConfigBase@{KConfig\-Base}!readUnsignedLongNumEntry@{readUnsignedLongNumEntry}}
\index{readUnsignedLongNumEntry@{readUnsignedLongNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}unsigned long KConfig\-Base::read\-Unsigned\-Long\-Num\-Entry (const char $\ast$ {\em p\-Key}, unsigned long {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a32}


Read an unsigned numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 642 of file kconfigbase.cpp.

References QCString::is\-Null(), and QCString::to\-ULong().\index{KConfigBase@{KConfig\-Base}!readNum64Entry@{readNum64Entry}}
\index{readNum64Entry@{readNum64Entry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Q\_\-INT64 KConfig\-Base::read\-Num64Entry (const {\bf QString} \& {\em p\-Key}, Q\_\-INT64 {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a33}


Reads a 64-bit numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 655 of file kconfigbase.cpp.

Referenced by read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readNum64Entry@{readNum64Entry}}
\index{readNum64Entry@{readNum64Entry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Q\_\-INT64 KConfig\-Base::read\-Num64Entry (const char $\ast$ {\em p\-Key}, Q\_\-INT64 {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a34}


Reads a 64-bit numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 660 of file kconfigbase.cpp.

References QString::is\-Null(), read\-Entry(), and QString::to\-Long\-Long().\index{KConfigBase@{KConfig\-Base}!readUnsignedNum64Entry@{readUnsignedNum64Entry}}
\index{readUnsignedNum64Entry@{readUnsignedNum64Entry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Q\_\-UINT64 KConfig\-Base::read\-Unsigned\-Num64Entry (const {\bf QString} \& {\em p\-Key}, Q\_\-UINT64 {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a35}


Read an 64-bit unsigned numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 675 of file kconfigbase.cpp.

Referenced by read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readUnsignedNum64Entry@{readUnsignedNum64Entry}}
\index{readUnsignedNum64Entry@{readUnsignedNum64Entry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Q\_\-UINT64 KConfig\-Base::read\-Unsigned\-Num64Entry (const char $\ast$ {\em p\-Key}, Q\_\-UINT64 {\em n\-Default} = {\tt 0}) const}\label{classKConfigBase_a36}


Read an 64-bit unsigned numerical value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 680 of file kconfigbase.cpp.

References QString::is\-Null(), read\-Entry(), and QString::to\-ULong\-Long().\index{KConfigBase@{KConfig\-Base}!readDoubleNumEntry@{readDoubleNumEntry}}
\index{readDoubleNumEntry@{readDoubleNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double KConfig\-Base::read\-Double\-Num\-Entry (const {\bf QString} \& {\em p\-Key}, double {\em n\-Default} = {\tt 0.0}) const}\label{classKConfigBase_a37}


Reads a floating point value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 694 of file kconfigbase.cpp.

Referenced by KIcon\-Effect::init(), and read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readDoubleNumEntry@{readDoubleNumEntry}}
\index{readDoubleNumEntry@{readDoubleNumEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}double KConfig\-Base::read\-Double\-Num\-Entry (const char $\ast$ {\em p\-Key}, double {\em n\-Default} = {\tt 0.0}) const}\label{classKConfigBase_a38}


Reads a floating point value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it numerically.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em n\-Default}]A default value returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 699 of file kconfigbase.cpp.

References QCString::is\-Null(), and QCString::to\-Double().\index{KConfigBase@{KConfig\-Base}!readFontEntry@{readFontEntry}}
\index{readFontEntry@{readFontEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QFont} KConfig\-Base::read\-Font\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QFont} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a39}


Reads a {\bf QFont} value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a font object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em p\-Default}]A default value (null {\bf QFont} by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 740 of file kconfigbase.cpp.

Referenced by KGlobal\-Settings::fixed\-Font(), KGlobal\-Settings::general\-Font(), KGlobal\-Settings::menu\-Font(), read\-Property\-Entry(), KGlobal\-Settings::taskbar\-Font(), KGlobal\-Settings::tool\-Bar\-Font(), and KGlobal\-Settings::window\-Title\-Font().\index{KConfigBase@{KConfig\-Base}!readFontEntry@{readFontEntry}}
\index{readFontEntry@{readFontEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QFont} KConfig\-Base::read\-Font\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QFont} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a40}


Reads a {\bf QFont} value. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a font object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em p\-Default}]A default value (null {\bf QFont} by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 745 of file kconfigbase.cpp.

References QString::contains(), QString::find(), QFont::from\-String(), QString::is\-Null(), QString::left(), QString::length(), QString::mid(), read\-Entry(), QString::right(), QFont::set\-Family(), QFont::set\-Fixed\-Pitch(), QFont::set\-Italic(), QFont::set\-Point\-Size(), QFont::set\-Raw\-Mode(), QFont::set\-Strike\-Out(), QFont::set\-Style\-Hint(), QFont::set\-Underline(), QFont::set\-Weight(), QString::to\-Int(), and QString::to\-UInt().\index{KConfigBase@{KConfig\-Base}!readBoolEntry@{readBoolEntry}}
\index{readBoolEntry@{readBoolEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::read\-Bool\-Entry (const {\bf QString} \& {\em p\-Key}, bool {\em b\-Default} = {\tt false}) const}\label{classKConfigBase_a41}


Reads a boolean entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a boolean value. Currently \char`\"{}on\char`\"{} and \char`\"{}true\char`\"{} are accepted as true, everything else if false.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em b\-Default}]A default value returned if the key was not found. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 713 of file kconfigbase.cpp.

Referenced by KApplication::authorize(), KApplication::authorize\-Control\-Module(), KApplication::authorize\-Control\-Modules(), KGlobal\-Settings::change\-Cursor\-Over\-Icon(), KGlobal\-Settings::desktop\-Geometry(), KIcon\-Effect::init(), KGlobal\-Settings::insert\-Tear\-Off\-Handle(), KNotify\-Client::Instance::Instance(), KApplication::invoke\-Mailer(), KIcon\-Theme::KIcon\-Theme(), KGlobal\-Settings::opaque\-Resize(), read\-Property\-Entry(), KGlobal\-Settings::shade\-Sort\-Column(), KGlobal\-Settings::show\-Context\-Menus\-On\-Press(), KGlobal\-Settings::show\-File\-Preview(), KGlobal\-Settings::show\-Icons\-On\-Push\-Buttons(), KGlobal\-Settings::single\-Click(), KGlobal\-Settings::splash\-Screen\-Desktop\-Geometry(), KDesktop\-File::try\-Exec(), KGlobal\-Settings::visual\-Activate(), and KGlobal\-Settings::wheel\-Mouse\-Zooms().\index{KConfigBase@{KConfig\-Base}!readBoolEntry@{readBoolEntry}}
\index{readBoolEntry@{readBoolEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::read\-Bool\-Entry (const char $\ast$ {\em p\-Key}, bool {\em b\-Default} = {\tt false}) const}\label{classKConfigBase_a42}


Reads a boolean entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a boolean value. Currently \char`\"{}on\char`\"{} and \char`\"{}true\char`\"{} are accepted as true, everything else if false.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em b\-Default}]A default value returned if the key was not found. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 718 of file kconfigbase.cpp.

References QCString::is\-Null(), and QCString::to\-Int().\index{KConfigBase@{KConfig\-Base}!readRectEntry@{readRectEntry}}
\index{readRectEntry@{readRectEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QRect} KConfig\-Base::read\-Rect\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QRect} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a43}


Reads a {\bf QRect} entry. 

Read the value of an entry specified by p\-Key in the current group and interpret it as a {\bf QRect} object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em p\-Default}]A default value (null {\bf QRect} by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 837 of file kconfigbase.cpp.

Referenced by read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readRectEntry@{readRectEntry}}
\index{readRectEntry@{readRectEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QRect} KConfig\-Base::read\-Rect\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QRect} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a44}


Reads a {\bf QRect} entry. 

Read the value of an entry specified by p\-Key in the current group and interpret it as a {\bf QRect} object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em p\-Default}]A default value (null {\bf QRect} by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 842 of file kconfigbase.cpp.

References QCString::is\-Empty().\index{KConfigBase@{KConfig\-Base}!readPointEntry@{readPointEntry}}
\index{readPointEntry@{readPointEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QPoint} KConfig\-Base::read\-Point\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QPoint} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a45}


Reads a {\bf QPoint} entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a {\bf QPoint} object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em p\-Default}]A default value (null {\bf QPoint} by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 861 of file kconfigbase.cpp.

Referenced by read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readPointEntry@{readPointEntry}}
\index{readPointEntry@{readPointEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QPoint} KConfig\-Base::read\-Point\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QPoint} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a46}


Reads a {\bf QPoint} entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a {\bf QPoint} object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em p\-Default}]A default value (null {\bf QPoint} by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 867 of file kconfigbase.cpp.

References QCString::is\-Empty().\index{KConfigBase@{KConfig\-Base}!readSizeEntry@{readSizeEntry}}
\index{readSizeEntry@{readSizeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QSize} KConfig\-Base::read\-Size\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QSize} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a47}


Reads a {\bf QSize} entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a {\bf QSize} object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em p\-Default}]A default value (null {\bf QSize} by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 886 of file kconfigbase.cpp.

Referenced by read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readSizeEntry@{readSizeEntry}}
\index{readSizeEntry@{readSizeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QSize} KConfig\-Base::read\-Size\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QSize} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a48}


Reads a {\bf QSize} entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a {\bf QSize} object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for \item[{\em p\-Default}]A default value (null {\bf QSize} by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 892 of file kconfigbase.cpp.

References QCString::is\-Empty().\index{KConfigBase@{KConfig\-Base}!readColorEntry@{readColorEntry}}
\index{readColorEntry@{readColorEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QColor} KConfig\-Base::read\-Color\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QColor} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a49}


Reads a {\bf QColor} entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a color.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em p\-Default}]A default value (null {\bf QColor} by default) returned if the key was not found or if the value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 912 of file kconfigbase.cpp.

Referenced by KGlobal\-Settings::active\-Text\-Color(), KGlobal\-Settings::active\-Title\-Color(), KGlobal\-Settings::alternate\-Background\-Color(), KGlobal\-Settings::base\-Color(), KGlobal\-Settings::button\-Background(), KGlobal\-Settings::button\-Text\-Color(), KGlobal\-Settings::highlight\-Color(), KGlobal\-Settings::highlighted\-Text\-Color(), KGlobal\-Settings::inactive\-Text\-Color(), KGlobal\-Settings::inactive\-Title\-Color(), KIcon\-Effect::init(), KGlobal\-Settings::link\-Color(), read\-Property\-Entry(), KGlobal\-Settings::text\-Color(), KGlobal\-Settings::tool\-Bar\-Highlight\-Color(), and KGlobal\-Settings::visited\-Link\-Color().\index{KConfigBase@{KConfig\-Base}!readColorEntry@{readColorEntry}}
\index{readColorEntry@{readColorEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QColor} KConfig\-Base::read\-Color\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QColor} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a50}


Reads a {\bf QColor} entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a color.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em p\-Default}]A default value (null {\bf QColor} by default) returned if the key was not found or if the value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 918 of file kconfigbase.cpp.

References QString::at(), QString::find(), QString::is\-Empty(), QString::left(), QString::length(), QString::mid(), read\-Entry(), QString::right(), QColor::set\-Named\-Color(), QColor::set\-Rgb(), and QString::to\-Int().\index{KConfigBase@{KConfig\-Base}!readDateTimeEntry@{readDateTimeEntry}}
\index{readDateTimeEntry@{readDateTimeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QDate\-Time} KConfig\-Base::read\-Date\-Time\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QDate\-Time} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a51}


Reads a {\bf QDate\-Time} entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a date and time.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em p\-Default}]A default value ( current\-Date\-Time() by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 977 of file kconfigbase.cpp.

Referenced by read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!readDateTimeEntry@{readDateTimeEntry}}
\index{readDateTimeEntry@{readDateTimeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QDate\-Time} KConfig\-Base::read\-Date\-Time\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QDate\-Time} $\ast$ {\em p\-Default} = {\tt 0L}) const}\label{classKConfigBase_a52}


Reads a {\bf QDate\-Time} entry. 

Read the value of an entry specified by {\tt p\-Key} in the current group and interpret it as a date and time.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em p\-Default}]A default value ( current\-Date\-Time() by default) returned if the key was not found or if the read value cannot be interpreted. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 984 of file kconfigbase.cpp.

References QDate\-Time::current\-Date\-Time(), has\-Key(), and read\-List\-Entry().\index{KConfigBase@{KConfig\-Base}!readEntryUntranslated@{readEntryUntranslated}}
\index{readEntryUntranslated@{readEntryUntranslated}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KConfig\-Base::read\-Entry\-Untranslated (const {\bf QString} \& {\em p\-Key}, const {\bf QString} \& {\em a\-Default} = {\tt QString::null}) const}\label{classKConfigBase_a53}


Reads the value of an entry specified by {\tt p\-Key} in the current group. 

The untranslated entry is returned, you normally do not need this.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em a\-Default}]A default value returned if the key was not found. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 186 of file kconfigbase.cpp.\index{KConfigBase@{KConfig\-Base}!readEntryUntranslated@{readEntryUntranslated}}
\index{readEntryUntranslated@{readEntryUntranslated}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KConfig\-Base::read\-Entry\-Untranslated (const char $\ast$ {\em p\-Key}, const {\bf QString} \& {\em a\-Default} = {\tt QString::null}) const}\label{classKConfigBase_a54}


Reads the value of an entry specified by {\tt p\-Key} in the current group. 

The untranslated entry is returned, you normally do not need this.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to search for. \item[{\em a\-Default}]A default value returned if the key was not found. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The value for this key. \end{Desc}


Definition at line 193 of file kconfigbase.cpp.

References QString::from\-Utf8(), and QCString::is\-Null().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QString} \& {\em p\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a55}


Writes a key/value pair. 

This is stored in the most specific config file when destroying the config object or when calling {\bf sync()}{\rm (p.\,\pageref{classKConfigBase_a105})}.

If you want to write a path, please use {\bf write\-Path\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a95})}.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em p\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1009 of file kconfigbase.cpp.

Referenced by write\-Entry(), and write\-Path\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QString} \& {\em p\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a56}


Writes a key/value pair. 

This is stored in the most specific config file when destroying the config object or when calling {\bf sync()}{\rm (p.\,\pageref{classKConfigBase_a105})}.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em p\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1017 of file kconfigbase.cpp.

References KEntry::b\-Dirty, KEntry::b\-Global, KEntry\-Key::b\-Local, KEntry::b\-NLS, m\-Group, KEntry::m\-Value, put\-Data(), set\-Dirty(), and set\-Locale().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QVariant} \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a57}


{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} Overridden to accept a property. 

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The property to write \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} \end{Desc}


Definition at line 1214 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QVariant} \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a58}


{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} Overridden to accept a property. 

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The property to write \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} \end{Desc}


Definition at line 1221 of file kconfigbase.cpp.

References QValue\-List::begin(), QValue\-List::end(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QStr\-List} \& {\em r\-Value}, char {\em sep} = {\tt ','}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a59}


{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} overridden to accept a list of strings. 

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The list to write \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} \end{Desc}


Definition at line 1313 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QStr\-List} \& {\em r\-Value}, char {\em sep} = {\tt ','}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a60}


{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} overridden to accept a list of strings. 

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The list to write \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} \end{Desc}


Definition at line 1320 of file kconfigbase.cpp.

References QString::at(), KString\-Handler::from8Bit(), QString::length(), QString::truncate(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QString\-List} \& {\em r\-Value}, char {\em sep} = {\tt ','}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a61}


{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} overridden to accept a list of strings. 

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The list to write \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} \end{Desc}


Definition at line 1352 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QString\-List} \& {\em r\-Value}, char {\em sep} = {\tt ','}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a62}


{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} overridden to accept a list of strings. 

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The list to write \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} \end{Desc}


Definition at line 1359 of file kconfigbase.cpp.

References QString::at(), QString::length(), QString::reserve(), QString::truncate(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QValue\-List}$<$ int $>$ \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a63}


{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} overridden to accept a list of Integers. 

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The list to write \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} \end{Desc}


Definition at line 1388 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QValue\-List}$<$ int $>$ \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a64}


{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} overridden to accept a list of Integers. 

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The list to write \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} \end{Desc}


Definition at line 1394 of file kconfigbase.cpp.

References QString::number(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const char $\ast$ {\em p\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})\hspace{0.3cm}{\tt  [inline]}}\label{classKConfigBase_a65}


Write a (key/value) pair. 

This is stored to the most specific config file when destroying the config object or when calling {\bf sync()}{\rm (p.\,\pageref{classKConfigBase_a105})}.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em p\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 978 of file kconfigbase.h.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const char $\ast$ {\em p\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})\hspace{0.3cm}{\tt  [inline]}}\label{classKConfigBase_a66}


Write a (key/value) pair. 

This is stored to the most specific config file when destroying the config object or when calling {\bf sync()}{\rm (p.\,\pageref{classKConfigBase_a105})}.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em p\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 999 of file kconfigbase.h.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, int {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a67}


Write a (key/value) pair. 

Same as above, but writes a numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1404 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, int {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a68}


Write a (key/value) pair. 

Same as above, but writes a numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1411 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, unsigned int {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a69}


Writes a (key/value) pair. 

Same as above, but writes an unsigned numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1419 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, unsigned int {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a70}


Writes a (key/value) pair. 

Same as above, but writes an unsigned numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1426 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, long {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a71}


Writes a (key/value) pair. 

Same as above, but write a long numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1434 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, long {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a72}


Writes a (key/value) pair. 

Same as above, but write a long numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1441 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, unsigned long {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a73}


Writes a (key/value) pair. 

Same as above, but writes an unsigned long numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1449 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, unsigned long {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a74}


Writes a (key/value) pair. 

Same as above, but writes an unsigned long numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1456 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, Q\_\-INT64 {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a75}


Writes a (key/value) pair. 

Same as above, but write a 64-bit numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1463 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, Q\_\-INT64 {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a76}


Writes a (key/value) pair. 

Same as above, but write a long numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1470 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, Q\_\-UINT64 {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a77}


Writes a (key/value) pair. 

Same as above, but writes an unsigned 64-bit numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1478 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, Q\_\-UINT64 {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a78}


Writes a (key/value) pair. 

Same as above, but writes an unsigned 64-bit numerical value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1485 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, double {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, char {\em format} = {\tt 'g'}, int {\em precision} = {\tt 6}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a79}


Writes a (key/value) pair. 

Same as above, but writes a floating-point value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em format}]{\tt format} determines the format to which the value is converted. Default is 'g'. \item[{\em precision}]{\tt precision} sets the precision with which the value is converted. Default is 6 as in {\bf QString}. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1492 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, double {\em n\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, char {\em format} = {\tt 'g'}, int {\em precision} = {\tt 6}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a80}


Writes a (key/value) pair. 

Same as above, but writes a floating-point value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em n\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em format}]{\tt format} determines the format to which the value is converted. Default is 'g'. \item[{\em precision}]{\tt precision} sets the precision with which the value is converted. Default is 6 as in {\bf QString}. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1501 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, bool {\em b\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a81}


Writes a (key/value) pair. 

Same as above, but writes a boolean value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em b\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1511 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, bool {\em b\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a82}


Writes a (key/value) pair. 

Same as above, but writes a boolean value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em b\-Value}]The value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1519 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QFont} \& {\em r\-Font}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a83}


Writes a (key/value) pair. 

Same as above, but writes a font value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Font}]The font value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1535 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QFont} \& {\em r\-Font}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a84}


Writes a (key/value) pair. 

Same as above, but writes a font value.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Font}]The font value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1542 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QColor} \& {\em r\-Color}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a85}


Writes a (key/value) pair. 

Same as above, but write a color entry.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Color}]The color value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1611 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QColor} \& {\em r\-Color}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a86}


Writes a (key/value) pair. 

Same as above, but write a color entry.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Color}]The color value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1619 of file kconfigbase.cpp.

References QString::sprintf(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QDate\-Time} \& {\em r\-Date\-Time}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a87}


Writes a (key/value) pair. 

Same as above, but writes a date and time entry.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is {\em not\/} returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Date\-Time}]The date and time value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1633 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QDate\-Time} \& {\em r\-Date\-Time}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a88}


Writes a (key/value) pair. 

Same as above, but writes a date and time entry.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is {\em not\/} returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Date\-Time}]The date and time value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1640 of file kconfigbase.cpp.

References QDate::day(), QTime::hour(), QTime::minute(), QDate::month(), QTime::second(), QCString::set\-Num(), write\-Entry(), and QDate::year().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QRect} \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a89}


Writes a (key/value) pair. 

Same as above, but writes a rectangle.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Value}]The rectangle value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1550 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QRect} \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a90}


Writes a (key/value) pair. 

Same as above, but writes a rectangle.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Value}]The rectangle value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1557 of file kconfigbase.cpp.

References QCString::set\-Num(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QPoint} \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a91}


Writes a (key/value) pair. 

Same as above, but writes a point.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Value}]The point value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1572 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QPoint} \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a92}


Writes a (key/value) pair. 

Same as above, but writes a point.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Value}]The point value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1579 of file kconfigbase.cpp.

References QCString::set\-Num(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QSize} \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a93}


Writes a (key/value) pair. 

Same as above, but writes a size.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Value}]The size value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1592 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!writeEntry@{writeEntry}}
\index{writeEntry@{writeEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QSize} \& {\em r\-Value}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a94}


Writes a (key/value) pair. 

Same as above, but writes a size.

Note: Unlike the other {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} functions, the old value is \_\-not\_\- returned here!

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em r\-Value}]The size value to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1599 of file kconfigbase.cpp.

References QCString::set\-Num(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!writePathEntry@{writePathEntry}}
\index{writePathEntry@{writePathEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Path\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QString} \& {\em path}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a95}


Writes a file path. 

It is checked whether the path is located under \$HOME. If so the path is written out with the user's home-directory replaced with \$HOME. The path should be read back with {\bf read\-Path\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a21})}

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em path}]The path to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1048 of file kconfigbase.cpp.

Referenced by write\-Path\-Entry().\index{KConfigBase@{KConfig\-Base}!writePathEntry@{writePathEntry}}
\index{writePathEntry@{writePathEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Path\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QString} \& {\em path}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a96}


Writes a file path. 

It is checked whether the path is located under \$HOME. If so the path is written out with the user's home-directory replaced with \$HOME. The path should be read back with {\bf read\-Path\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a21})}

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write. \item[{\em path}]The path to write. \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back. \end{description}
\end{Desc}


Definition at line 1117 of file kconfigbase.cpp.\index{KConfigBase@{KConfig\-Base}!writePathEntry@{writePathEntry}}
\index{writePathEntry@{writePathEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Path\-Entry (const {\bf QString} \& {\em p\-Key}, const {\bf QString\-List} \& {\em r\-Value}, char {\em sep} = {\tt ','}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a97}


{\bf write\-Path\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a95})} overridden to accept a list of paths (strings). 

It is checked whether the paths are located under \$HOME. If so each of the paths are written out with the user's home-directory replaced with \$HOME. The paths should be read back with {\bf read\-Path\-List\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a23})}

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The list to write \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Path\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a95})} 

{\bf read\-Path\-List\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a23})} \end{Desc}
\begin{Desc}
\item[Since:]3.1.3 \end{Desc}


Definition at line 1124 of file kconfigbase.cpp.

References write\-Path\-Entry().\index{KConfigBase@{KConfig\-Base}!writePathEntry@{writePathEntry}}
\index{writePathEntry@{writePathEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::write\-Path\-Entry (const char $\ast$ {\em p\-Key}, const {\bf QString\-List} \& {\em r\-Value}, char {\em sep} = {\tt ','}, bool {\em b\-Persistent} = {\tt true}, bool {\em b\-Global} = {\tt false}, bool {\em b\-NLS} = {\tt false})}\label{classKConfigBase_a98}


{\bf write\-Path\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a95})} overridden to accept a list of paths (strings). 

It is checked whether the paths are located under \$HOME. If so each of the paths are written out with the user's home-directory replaced with \$HOME. The paths should be read back with {\bf read\-Path\-List\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a23})}

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to write \item[{\em r\-Value}]The list to write \item[{\em sep}]The list separator (default is \char`\"{},\char`\"{}). \item[{\em b\-Persistent}]If {\tt b\-Persistent} is false, the entry's dirty flag will not be set and thus the entry will not be written to disk at deletion time. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not saved to the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the locale tag is added to the key when writing it back.\end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf write\-Path\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a95})} 

{\bf read\-Path\-List\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a23})} \end{Desc}
\begin{Desc}
\item[Since:]3.1.3 \end{Desc}


Definition at line 1131 of file kconfigbase.cpp.

References write\-Entry().\index{KConfigBase@{KConfig\-Base}!deleteEntry@{deleteEntry}}
\index{deleteEntry@{deleteEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::delete\-Entry (const {\bf QString} \& {\em p\-Key}, bool {\em b\-NLS} = {\tt false}, bool {\em b\-Global} = {\tt false})}\label{classKConfigBase_a99}


Deletes the entry specified by {\tt p\-Key} in the current group. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to delete. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not removed from the application specific config file, but to the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the key with the locale tag is removed. \end{description}
\end{Desc}


Definition at line 1150 of file kconfigbase.cpp.\index{KConfigBase@{KConfig\-Base}!deleteEntry@{deleteEntry}}
\index{deleteEntry@{deleteEntry}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::delete\-Entry (const char $\ast$ {\em p\-Key}, bool {\em b\-NLS} = {\tt false}, bool {\em b\-Global} = {\tt false})}\label{classKConfigBase_a100}


Deletes the entry specified by {\tt p\-Key} in the current group. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Key}]The key to delete. \item[{\em b\-Global}]If {\tt b\-Global} is true, the pair is not removed from the application specific config file, but from the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \item[{\em b\-NLS}]If {\tt b\-NLS} is true, the key with the locale tag is removed. \end{description}
\end{Desc}


Definition at line 1157 of file kconfigbase.cpp.

References KEntry::b\-Deleted, KEntry::b\-Dirty, KEntry::b\-Global, KEntry::b\-NLS, m\-Group, put\-Data(), set\-Dirty(), and set\-Locale().\index{KConfigBase@{KConfig\-Base}!deleteGroup@{deleteGroup}}
\index{deleteGroup@{deleteGroup}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::delete\-Group (const {\bf QString} \& {\em group}, bool {\em b\-Deep} = {\tt true}, bool {\em b\-Global} = {\tt false})}\label{classKConfigBase_a101}


Deletes a configuration entry group. 

If the group is not empty and b\-Deep is false, nothing gets deleted and false is returned. If this group is the current group and it is deleted, the current group is undefined and should be set with {\bf set\-Group()}{\rm (p.\,\pageref{classKConfigBase_a2})} before the next operation on the configuration object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em group}]The name of the group \item[{\em b\-Deep}]Specify whether non-empty groups should be completely deleted (including their entries). \item[{\em b\-Global}]If {\tt b\-Global} is true, the group is not removed from the application specific config file, but from the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]If the group is not empty and b\-Deep is false, delete\-Group returns false. \end{Desc}


Definition at line 1183 of file kconfigbase.cpp.

References KEntry::b\-Deleted, KEntry::b\-Dirty, KEntry::b\-Global, group(), internal\-Entry\-Map(), KEntry::m\-Value, put\-Data(), and set\-Dirty().

Referenced by KConfig\-Group::delete\-Group(), and KShortcut\-List::write\-Settings().\index{KConfigBase@{KConfig\-Base}!setDollarExpansion@{setDollarExpansion}}
\index{setDollarExpansion@{setDollarExpansion}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::set\-Dollar\-Expansion (bool {\em \_\-b\-Expand} = {\tt true})\hspace{0.3cm}{\tt  [inline]}}\label{classKConfigBase_a102}


Turns on or off \char`\"{}dollar  expansion\char`\"{} (see KConfig\-Base introduction) when reading config entries. 

Dollar sign expansion is initially OFF.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-b\-Expand}]Tf true, dollar expansion is turned on. \end{description}
\end{Desc}


Definition at line 1678 of file kconfigbase.h.\index{KConfigBase@{KConfig\-Base}!isDollarExpansion@{isDollarExpansion}}
\index{isDollarExpansion@{isDollarExpansion}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::is\-Dollar\-Expansion () const\hspace{0.3cm}{\tt  [inline]}}\label{classKConfigBase_a103}


Returns whether dollar expansion is on or off. 

It is initially OFF.

\begin{Desc}
\item[Returns:]true if dollar expansion is on. \end{Desc}


Definition at line 1685 of file kconfigbase.h.\index{KConfigBase@{KConfig\-Base}!rollback@{rollback}}
\index{rollback@{rollback}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::rollback (bool {\em b\-Deep} = {\tt true})\hspace{0.3cm}{\tt  [virtual]}}\label{classKConfigBase_a104}


Mark the config object as \char`\"{}clean,\char`\"{} i.e. 

don't write dirty entries at destruction time. If {\tt b\-Deep} is false, only the global dirty flag of the {\bf KConfig}{\rm (p.\,\pageref{classKConfig})} object gets cleared. If you then call {\bf write\-Entry()}{\rm (p.\,\pageref{classKConfigBase_a55})} again, the global dirty flag is set again and all dirty entries will be written at a subsequent {\bf sync()}{\rm (p.\,\pageref{classKConfigBase_a105})} call.

Classes that derive from KConfig\-Base should override this method and implement storage-specific behavior, as well as calling the {\bf KConfig\-Base::rollback()}{\rm (p.\,\pageref{classKConfigBase_a104})} explicitly in the initializer.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em b\-Deep}]If true, the dirty flags of all entries are cleared, as well as the global dirty flag. \end{description}
\end{Desc}


Reimplemented in {\bf KConfig} {\rm (p.\,\pageref{classKConfig_a3})}.

Definition at line 1690 of file kconfigbase.cpp.

References b\-Dirty.

Referenced by KConfig::rollback(), and sync().\index{KConfigBase@{KConfig\-Base}!sync@{sync}}
\index{sync@{sync}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::sync ()\hspace{0.3cm}{\tt  [virtual]}}\label{classKConfigBase_a105}


Flushes all changes that currently reside only in memory back to disk / permanent storage. 

Dirty configuration entries are written to the most specific file available.

Asks the back end to flush out all pending writes, and then calls {\bf rollback()}{\rm (p.\,\pageref{classKConfigBase_a104})}. No changes are made if the object has {\tt read\-Only} status.

You should call this from your destructor in derivative classes.

\begin{Desc}
\item[See also:]{\bf rollback()}{\rm (p.\,\pageref{classKConfigBase_a104})}, {\bf is\-Read\-Only()}{\rm (p.\,\pageref{classKConfigBase_a108})} \end{Desc}


Reimplemented in {\bf KConfig\-Group} {\rm (p.\,\pageref{classKConfigGroup_a8})}, and {\bf KSimple\-Config} {\rm (p.\,\pageref{classKSimpleConfig_a3})}.

Definition at line 1673 of file kconfigbase.cpp.

References back\-End, b\-Dirty, is\-Read\-Only(), rollback(), and KConfig\-Back\-End::sync().

Referenced by KConfig\-Group::sync(), and KConfig::$\sim$KConfig().\index{KConfigBase@{KConfig\-Base}!isDirty@{isDirty}}
\index{isDirty@{isDirty}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::is\-Dirty () const\hspace{0.3cm}{\tt  [inline]}}\label{classKConfigBase_a106}


Checks whether the config file has any dirty (modified) entries. 

\begin{Desc}
\item[Returns:]true if the config file has any dirty (modified) entries. \end{Desc}


Definition at line 1722 of file kconfigbase.h.

Referenced by KSimple\-Config::sync(), and KConfig\-INIBack\-End::sync().\index{KConfigBase@{KConfig\-Base}!setReadOnly@{setReadOnly}}
\index{setReadOnly@{setReadOnly}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KConfig\-Base::set\-Read\-Only (bool {\em \_\-ro})\hspace{0.3cm}{\tt  [inline, virtual]}}\label{classKConfigBase_a107}


Sets the config object's read-only status. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-ro}]If true, the config object will not write out any changes to disk even if it is destroyed or {\bf sync()}{\rm (p.\,\pageref{classKConfigBase_a105})} is called. \end{description}
\end{Desc}


Definition at line 1731 of file kconfigbase.h.

Referenced by KConfig::KConfig(), KDesktop\-File::KDesktop\-File(), and KSimple\-Config::KSimple\-Config().\index{KConfigBase@{KConfig\-Base}!isReadOnly@{isReadOnly}}
\index{isReadOnly@{isReadOnly}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::is\-Read\-Only () const\hspace{0.3cm}{\tt  [inline]}}\label{classKConfigBase_a108}


Returns the read-only status of the config object. 

\begin{Desc}
\item[Returns:]The read-only status. \end{Desc}


Definition at line 1738 of file kconfigbase.h.

Referenced by KConfig\-INIBack\-End::parse\-Config\-Files(), KConfig::reparse\-Configuration(), KSimple\-Config::sync(), sync(), and KConfig\-INIBack\-End::write\-Config\-File().\index{KConfigBase@{KConfig\-Base}!hasKey@{hasKey}}
\index{hasKey@{hasKey}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::has\-Key (const {\bf QString} \& {\em key}) const}\label{classKConfigBase_a109}


Checks whether the key has an entry in the currently active group. 

Use this to determine whether a key is not specified for the current group ({\bf has\-Key()}{\rm (p.\,\pageref{classKConfigBase_a109})} returns false). Keys with null data are considered nonexistent.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key}]The key to search for. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]If true, the key is available. \end{Desc}


Definition at line 109 of file kconfigbase.cpp.

Referenced by KLocale::languages\-Two\-Alpha(), read\-Date\-Time\-Entry(), KDesktop\-File::read\-Doc\-Path(), read\-List\-Entry(), and read\-Property\-Entry().\index{KConfigBase@{KConfig\-Base}!entryMap@{entryMap}}
\index{entryMap@{entryMap}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual {\bf QMap}$<${\bf QString}, {\bf QString}$>$ KConfig\-Base::entry\-Map (const {\bf QString} \& {\em group}) const\hspace{0.3cm}{\tt  [pure virtual]}}\label{classKConfigBase_a110}


Returns a map (tree) of entries for all entries in a particular group. 

Only the actual entry string is returned, none of the other internal data should be included.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em group}]A group to get keys from. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]A map of entries in the group specified, indexed by key. The returned map may be empty if the group is not found. \end{Desc}
\begin{Desc}
\item[See also:]{\bf QMap} \end{Desc}


Implemented in {\bf KConfig} {\rm (p.\,\pageref{classKConfig_a5})}.\index{KConfigBase@{KConfig\-Base}!reparseConfiguration@{reparseConfiguration}}
\index{reparseConfiguration@{reparseConfiguration}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KConfig\-Base::reparse\-Configuration ()\hspace{0.3cm}{\tt  [pure virtual]}}\label{classKConfigBase_a111}


Reparses all configuration files. 

This is useful for programs that use stand alone graphical configuration tools. The base method implemented here only clears the group list and then appends the default group.

Derivative classes should clear any internal data structures and then simply call {\bf parse\-Config\-Files()}{\rm (p.\,\pageref{classKConfigBase_b2})} when implementing this method.

\begin{Desc}
\item[See also:]{\bf parse\-Config\-Files()}{\rm (p.\,\pageref{classKConfigBase_b2})} \end{Desc}


Implemented in {\bf KConfig} {\rm (p.\,\pageref{classKConfig_a6})}.\index{KConfigBase@{KConfig\-Base}!isImmutable@{isImmutable}}
\index{isImmutable@{isImmutable}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::is\-Immutable () const}\label{classKConfigBase_a112}


Checks whether this configuration file can be modified. 

\begin{Desc}
\item[Returns:]whether changes may be made to this configuration file. \end{Desc}


Definition at line 149 of file kconfigbase.cpp.

References get\-Config\-State().\index{KConfigBase@{KConfig\-Base}!groupIsImmutable@{groupIsImmutable}}
\index{groupIsImmutable@{groupIsImmutable}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::group\-Is\-Immutable (const {\bf QString} \& {\em group}) const}\label{classKConfigBase_a113}


Checks whether it is possible to change the given group. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em group}]the group to check \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]whether changes may be made to {\tt group} in this configuration file. \end{Desc}


Definition at line 154 of file kconfigbase.cpp.

References KEntry::b\-Immutable, get\-Config\-State(), group(), lookup\-Data(), and QString::utf8().

Referenced by KConfig\-Group::group\-Is\-Immutable().\index{KConfigBase@{KConfig\-Base}!entryIsImmutable@{entryIsImmutable}}
\index{entryIsImmutable@{entryIsImmutable}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::entry\-Is\-Immutable (const {\bf QString} \& {\em key}) const}\label{classKConfigBase_a114}


Checks whether it is possible to change the given entry. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key}]the key to check \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]whether the entry {\tt key} may be changed in the current group in this configuration file. \end{Desc}


Definition at line 164 of file kconfigbase.cpp.

References KEntry::b\-Immutable, KEntry\-Key::b\-Local, KEntry\-Key::c\_\-key, get\-Config\-State(), lookup\-Data(), and m\-Group.\index{KConfigBase@{KConfig\-Base}!getConfigState@{getConfigState}}
\index{getConfigState@{getConfigState}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Base::Config\-State} KConfig\-Base::get\-Config\-State () const}\label{classKConfigBase_a115}


Returns the state of the app-config object. 

Possible return values are No\-Access (the application-specific config file could not be opened neither read-write nor read-only), Read\-Only (the application-specific config file is opened read-only, but not read-write) and Read\-Write (the application-specific config file is opened read-write).

\begin{Desc}
\item[See also:]{\bf Config\-State()}{\rm (p.\,\pageref{classKConfigBase_w3})} \end{Desc}
\begin{Desc}
\item[Returns:]the state of the app-config object \end{Desc}


Definition at line 1684 of file kconfigbase.cpp.

References back\-End, and KConfig\-Back\-End::get\-Config\-State().

Referenced by entry\-Is\-Immutable(), group\-Is\-Immutable(), and is\-Immutable().\index{KConfigBase@{KConfig\-Base}!checkConfigFilesWritable@{checkConfigFilesWritable}}
\index{checkConfigFilesWritable@{checkConfigFilesWritable}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::check\-Config\-Files\-Writable (bool {\em warn\-User})}\label{classKConfigBase_a116}


Check whether the config files are writable. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em warn\-User}]Warn the user if the configuration files are not writable. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]Indicates that all of the configuration files used are writable. \end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 1839 of file kconfigbase.cpp.

References back\-End, and KConfig\-Back\-End::check\-Config\-Files\-Writable().\index{KConfigBase@{KConfig\-Base}!setReadDefaults@{setReadDefaults}}
\index{setReadDefaults@{setReadDefaults}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::set\-Read\-Defaults (bool {\em b})}\label{classKConfigBase_a117}


When set, all read\-Entry and read\-XXXEntry calls return the system wide (default) values instead of the user's preference. 

This is off by default. \begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 1696 of file kconfigbase.cpp.

Referenced by KConfig\-Group::KConfig\-Group().\index{KConfigBase@{KConfig\-Base}!readDefaults@{readDefaults}}
\index{readDefaults@{readDefaults}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::read\-Defaults () const}\label{classKConfigBase_a118}


\begin{Desc}
\item[Returns:]true if all read\-Entry and read\-XXXEntry calls return the system wide (default) values instead of the user's preference. \end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 1707 of file kconfigbase.cpp.

Referenced by KConfig\-Group::KConfig\-Group(), and read\-Entry().\index{KConfigBase@{KConfig\-Base}!revertToDefault@{revertToDefault}}
\index{revertToDefault@{revertToDefault}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::revert\-To\-Default (const {\bf QString} \& {\em key})}\label{classKConfigBase_a119}


Reverts the entry with key {\tt key} in the current group in the application specific config file to either the system wide (default) value or the value specified in the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. 

To revert entries in the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file, the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file should be opened explicitly in a separate config object.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key}]The key of the entry to revert. \end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 1712 of file kconfigbase.cpp.

References KEntry::b\-Deleted, KEntry::b\-Dirty, QCString::is\-Null(), locale(), lookup\-Data(), m\-Group, KEntry::m\-Value, put\-Data(), and set\-Dirty().\index{KConfigBase@{KConfig\-Base}!hasDefault@{hasDefault}}
\index{hasDefault@{hasDefault}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KConfig\-Base::has\-Default (const {\bf QString} \& {\em key}) const}\label{classKConfigBase_a120}


Returns whether a default is specified for an entry in either the system wide configuration file or the global {\bf KDE}{\rm (p.\,\pageref{namespaceKDE})} config file. 

If an application computes a default value at runtime for a certain entry, e.g. like: 

\footnotesize\begin{verbatim} QColor computedDefault = kapp->palette().color(QPalette::Active, QColorGroup::Text)
 QColor color = config->readEntry(key, computedDefault);
 \encode

 Then it may wish to make the following check before
 writing back changes:
 \code
 if ( (value == computedDefault) && !config->hasDefault(key) )
    config->revertToDefault(key)
 else
    config->writeEntry(key, value)
\end{verbatim}
\normalsize


This ensures that as long as the entry is not modified to differ from the computed default, the application will keep using the computed default and will follow changes the computed default makes over time. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key}]The key of the entry to check. \end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 1739 of file kconfigbase.cpp.

References QCString::is\-Null(), locale(), lookup\-Data(), m\-Group, and KEntry::m\-Value.\index{KConfigBase@{KConfig\-Base}!setLocale@{setLocale}}
\index{setLocale@{setLocale}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::set\-Locale ()\hspace{0.3cm}{\tt  [protected]}}\label{classKConfigBase_b0}


Reads the locale and put in the configuration data struct. 

Note that this should be done in the constructor, but this is not possible due to some mutual dependencies in KApplication::init() 

Definition at line 62 of file kconfigbase.cpp.

References a\-Locale\-String, back\-End, KLocale::default\-Language(), KLocale::language(), KGlobal::locale(), KConfig\-Back\-End::set\-Locale\-String(), and QString::utf8().

Referenced by delete\-Entry(), parse\-Config\-Files(), read\-Entry(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!setDirty@{setDirty}}
\index{setDirty@{setDirty}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KConfig\-Base::set\-Dirty (bool {\em \_\-b\-Dirty} = {\tt true})\hspace{0.3cm}{\tt  [inline, protected, virtual]}}\label{classKConfigBase_b1}


Sets the global dirty flag of the config object. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-b\-Dirty}]How to mark the object's dirty status \end{description}
\end{Desc}


Reimplemented in {\bf KConfig\-Group} {\rm (p.\,\pageref{classKConfigGroup_a5})}.

Definition at line 1898 of file kconfigbase.h.

Referenced by delete\-Entry(), delete\-Group(), revert\-To\-Default(), KConfig\-Group::set\-Dirty(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!parseConfigFiles@{parseConfigFiles}}
\index{parseConfigFiles@{parseConfigFiles}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::parse\-Config\-Files ()\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKConfigBase_b2}


Parses all configuration files for a configuration object. 

The actual parsing is done by the associated {\bf KConfig\-Back\-End}{\rm (p.\,\pageref{classKConfigBackEnd})}. 

Definition at line 1661 of file kconfigbase.cpp.

References back\-End, KConfig\-Back\-End::get\-Config\-State(), KConfig\-Back\-End::parse\-Config\-Files(), and set\-Locale().

Referenced by KConfig::reparse\-Configuration().\index{KConfigBase@{KConfig\-Base}!internalEntryMap@{internalEntryMap}}
\index{internalEntryMap@{internalEntryMap}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual KEntry\-Map KConfig\-Base::internal\-Entry\-Map (const {\bf QString} \& {\em p\-Group}) const\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classKConfigBase_b3}


Returns a map (tree) of the entries in the specified group. 

This may or may not return all entries that belong to the config object. The only guarantee that you are given is that any entries that are dirty (i.e. modified and not yet written back to the disk) will be contained in the map. Some derivative classes may choose to return everything.

Do not use this function, the implementation / return type are subject to change.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em p\-Group}]The group to provide a KEntry\-Map for. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The map of the entries in the group. \end{Desc}


Implemented in {\bf KConfig} {\rm (p.\,\pageref{classKConfig_b1})}.\index{KConfigBase@{KConfig\-Base}!internalEntryMap@{internalEntryMap}}
\index{internalEntryMap@{internalEntryMap}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual KEntry\-Map KConfig\-Base::internal\-Entry\-Map () const\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classKConfigBase_b4}


Returns a map (tree) of the entries in the tree. 

Do not use this function, the implementation / return type are subject to change.

\begin{Desc}
\item[Returns:]A map of the entries in the tree. \end{Desc}


Implemented in {\bf KConfig} {\rm (p.\,\pageref{classKConfig_b2})}.

Referenced by delete\-Group().\index{KConfigBase@{KConfig\-Base}!putData@{putData}}
\index{putData@{putData}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KConfig\-Base::put\-Data (const {\bf KEntry\-Key} \& {\em \_\-key}, const {\bf KEntry} \& {\em \_\-data}, bool {\em \_\-check\-Group} = {\tt true})\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classKConfigBase_b5}


Inserts a (key/value) pair into the internal storage mechanism of the configuration object. 

Classes that derive from KConfig\-Base will need to implement this method in a storage-specific manner.

Do not use this function, the implementation / return type are subject to change.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-key}]The key to insert. It contains information both on the group of the key and the key itself. If the key already exists, the old value will be replaced. \item[{\em \_\-data}]the {\bf KEntry}{\rm (p.\,\pageref{structKEntry})} that is to be stored. \item[{\em \_\-check\-Group}]When false, assume that the group already exists. \end{description}
\end{Desc}


Implemented in {\bf KConfig} {\rm (p.\,\pageref{classKConfig_b3})}, and {\bf KConfig\-Group} {\rm (p.\,\pageref{classKConfigGroup_a6})}.

Referenced by delete\-Entry(), delete\-Group(), KConfig\-INIBack\-End::parse\-Single\-Config\-File(), KConfig\-Group::put\-Data(), revert\-To\-Default(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!lookupData@{lookupData}}
\index{lookupData@{lookupData}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual {\bf KEntry} KConfig\-Base::lookup\-Data (const {\bf KEntry\-Key} \& {\em \_\-key}) const\hspace{0.3cm}{\tt  [protected, pure virtual]}}\label{classKConfigBase_b6}


Looks up an entry in the config object's internal structure. 

Classes that derive from KConfig\-Base will need to implement this method in a storage-specific manner.

Do not use this function, the implementation and return type are subject to change.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em \_\-key}]The key to look up It contains information both on the group of the key and the entry's key itself. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]The {\bf KEntry}{\rm (p.\,\pageref{structKEntry})} value (data) found for the key. {\tt KEntry.a\-Value} will be the null string if nothing was located. \end{Desc}


Implemented in {\bf KConfig} {\rm (p.\,\pageref{classKConfig_b4})}, and {\bf KConfig\-Group} {\rm (p.\,\pageref{classKConfigGroup_a7})}.

Referenced by entry\-Is\-Immutable(), group\-Is\-Immutable(), has\-Default(), KConfig\-Group::lookup\-Data(), KConfig\-INIBack\-End::parse\-Single\-Config\-File(), read\-Entry(), and revert\-To\-Default().\index{KConfigBase@{KConfig\-Base}!setGroup@{setGroup}}
\index{setGroup@{setGroup}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KConfig\-Base::set\-Group (const {\bf QCString} \& {\em p\-Group})}\label{classKConfigBase_a121}


Overloaded public methods:. 



Definition at line 92 of file kconfigbase.cpp.

References group(), QString::is\-Empty(), and m\-Group.

\subsection{Member Data Documentation}
\index{KConfigBase@{KConfig\-Base}!backEnd@{backEnd}}
\index{backEnd@{backEnd}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KConfig\-Back\-End}$\ast$ {\bf KConfig\-Base::back\-End}\hspace{0.3cm}{\tt  [protected]}}\label{classKConfigBase_p0}


A back end for loading/saving to disk in a particular format. 



Definition at line 1975 of file kconfigbase.h.

Referenced by check\-Config\-Files\-Writable(), KConfig::copy\-To(), get\-Config\-State(), KConfig\-Base(), KConfig\-Group::KConfig\-Group(), parse\-Config\-Files(), set\-Locale(), and sync().\index{KConfigBase@{KConfig\-Base}!mGroup@{mGroup}}
\index{mGroup@{mGroup}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QCString} {\bf KConfig\-Base::m\-Group}\hspace{0.3cm}{\tt  [protected]}}\label{classKConfigBase_p1}


The currently selected group. 



Definition at line 1991 of file kconfigbase.h.

Referenced by delete\-Entry(), entry\-Is\-Immutable(), group(), has\-Default(), read\-Entry(), revert\-To\-Default(), set\-Desktop\-Group(), set\-Group(), and write\-Entry().\index{KConfigBase@{KConfig\-Base}!aLocaleString@{aLocaleString}}
\index{aLocaleString@{aLocaleString}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QCString} {\bf KConfig\-Base::a\-Locale\-String}\hspace{0.3cm}{\tt  [protected]}}\label{classKConfigBase_p2}


The locale to retrieve keys under if possible, i.e en\_\-US or fr. 



Definition at line 1995 of file kconfigbase.h.

Referenced by KConfig\-Group::KConfig\-Group(), locale(), and set\-Locale().\index{KConfigBase@{KConfig\-Base}!bDirty@{bDirty}}
\index{bDirty@{bDirty}!KConfigBase@{KConfig\-Base}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool {\bf KConfig\-Base::b\-Dirty}\hspace{0.3cm}{\tt  [protected]}}\label{classKConfigBase_p3}


Indicates whether there are any dirty entries in the config object that need to be written back to disk. 



Definition at line 2000 of file kconfigbase.h.

Referenced by KConfig\-Base(), rollback(), and sync().

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