\section{KKey\-Sequence Class Reference}
\label{classKKeySequence}\index{KKeySequence@{KKeySequence}}
A KKey\-Sequence object holds a sequence of up to 4 keys.  


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

\subsection*{Public Types}
\begin{CompactItemize}
\item 
enum \{ {\bf MAX\_\-KEYS} =  4
 \}
\begin{CompactList}\small\item\em Defines the maximum length of the key sequence. \item\end{CompactList}\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf KKey\-Sequence} ()
\begin{CompactList}\small\item\em Create a new null key sequence. \item\end{CompactList}\item 
{\bf KKey\-Sequence} (const  {\bf QKey\-Sequence} \&key\-Seq)
\begin{CompactList}\small\item\em Copies the given qt key sequence. \item\end{CompactList}\item 
{\bf KKey\-Sequence} (const  KKey \&key)
\begin{CompactList}\small\item\em Create a new key sequence that only contains the given key. \item\end{CompactList}\item 
{\bf KKey\-Sequence} (const  {\bf KKey\-Native} \&key)
\begin{CompactList}\small\item\em Create a new key sequence that only contains the given key. \item\end{CompactList}\item 
{\bf KKey\-Sequence} (const  {\bf KKey\-Sequence} \&key\-Seq)
\begin{CompactList}\small\item\em Copies the given key sequence. \item\end{CompactList}\item 
{\bf KKey\-Sequence} (const  {\bf QString} \&key\-Seq)
\begin{CompactList}\small\item\em Creates a new key sequence that contains the given key sequence. \item\end{CompactList}\item 
void {\bf clear} ()
\begin{CompactList}\small\item\em Clears the key sequence. \item\end{CompactList}\item 
bool {\bf init} (const  {\bf QKey\-Sequence} \&key\-Seq)
\begin{CompactList}\small\item\em Copies the given qt key sequence over this key sequence. \item\end{CompactList}\item 
bool {\bf init} (const  KKey \&key)
\begin{CompactList}\small\item\em Initializes the key sequence to only contain the given key. \item\end{CompactList}\item 
bool {\bf init} (const  {\bf KKey\-Native} \&key)
\begin{CompactList}\small\item\em Initializes the key sequence to only contain the given key. \item\end{CompactList}\item 
bool {\bf init} (const  {\bf KKey\-Sequence} \&key\-Seq)
\begin{CompactList}\small\item\em Copies the given key sequence over this key sequence. \item\end{CompactList}\item 
bool {\bf init} (const  {\bf QString} \&key)
\begin{CompactList}\small\item\em Initializes this key sequence to contain the given key sequence. \item\end{CompactList}\item 
{\bf KKey\-Sequence} \& {\bf operator=} (const  {\bf KKey\-Sequence} \&seq)
\begin{CompactList}\small\item\em Copy the given key sequence into this sequence. \item\end{CompactList}\item 
uint {\bf count} () const 
\begin{CompactList}\small\item\em Returns the number of key strokes of this sequence. \item\end{CompactList}\item 
const  KKey \& {\bf key} (uint i) const 
\begin{CompactList}\small\item\em Return the {\tt i'th} key of this sequence, or a null key if there are less then i keys. \item\end{CompactList}\item 
bool {\bf is\-Trigger\-On\-Release} () const \label{classKKeySequence_a16}

\item 
bool {\bf set\-Key} (uint i, const  KKey \&key)
\begin{CompactList}\small\item\em Sets the {\tt i'th} key of the sequence. \item\end{CompactList}\item 
void {\bf set\-Trigger\-On\-Release} (bool)\label{classKKeySequence_a18}

\item 
bool {\bf is\-Null} () const 
\begin{CompactList}\small\item\em Returns true if the key sequence is null (after {\bf clear}{\rm (p.\,\pageref{classKKeySequence_a7})}() or empty constructor). \item\end{CompactList}\item 
bool {\bf starts\-With} (const  {\bf KKey\-Sequence} \&key\-Seq) const 
\begin{CompactList}\small\item\em Returns true if this key sequence begins with the given sequence. \item\end{CompactList}\item 
int {\bf compare} (const  {\bf KKey\-Sequence} \&key\-Seq) const 
\begin{CompactList}\small\item\em Compares this object with the given key sequence. \item\end{CompactList}\item 
bool {\bf operator==} (const  {\bf KKey\-Sequence} \&seq) const 
\begin{CompactList}\small\item\em Compares the keys of both sequences. \item\end{CompactList}\item 
bool {\bf operator!=} (const  {\bf KKey\-Sequence} \&seq) const 
\begin{CompactList}\small\item\em Compares the keys of both sequences. \item\end{CompactList}\item 
bool {\bf operator$<$} (const  {\bf KKey\-Sequence} \&seq) const 
\begin{CompactList}\small\item\em Compares the keys of both sequences. \item\end{CompactList}\item 
{\bf QKey\-Sequence} {\bf qt} () const 
\begin{CompactList}\small\item\em Converts this key sequence to a {\bf QKey\-Sequence}. \item\end{CompactList}\item 
int {\bf key\-Code\-Qt} () const 
\begin{CompactList}\small\item\em Returns the qt key code of the first key. \item\end{CompactList}\item 
{\bf QString} {\bf to\-String} () const 
\begin{CompactList}\small\item\em Returns the key sequence as a number of key presses as returned by KKey::to\-String(), seperated by commas. \item\end{CompactList}\item 
{\bf QString} {\bf to\-String\-Internal} () const \label{classKKeySequence_a28}

\end{CompactItemize}
\subsection*{Static Public Member Functions}
\begin{CompactItemize}
\item 
{\bf KKey\-Sequence} \& {\bf null} ()
\begin{CompactList}\small\item\em Returns a null key sequence. \item\end{CompactList}\end{CompactItemize}
\subsection*{Protected Attributes}
\begin{CompactItemize}
\item 
uchar {\bf m\_\-n\-Keys}\label{classKKeySequence_p0}

\item 
uchar {\bf m\_\-b\-Trigger\-On\-Release}\label{classKKeySequence_p1}

\item 
KKey {\bf m\_\-rgvar} [MAX\_\-KEYS]\label{classKKeySequence_p2}

\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
class {\bf KKey\-Native}\label{classKKeySequence_n0}

\end{CompactItemize}


\subsection{Detailed Description}
A KKey\-Sequence object holds a sequence of up to 4 keys. 

Ex: Ctrl+X,I \begin{Desc}
\item[See also:]KKey 

KShortcut \end{Desc}




Definition at line 294 of file kshortcut.h.

\subsection{Member Enumeration Documentation}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}anonymous enum}\label{classKKeySequence_w1}


Defines the maximum length of the key sequence. 



Definition at line 298 of file kshortcut.h.

\subsection{Constructor \& Destructor Documentation}
\index{KKeySequence@{KKey\-Sequence}!KKeySequence@{KKeySequence}}
\index{KKeySequence@{KKeySequence}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KKey\-Sequence::KKey\-Sequence ()}\label{classKKeySequence_a0}


Create a new null key sequence. 

\begin{Desc}
\item[See also:]{\bf is\-Null()}{\rm (p.\,\pageref{classKKeySequence_a19})} 

{\bf null()}{\rm (p.\,\pageref{classKKeySequence_e0})} 

{\bf clear()}{\rm (p.\,\pageref{classKKeySequence_a7})}\end{Desc}


Definition at line 207 of file kshortcut.cpp.

References clear().\index{KKeySequence@{KKey\-Sequence}!KKeySequence@{KKeySequence}}
\index{KKeySequence@{KKeySequence}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KKey\-Sequence::KKey\-Sequence (const {\bf QKey\-Sequence} \& {\em key\-Seq})}\label{classKKeySequence_a1}


Copies the given qt key sequence. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key\-Seq}]the qt key sequence to copy\end{description}
\end{Desc}


Definition at line 208 of file kshortcut.cpp.

References init().\index{KKeySequence@{KKey\-Sequence}!KKeySequence@{KKeySequence}}
\index{KKeySequence@{KKeySequence}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KKey\-Sequence::KKey\-Sequence (const KKey \& {\em key})}\label{classKKeySequence_a2}


Create a new key sequence that only contains the given key. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key}]the key to add\end{description}
\end{Desc}


Definition at line 209 of file kshortcut.cpp.

References init(), and KStd\-Accel::key().\index{KKeySequence@{KKey\-Sequence}!KKeySequence@{KKeySequence}}
\index{KKeySequence@{KKeySequence}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KKey\-Sequence::KKey\-Sequence (const {\bf KKey\-Native} \& {\em key})}\label{classKKeySequence_a3}


Create a new key sequence that only contains the given key. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key}]the key to add\end{description}
\end{Desc}
\index{KKeySequence@{KKey\-Sequence}!KKeySequence@{KKeySequence}}
\index{KKeySequence@{KKeySequence}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KKey\-Sequence::KKey\-Sequence (const {\bf KKey\-Sequence} \& {\em key\-Seq})}\label{classKKeySequence_a4}


Copies the given key sequence. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key\-Seq}]the key sequence to copy\end{description}
\end{Desc}


Definition at line 210 of file kshortcut.cpp.

References init().\index{KKeySequence@{KKey\-Sequence}!KKeySequence@{KKeySequence}}
\index{KKeySequence@{KKeySequence}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KKey\-Sequence::KKey\-Sequence (const {\bf QString} \& {\em key\-Seq})}\label{classKKeySequence_a5}


Creates a new key sequence that contains the given key sequence. 

The description consists of comma-separated keys as required by KKey::KKey(const {\bf QString}\&). \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key\-Seq}]the description of the key \end{description}
\end{Desc}
\begin{Desc}
\item[See also:]{\bf KKey\-Server::Sym::init()}{\rm (p.\,\pageref{structKKeyServer_1_1Sym_a4})} 

KKey::KKey(const QString\&)\end{Desc}


Definition at line 211 of file kshortcut.cpp.

References init().

\subsection{Member Function Documentation}
\index{KKeySequence@{KKey\-Sequence}!clear@{clear}}
\index{clear@{clear}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KKey\-Sequence::clear ()}\label{classKKeySequence_a7}


Clears the key sequence. 

The key sequence is null after calling this function. \begin{Desc}
\item[See also:]{\bf is\-Null()}{\rm (p.\,\pageref{classKKeySequence_a19})}\end{Desc}


Definition at line 217 of file kshortcut.cpp.

Referenced by init(), KKey\-Sequence(), and null().\index{KKeySequence@{KKey\-Sequence}!init@{init}}
\index{init@{init}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::init (const {\bf QKey\-Sequence} \& {\em key\-Seq})}\label{classKKeySequence_a8}


Copies the given qt key sequence over this key sequence. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key\-Seq}]the qt key sequence to copy \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true if successful, false otherwise\end{Desc}


Definition at line 223 of file kshortcut.cpp.

References clear(), QKey\-Sequence::count(), and QKey\-Sequence::is\-Empty().

Referenced by KKey\-Sequence(), operator=(), and KStd\-Accel::shortcut\-Default4().\index{KKeySequence@{KKey\-Sequence}!init@{init}}
\index{init@{init}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::init (const KKey \& {\em key})}\label{classKKeySequence_a9}


Initializes the key sequence to only contain the given key. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key}]the key to set \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true if successful, false otherwise\end{Desc}


Definition at line 248 of file kshortcut.cpp.

References clear(), and KStd\-Accel::key().\index{KKeySequence@{KKey\-Sequence}!init@{init}}
\index{init@{init}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::init (const {\bf KKey\-Native} \& {\em key})}\label{classKKeySequence_a10}


Initializes the key sequence to only contain the given key. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key}]the key to set \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true if successful, false otherwise\end{Desc}
\index{KKeySequence@{KKey\-Sequence}!init@{init}}
\index{init@{init}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::init (const {\bf KKey\-Sequence} \& {\em key\-Seq})}\label{classKKeySequence_a11}


Copies the given key sequence over this key sequence. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key\-Seq}]the key sequence to copy \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true if successful, false otherwise\end{Desc}


Definition at line 259 of file kshortcut.cpp.

References m\_\-n\-Keys, and m\_\-rgvar.\index{KKeySequence@{KKey\-Sequence}!init@{init}}
\index{init@{init}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::init (const {\bf QString} \& {\em key})}\label{classKKeySequence_a12}


Initializes this key sequence to contain the given key sequence. 

The description consists of comma-separated keys as required by KKey::KKey(const {\bf QString}\&). \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key}]the description of the key \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true if successful, false otherwise \end{Desc}
\begin{Desc}
\item[See also:]{\bf KKey\-Server::Sym::init()}{\rm (p.\,\pageref{structKKeyServer_1_1Sym_a4})} 

KKey::KKey(const QString\&)\end{Desc}


Definition at line 274 of file kshortcut.cpp.

References clear(), and QString\-List::split().\index{KKeySequence@{KKey\-Sequence}!operator=@{operator=}}
\index{operator=@{operator=}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KKey\-Sequence}\& KKey\-Sequence::operator= (const {\bf KKey\-Sequence} \& {\em seq})\hspace{0.3cm}{\tt  [inline]}}\label{classKKeySequence_a13}


Copy the given key sequence into this sequence. 



Definition at line 393 of file kshortcut.h.

References init().\index{KKeySequence@{KKey\-Sequence}!count@{count}}
\index{count@{count}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}uint KKey\-Sequence::count () const}\label{classKKeySequence_a14}


Returns the number of key strokes of this sequence. 

\begin{Desc}
\item[Returns:]the number of key strokes \end{Desc}
\begin{Desc}
\item[See also:]MAX\_\-KEYS\end{Desc}


Definition at line 295 of file kshortcut.cpp.

Referenced by key\-Code\-Qt(), qt(), and KStd\-Accel::shortcut\-Default4().\index{KKeySequence@{KKey\-Sequence}!key@{key}}
\index{key@{key}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const  KKey \& KKey\-Sequence::key (uint {\em i}) const}\label{classKKeySequence_a15}


Return the {\tt i'th} key of this sequence, or a null key if there are less then i keys. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em i}]the key to retrieve \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\tt i'th} key, or KKey::null() if there are less than i keys \end{Desc}
\begin{Desc}
\item[See also:]MAX\_\-KEYS\end{Desc}


Definition at line 300 of file kshortcut.cpp.

Referenced by key\-Code\-Qt(), and qt().\index{KKeySequence@{KKey\-Sequence}!setKey@{setKey}}
\index{setKey@{setKey}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::set\-Key (uint {\em i}, const KKey \& {\em key})}\label{classKKeySequence_a17}


Sets the {\tt i'th} key of the sequence. 

You can not introduce gaps in a sequence, so you must use an {\tt i} $<$= {\bf count}{\rm (p.\,\pageref{classKKeySequence_a14})}(). Also note that the maximum length of a key sequence is MAX\_\-KEYS. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em i}]the position of the new key ($<$= {\bf count}{\rm (p.\,\pageref{classKKeySequence_a14})}(), $<$= MAX\_\-KEYS) \item[{\em key}]the key to set \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true if successful, false otherwise\end{Desc}


Definition at line 311 of file kshortcut.cpp.

References KStd\-Accel::key().\index{KKeySequence@{KKey\-Sequence}!isNull@{isNull}}
\index{isNull@{isNull}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::is\-Null () const}\label{classKKeySequence_a19}


Returns true if the key sequence is null (after {\bf clear}{\rm (p.\,\pageref{classKKeySequence_a7})}() or empty constructor). 

\begin{Desc}
\item[Returns:]true if the key sequence is null \end{Desc}
\begin{Desc}
\item[See also:]{\bf clear()}{\rm (p.\,\pageref{classKKeySequence_a7})} 

{\bf null()}{\rm (p.\,\pageref{classKKeySequence_e0})}\end{Desc}


Definition at line 322 of file kshortcut.cpp.

Referenced by KStd\-Accel::find\-Std\-Accel(), KShortcut\-List::index(), and null().\index{KKeySequence@{KKey\-Sequence}!startsWith@{startsWith}}
\index{startsWith@{startsWith}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::starts\-With (const {\bf KKey\-Sequence} \& {\em key\-Seq}) const}\label{classKKeySequence_a20}


Returns true if this key sequence begins with the given sequence. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key\-Seq}]the key sequence to search \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true if this key sequence begins with the given sequence\end{Desc}


Definition at line 327 of file kshortcut.cpp.

References m\_\-n\-Keys, and m\_\-rgvar.\index{KKeySequence@{KKey\-Sequence}!compare@{compare}}
\index{compare@{compare}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KKey\-Sequence::compare (const {\bf KKey\-Sequence} \& {\em key\-Seq}) const}\label{classKKeySequence_a21}


Compares this object with the given key sequence. 

Returns a negative number if the given KKey\-Sequence is larger, 0 if they are equal and a positive number this KKey\-Sequence is larger. Key sequences are compared by comparing the individual keys, starting from the beginning until an unequal key has been found. If a sequence contains more keys, it is considered larger. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em key\-Seq}]the key sequence to compare to \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]a negative number if the given KKey\-Sequence is larger, 0 if they are equal and a positive number this KKey\-Sequence is larger \end{Desc}
\begin{Desc}
\item[See also:]KKey::sequence\end{Desc}


Definition at line 340 of file kshortcut.cpp.

References m\_\-n\-Keys, and m\_\-rgvar.

Referenced by operator!=(), operator$<$(), and operator==().\index{KKeySequence@{KKey\-Sequence}!operator==@{operator==}}
\index{operator==@{operator==}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::operator== (const {\bf KKey\-Sequence} \& {\em seq}) const\hspace{0.3cm}{\tt  [inline]}}\label{classKKeySequence_a22}


Compares the keys of both sequences. 

\begin{Desc}
\item[See also:]{\bf compare()}{\rm (p.\,\pageref{classKKeySequence_a21})}\end{Desc}


Definition at line 467 of file kshortcut.h.

References compare().\index{KKeySequence@{KKey\-Sequence}!operator"!=@{operator"!=}}
\index{operator"!=@{operator"!=}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::operator!= (const {\bf KKey\-Sequence} \& {\em seq}) const\hspace{0.3cm}{\tt  [inline]}}\label{classKKeySequence_a23}


Compares the keys of both sequences. 

\begin{Desc}
\item[See also:]{\bf compare()}{\rm (p.\,\pageref{classKKeySequence_a21})}\end{Desc}


Definition at line 474 of file kshortcut.h.

References compare().\index{KKeySequence@{KKey\-Sequence}!operator<@{operator$<$}}
\index{operator<@{operator$<$}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KKey\-Sequence::operator$<$ (const {\bf KKey\-Sequence} \& {\em seq}) const\hspace{0.3cm}{\tt  [inline]}}\label{classKKeySequence_a24}


Compares the keys of both sequences. 

\begin{Desc}
\item[See also:]{\bf compare()}{\rm (p.\,\pageref{classKKeySequence_a21})}\end{Desc}


Definition at line 481 of file kshortcut.h.

References compare().\index{KKeySequence@{KKey\-Sequence}!qt@{qt}}
\index{qt@{qt}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QKey\-Sequence} KKey\-Sequence::qt () const}\label{classKKeySequence_a25}


Converts this key sequence to a {\bf QKey\-Sequence}. 

\begin{Desc}
\item[Returns:]the {\bf QKey\-Sequence}\end{Desc}


Definition at line 353 of file kshortcut.cpp.

References count(), and key().\index{KKeySequence@{KKey\-Sequence}!keyCodeQt@{keyCodeQt}}
\index{keyCodeQt@{keyCodeQt}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KKey\-Sequence::key\-Code\-Qt () const}\label{classKKeySequence_a26}


Returns the qt key code of the first key. 

\begin{Desc}
\item[Returns:]the qt key code of the first key \end{Desc}
\begin{Desc}
\item[See also:]Qt::Key 

KKey::key\-Code\-Qt()\end{Desc}


Definition at line 369 of file kshortcut.cpp.

References count(), and key().\index{KKeySequence@{KKey\-Sequence}!toString@{toString}}
\index{toString@{toString}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KKey\-Sequence::to\-String () const}\label{classKKeySequence_a27}


Returns the key sequence as a number of key presses as returned by KKey::to\-String(), seperated by commas. 

\begin{Desc}
\item[Returns:]the string represenation of this key sequence \end{Desc}
\begin{Desc}
\item[See also:]KKey::to\-String()\end{Desc}


Definition at line 374 of file kshortcut.cpp.\index{KKeySequence@{KKey\-Sequence}!null@{null}}
\index{null@{null}!KKeySequence@{KKey\-Sequence}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf KKey\-Sequence} \& KKey\-Sequence::null ()\hspace{0.3cm}{\tt  [static]}}\label{classKKeySequence_e0}


Returns a null key sequence. 

\begin{Desc}
\item[Returns:]the null key sequence \end{Desc}
\begin{Desc}
\item[See also:]{\bf is\-Null()}{\rm (p.\,\pageref{classKKeySequence_a19})} 

{\bf clear()}{\rm (p.\,\pageref{classKKeySequence_a7})}\end{Desc}


Definition at line 402 of file kshortcut.cpp.

References clear(), and is\-Null().

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