home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / kshortcut.h < prev    next >
Encoding:
C/C++ Source or Header  |  2005-10-10  |  22.0 KB  |  852 lines
  1. /*  This file is part of the KDE libraries
  2.     Copyright (C) 2001,2002 Ellis Whitehead <ellis@kde.org>
  3.  
  4.     This library is free software; you can redistribute it and/or
  5.     modify it under the terms of the GNU Library General Public
  6.     License as published by the Free Software Foundation; either
  7.     version 2 of the License, or (at your option) any later version.
  8.  
  9.     This library is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.     Library General Public License for more details.
  13.  
  14.     You should have received a copy of the GNU Library General Public License
  15.     along with this library; see the file COPYING.LIB.  If not, write to
  16.     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17.     Boston, MA 02110-1301, USA.
  18. */
  19.  
  20. #ifndef __KSHORTCUT_H
  21. #define __KSHORTCUT_H
  22.  
  23. #include <qkeysequence.h>
  24. #include <qstring.h>
  25. #include "kdelibs_export.h"
  26.  
  27. class QKeyEvent;
  28. class KKeyNative;
  29.  
  30. /**
  31. * A KKey object represents a single key with possible modifiers
  32. * (Shift, Ctrl, Alt, Win).  It can represent both keys which are
  33. * understood by Qt as well as those which are additionally supported
  34. * by the underlying system (e.g. X11).
  35. * @see KKeyNative
  36. * @see KKeySequence
  37. * @see KShortcut
  38. */
  39.  
  40. class KDECORE_EXPORT KKey
  41. {
  42.  public:
  43.         /**
  44.      * The number of flags.
  45.      * @see ModFlag
  46.      */
  47.     enum { MOD_FLAG_COUNT = 4 };
  48.     enum { QtWIN = (Qt::META) };
  49.     /**
  50.      * Flags to represent the modifiers. You can combine modifiers
  51.      * by ORing them.
  52.      */
  53.     enum ModFlag {
  54.         SHIFT = 0x01,
  55.         CTRL = 0x02,
  56.         ALT = 0x04,
  57.         WIN = 0x08
  58.     };
  59.  
  60.     /**
  61.      * Creates a new null KKey.
  62.      * @see clear()
  63.      * @see isNull()
  64.      * @see null()
  65.      */
  66.     KKey();
  67.  
  68.     /**
  69.      * Creates a new key for the given Qt key code.
  70.      * @param keyQt the qt keycode
  71.      * @see Qt::Key
  72.      */
  73.     KKey( int keyQt );
  74.  
  75.     /**
  76.      * Creates a new key from the first key code of the given key sequence.
  77.      * @param keySeq the key sequence that contains the key
  78.      */
  79.     KKey( const QKeySequence& keySeq );
  80.  
  81.     /**
  82.      * Extracts the key from the given key event.
  83.      * @param keyEvent the key event to get the key from
  84.      */
  85.     KKey( const QKeyEvent* keyEvent );
  86.  
  87.     /**
  88.      * Copy constructor.
  89.      */
  90.     KKey( const KKey& key );
  91.  
  92.     /**
  93.      * Creates a new key from the given description. The form of the description
  94.      * is "[modifier+[modifier+]]+key", for example "e", "CTRL+q" or
  95.      * "CTRL+ALT+DEL". Allowed modifiers are "SHIFT", "CTRL", "ALT", "WIN" and
  96.      * "META". "WIN" and "META" are equivalent. Modifiers are not case-sensitive.
  97.      * @param key the description of the key
  98.      * @see KKeyServer::Sym::init()
  99.      */
  100.     KKey( const QString& key );
  101.     /**
  102.      * @internal
  103.      */
  104.     KKey( uint key, uint mod );
  105.     ~KKey();
  106.  
  107.  // Initialization methods
  108.     /**
  109.      * Clears the key. The key is null after calling this function.
  110.      * @see isNull()
  111.      */
  112.     void clear();
  113.  
  114.     /**
  115.      * Initializes the key with the given Qt key code.
  116.      * @param keyQt the qt keycode
  117.      * @return true if successful, false otherwise
  118.      * @see Qt::Key
  119.      */
  120.     bool init( int keyQt );
  121.  
  122.     /**
  123.      * Initializes the key with the first key code of the given key sequence.
  124.      * @param keySeq the key sequence that contains the key
  125.      * @return true if successful, false otherwise
  126.      */
  127.     bool init( const QKeySequence& keySeq );
  128.  
  129.     /**
  130.      * Initializes the key by extracting the code from the given key event.
  131.      * @param keyEvent the key event to get the key from
  132.      * @return true if successful, false otherwise
  133.      */
  134.     bool init( const QKeyEvent* keyEvent );
  135.  
  136.     /**
  137.      * Copies the given key.
  138.      * @param key the key to copy
  139.      * @return true if successful, false otherwise
  140.      */
  141.     bool init( const KKey& key );
  142.  
  143.     /**
  144.      * Initializes the key with the given description. The form of the description
  145.      * is "[modifier+[modifier+]]+key", for example "e", "CTRL+q" or
  146.      * "CTRL+ALT+DEL". Allowed modifiers are "SHIFT", "CTRL", "ALT", "WIN" and
  147.      * "META". "WIN" and "META" are equivalent. Modifiers are not case-sensitive.
  148.      * @param key the description of the key
  149.      * @return true if successful, false otherwise
  150.      * @see KKeyServer::Sym::init()
  151.      */
  152.     bool init( const QString& key);
  153.  
  154.     /**
  155.      * @internal
  156.      */
  157.     bool init( uint key, uint mod );
  158.  
  159.     /**
  160.      * Copies the key.
  161.      */
  162.     KKey& operator =( const KKey& key )
  163.         { init( key ); return *this; }
  164.  
  165.  // Query methods.
  166.     /**
  167.      * Returns true if the key is null (after clear() or empty
  168.      * constructor).
  169.      * @return true if the key is null
  170.      * @see clear()
  171.      * @see null()
  172.      */
  173.     bool isNull() const;
  174.  
  175.     /**
  176.      * @internal
  177.      */
  178.     uint sym() const;
  179.     /**
  180.      * @internal
  181.      */
  182.     uint modFlags() const;
  183.  
  184.  // Comparison Methods
  185.     /**
  186.      * Compares this key with the given KKey object. Returns a negative
  187.      * number if the given KKey is larger, 0 if they are equal and
  188.      * a positive number this KKey is larger. The returned value
  189.      * is the difference between the symbol or, if the symbols
  190.      * are equal, the difference between the encoded modifiers.
  191.      * @param key the key to compare with this key
  192.      * @return a negative number if the given KKey is larger, 0 if
  193.      * they are equal and a positive number this KKey is larger
  194.      */
  195.     int compare( const KKey& key ) const;
  196.  
  197.     /**
  198.      * Compares the symbol and modifiers of both keys.
  199.      * @see compare()
  200.      */
  201.     bool operator == ( const KKey& key ) const
  202.         { return compare( key ) == 0; }
  203.     /**
  204.      * Compares the symbol and modifiers of both keys.
  205.      * @see compare()
  206.      */
  207.     bool operator != ( const KKey& key ) const
  208.         { return compare( key ) != 0; }
  209.     /**
  210.      * Compares the symbol and modifiers of both keys.
  211.      * @see compare()
  212.      */
  213.     bool operator < ( const KKey& key ) const
  214.         { return compare( key ) < 0; }
  215.  
  216.  // Conversion methods.
  217.     /**
  218.      * Returns the qt key code.
  219.      * @return the qt key code or 0 if there is no key set.
  220.      * @see Qt::Key
  221.      */
  222.     int keyCodeQt() const;
  223.  
  224.     /**
  225.      * Returns a human-readable representation of the key in the form
  226.      * "modifier+key". Note that the representation is localised,
  227.      * use toStringInternal() for cases like saving to configuration files.
  228.      * @return the string representation of the key
  229.      * @see toStringInternal()
  230.      */
  231.     QString toString() const;
  232.  
  233.     /**
  234.      * Returns an untranslated text representation of the key in the form
  235.      * "modifier+key", suitable e.g. for saving in configuration files.
  236.      */
  237.     QString toStringInternal() const;
  238.  
  239.  // Operation methods
  240.     /**
  241.      * @internal
  242.      */
  243.     void simplify();
  244.  
  245.     /**
  246.      * Returns a null key.
  247.      * @return the null key
  248.      * @see isNull()
  249.      * @see clear()
  250.      */
  251.     static KKey& null();
  252.  
  253.     /**
  254.      * Returns a user-readable representation of the given modifiers.
  255.      * @param f the modifiers to convert
  256.      * @return the string representation of the modifiers
  257.      */
  258.     static QString modFlagLabel( ModFlag f );
  259.  
  260.  private:
  261.     /*
  262.      * Under X11, m_key will hold an X11 key symbol.
  263.      * For Qt/Embedded, it will hold the Qt key code.
  264.      */
  265.     /**
  266.      * Returns the native key symbol value key.  Under X11, this is the X
  267.      * keycode.  Under Qt/Embedded, this is the Qt keycode.
  268.      * @see /usr/include/X11/keysymdef.h
  269.      * @see qnamespace.h
  270.      */
  271.     uint m_sym;
  272.     /**
  273.      * m_mod holds the
  274.      */
  275.     uint m_mod;
  276.  
  277.  private:
  278.     friend class KKeyNative;
  279. };
  280.  
  281. /**
  282. * A KKeySequence object holds a sequence of up to 4 keys.
  283. * Ex: Ctrl+X,I
  284. * @see KKey
  285. * @see KShortcut
  286. */
  287.  
  288. class KDECORE_EXPORT KKeySequence
  289. {
  290.  public:
  291.         /// Defines the maximum length of the key sequence
  292.         enum { MAX_KEYS = 4 };
  293.  
  294.     /**
  295.      * Create a new null key sequence.
  296.      * @see isNull()
  297.      * @see null()
  298.      * @see clear()
  299.      */
  300.     KKeySequence();
  301.  
  302.     /**
  303.      * Copies the given qt key sequence.
  304.      * @param keySeq the qt key sequence to copy
  305.      */
  306.     KKeySequence( const QKeySequence& keySeq );
  307.  
  308.     /**
  309.      * Create a new key sequence that only contains the given key.
  310.      * @param key the key to add
  311.      */
  312.     KKeySequence( const KKey& key );
  313.  
  314.     /**
  315.      * Create a new key sequence that only contains the given key.
  316.      * @param key the key to add
  317.      */
  318.     KKeySequence( const KKeyNative& key );
  319.  
  320.     /**
  321.      * Copies the given key sequence.
  322.      * @param keySeq the key sequence to copy
  323.      */
  324.     KKeySequence( const KKeySequence& keySeq );
  325.  
  326.     /**
  327.      * Creates a new key sequence that contains the given key sequence.
  328.      * The description consists of comma-separated keys as
  329.      * required by KKey::KKey(const QString&).
  330.      * @param keySeq the description of the key
  331.      * @see KKeyServer::Sym::init()
  332.      * @see KKey::KKey(const QString&)
  333.      */
  334.     KKeySequence( const QString& keySeq );
  335.  
  336.     ~KKeySequence();
  337.  
  338.     /**
  339.      * Clears the key sequence. The key sequence is null after calling this
  340.      * function.
  341.      * @see isNull()
  342.      */
  343.     void clear();
  344.  
  345.     /**
  346.      * Copies the given qt key sequence over this key sequence.
  347.      * @param keySeq the qt key sequence to copy
  348.      * @return true if successful, false otherwise
  349.      */
  350.     bool init( const QKeySequence& keySeq );
  351.  
  352.     /**
  353.      * Initializes the key sequence to only contain the given key.
  354.      * @param key the key to set
  355.      * @return true if successful, false otherwise
  356.      */
  357.     bool init( const KKey& key );
  358.  
  359.     /**
  360.      * Initializes the key sequence to only contain the given key.
  361.      * @param key the key to set
  362.      * @return true if successful, false otherwise
  363.      */
  364.     bool init( const KKeyNative& key );
  365.  
  366.     /**
  367.      * Copies the given key sequence over this key sequence.
  368.      * @param keySeq the key sequence to copy
  369.      * @return true if successful, false otherwise
  370.      */
  371.     bool init( const KKeySequence& keySeq );
  372.  
  373.     /**
  374.      * Initializes this key sequence to contain the given key sequence.
  375.      * The description consists of comma-separated keys as
  376.      * required by KKey::KKey(const QString&).
  377.      * @param key the description of the key
  378.      * @return true if successful, false otherwise
  379.      * @see KKeyServer::Sym::init()
  380.      * @see KKey::KKey(const QString&)
  381.      */
  382.     bool init( const QString& key );
  383.  
  384.     /**
  385.      * Copy the given key sequence into this sequence.
  386.      */
  387.     KKeySequence& operator =( const KKeySequence& seq )
  388.         { init( seq ); return *this; }
  389.  
  390.     /**
  391.      * Returns the number of key strokes of this sequence.
  392.      * @return the number of key strokes
  393.      * @see MAX_KEYS
  394.      */
  395.     uint count() const;
  396.  
  397.     /**
  398.      * Return the @p i'th key of this sequence, or a null key if there
  399.      * are less then i keys.
  400.      * @param i the key to retrieve
  401.      * @return the @p i'th key, or KKey::null() if there are less
  402.      *         than i keys
  403.      * @see MAX_KEYS
  404.      */
  405.     const KKey& key( uint i ) const;
  406.  
  407.     /**
  408.      * @internal
  409.      */
  410.     bool isTriggerOnRelease() const;
  411.  
  412.     /**
  413.      * Sets the @p i'th key of the sequence. You can not introduce gaps
  414.      * in a sequence, so you must use an @p i <= count(). Also note that
  415.      * the maximum length of a key sequence is MAX_KEYS.
  416.      * @param i the position of the new key (<= count(), <= MAX_KEYS)
  417.      * @param key the key to set
  418.      * @return true if successful, false otherwise
  419.      */
  420.     bool setKey( uint i, const KKey& key );
  421.  
  422.     /**
  423.      * Returns true if the key sequence is null (after clear() or empty
  424.      * constructor).
  425.      * @return true if the key sequence is null
  426.      * @see clear()
  427.      * @see null()
  428.      */
  429.     bool isNull() const;
  430.  
  431.     /**
  432.      * Returns true if this key sequence begins with the given sequence.
  433.      * @param keySeq the key sequence to search
  434.      * @return true if this key sequence begins with the given sequence
  435.      */
  436.     bool startsWith( const KKeySequence& keySeq ) const;
  437.  
  438.     /**
  439.      * Compares this object with the given key sequence. Returns a negative
  440.      * number if the given KKeySequence is larger, 0 if they are equal and
  441.      * a positive number this KKeySequence is larger. Key sequences are
  442.      * compared by comparing the individual keys, starting from the beginning
  443.      * until an unequal key has been found. If a sequence contains more
  444.      * keys, it is considered larger.
  445.      * @param keySeq the key sequence to compare to
  446.      * @return a negative number if the given KKeySequence is larger, 0 if
  447.      * they are equal and a positive number this KKeySequence is larger
  448.      * @see KKey::sequence
  449.      */
  450.     int compare( const KKeySequence& keySeq ) const;
  451.  
  452.     /**
  453.      * Compares the keys of both sequences.
  454.      * @see compare()
  455.      */
  456.     bool operator == ( const KKeySequence& seq ) const
  457.         { return compare( seq ) == 0; }
  458.  
  459.     /**
  460.      * Compares the keys of both sequences.
  461.      * @see compare()
  462.      */
  463.     bool operator != ( const KKeySequence& seq ) const
  464.         { return compare( seq ) != 0; }
  465.  
  466.     /**
  467.      * Compares the keys of both sequences.
  468.      * @see compare()
  469.      */
  470.     bool operator < ( const KKeySequence& seq ) const
  471.         { return compare( seq ) < 0; }
  472.     // TODO: consider adding Qt::SequenceMatch matches(...) methods for QKeySequence equivalence
  473.  
  474.     /**
  475.      * Converts this key sequence to a QKeySequence.
  476.      * @return the QKeySequence
  477.      */
  478.     QKeySequence qt() const;
  479.  
  480.     /**
  481.      * Returns the qt key code of the first key.
  482.      * @return the qt key code of the first key
  483.      * @see Qt::Key
  484.      * @see KKey::keyCodeQt()
  485.      */
  486.     int keyCodeQt() const;
  487.  
  488.     /**
  489.      * Returns the key sequence as a number of key presses as
  490.      * returned by KKey::toString(), separated by commas.
  491.      * @return the string represenation of this key sequence
  492.      * @see KKey::toString()
  493.      */
  494.     QString toString() const;
  495.  
  496.     /**
  497.      * @internal
  498.      */
  499.     QString toStringInternal() const;
  500.  
  501.     /**
  502.      * Returns a null key sequence.
  503.      * @return the null key sequence
  504.      * @see isNull()
  505.      * @see clear()
  506.      */
  507.     static KKeySequence& null();
  508.  
  509.  protected:
  510.     uchar m_nKeys;
  511.     uchar m_bTriggerOnRelease;
  512.     // BCI: m_rgvar should be renamed to m_rgkey for KDE 4.0
  513.     KKey m_rgvar[MAX_KEYS];
  514.  
  515.  private:
  516.     class KKeySequencePrivate* d;
  517.     friend class KKeyNative;
  518. };
  519.  
  520. /**
  521. * The KShortcut class is used to represent a keyboard shortcut to an action.
  522. * A shortcut is normally a single key with modifiers, such as Ctrl+V.
  523. * A KShortcut object may also contain an alternate key which will also
  524. * activate the action it's associated to, as long as no other actions have
  525. * defined that key as their primary key.  Ex: Ctrl+V;Shift+Insert.
  526. *
  527. * This can be used to add additional accelerators to a KAction.  For example,
  528. * the below code binds the escape key to the close action.
  529. *
  530. * \code
  531. *  KAction *closeAction = KStdAction::close( this, SLOT( close() ), actionCollection() );
  532. *  KShortcut closeShortcut = closeAction->shortcut();
  533. *  closeShortcut.append( KKey(Key_Escape));
  534. *  closeAction->setShortcut(closeShortcut);
  535. * \endcode
  536. *
  537. * Note that a shortcut cannot have more than 2 key combinations associated with it, so the above
  538. * code would not do anything (and append() would return false) if the closeAction already had
  539. * an key and alternate key.
  540. * 
  541. */
  542.  
  543. class KDECORE_EXPORT KShortcut
  544. {
  545.  public:
  546.         /**
  547.      * The maximum number of key sequences that can be contained in
  548.      * a KShortcut.
  549.          */
  550.     enum { MAX_SEQUENCES = 2 };
  551.  
  552.     /**
  553.      * Creates a new null shortcut.
  554.      * @see null()
  555.      * @see isNull()
  556.      * @see clear()
  557.      */
  558.     KShortcut();
  559.  
  560.     /**
  561.      * Creates a new shortcut with the given Qt key code
  562.      * as the only key sequence.
  563.      * @param keyQt the qt keycode
  564.      * @see Qt::Key
  565.      */
  566.     KShortcut( int keyQt );
  567.  
  568.     /**
  569.      * Creates a new shortcut that contains only the given qt key
  570.      * sequence.
  571.      * @param keySeq the qt key sequence to add
  572.      */
  573.     KShortcut( const QKeySequence& keySeq );
  574.  
  575.     /**
  576.      * Creates a new shortcut that contains only the given key
  577.      * in its only sequence.
  578.      * @param key the key to add
  579.      */
  580.     KShortcut( const KKey& key );
  581.  
  582.     /**
  583.      * Creates a new shortcut that contains only the given key
  584.      * sequence.
  585.      * @param keySeq the key sequence to add
  586.      */
  587.     KShortcut( const KKeySequence& keySeq );
  588.  
  589.     /**
  590.      * Copies the given shortcut.
  591.      * @param shortcut the shortcut to add
  592.      */
  593.     KShortcut( const KShortcut& shortcut );
  594.  
  595.     /**
  596.      * Creates a new key sequence that contains the given key sequence.
  597.      * The description consists of semicolon-separated keys as
  598.      * used in KKeySequence::KKeySequence(const QString&).
  599.      * @param shortcut the description of the key
  600.      * @see KKeySequence::KKeySequence(const QString&)
  601.      */
  602.     KShortcut( const char* shortcut );
  603.  
  604.     /**
  605.      * Creates a new key sequence that contains the given key sequence.
  606.      * The description consists of semicolon-separated keys as
  607.      * used in KKeySequence::KKeySequence(const QString&).
  608.      * @param shortcut the description of the key
  609.      * @see KKeySequence::KKeySequence(const QString&)
  610.      */
  611.     KShortcut( const QString& shortcut );
  612.     ~KShortcut();
  613.  
  614.     /**
  615.      * Clears the shortcut. The shortcut is null after calling this
  616.      * function.
  617.      * @see isNull()
  618.      */
  619.     void clear();
  620.  
  621.     /**
  622.      * Initializes the shortcut with the given Qt key code
  623.      * as the only key sequence.
  624.      * @param keyQt the qt keycode
  625.      * @see Qt::Key
  626.      */
  627.     bool init( int keyQt );
  628.  
  629.     /**
  630.      * Initializes the shortcut with the given qt key sequence.
  631.      * @param keySeq the qt key sequence to add
  632.      */
  633.     bool init( const QKeySequence& keySeq );
  634.  
  635.     /**
  636.      * Initializes the shortcut with the given key as its only sequence.
  637.      * @param key the key to add
  638.      */
  639.     bool init( const KKey& key );
  640.  
  641.     /**
  642.      * Initializes the shortcut with the given qt key sequence.
  643.      * @param keySeq the qt key sequence to add
  644.      */
  645.     bool init( const KKeySequence& keySeq );
  646.  
  647.     /**
  648.      * Copies the given shortcut.
  649.      * @param shortcut the shortcut to add
  650.      */
  651.     bool init( const KShortcut& shortcut );
  652.  
  653.     /**
  654.      * Initializes the key sequence with the given key sequence.
  655.      * The description consists of semicolon-separated keys as
  656.      * used in KKeySequence::KKeySequence(const QString&).
  657.      * @param shortcut the description of the key
  658.      * @see KKeySequence::KKeySequence(const QString&)
  659.      */
  660.     bool init( const QString& shortcut );
  661.  
  662.     /**
  663.      * Copies the given shortcut over this shortcut.
  664.      */
  665.     KShortcut& operator =( const KShortcut& cut )
  666.         { init( cut ); return *this; }
  667.  
  668.     /**
  669.      * Returns the number of sequences that are in this
  670.      * shortcut.
  671.      * @return the number of sequences
  672.      * MAX_SEQUENCES
  673.      */
  674.     uint count() const;
  675.  
  676.     /**
  677.      * Returns the @p i'th key sequence of this shortcut.
  678.      * @param i the number of the key sequence to retrieve
  679.      * @return the @p i'th sequence or KKeySequence::null() if
  680.      *         there are less than @p i key sequences
  681.      * MAX_SEQUENCES
  682.      */
  683.     const KKeySequence& seq( uint i ) const;
  684.  
  685.     /**
  686.      * Returns the key code of the first key sequence, or
  687.      * null if there is no first key sequence.
  688.      * @return the key code of the first sequence's first key
  689.      * @see Qt::Key
  690.      * @see KKeySequence::keyCodeQt()
  691.      */
  692.     int keyCodeQt() const;
  693.  
  694.     /**
  695.      * Returns true if the shortcut is null (after clear() or empty
  696.      * constructor).
  697.      * @return true if the shortcut is null
  698.      * @see clear()
  699.      * @see null()
  700.      */
  701.     bool isNull() const;
  702.  
  703.     /**
  704.      * Compares this object with the given shortcut. Returns a negative
  705.      * number if the given shortcut is larger, 0 if they are equal and
  706.      * a positive number this shortcut is larger. Shortcuts are
  707.      * compared by comparing the individual key sequences, starting from the
  708.      * beginning until an unequal key sequences has been found. If a shortcut
  709.      * contains more key sequences, it is considered larger.
  710.      * @param shortcut the shortcut to compare to
  711.      * @return a negative number if the given KShortcut is larger, 0 if
  712.      * they are equal and a positive number this KShortcut is larger
  713.      * @see KKey::compare()
  714.      * @see KKeyShortcut::compare()
  715.      */
  716.     int compare( const KShortcut& shortcut ) const;
  717.  
  718.     /**
  719.      * Compares the sequences of both shortcuts.
  720.      * @see compare()
  721.      */
  722.     bool operator == ( const KShortcut& cut ) const
  723.         { return compare( cut ) == 0; }
  724.  
  725.     /**
  726.      * Compares the sequences of both shortcuts.
  727.      * @see compare()
  728.      */
  729.     bool operator != ( const KShortcut& cut ) const
  730.         { return compare( cut ) != 0; }
  731.  
  732.     /**
  733.      * Compares the sequences of both shortcuts.
  734.      * @see compare()
  735.      */
  736.     bool operator < ( const KShortcut& cut ) const
  737.         { return compare( cut ) < 0; }
  738.  
  739.     /**
  740.      * Checks whether this shortcut contains a sequence that starts
  741.      * with the given key.
  742.      * @param key the key to check
  743.      * @return true if a key sequence starts with the key
  744.      */
  745.     bool contains( const KKey& key ) const;
  746.  
  747.     /**
  748.      * Checks whether this shortcut contains a sequence that starts
  749.      * with the given key.
  750.      * @param key the key to check
  751.      * @return true if a key sequence starts with the key
  752.      */
  753.     bool contains( const KKeyNative& key ) const;
  754.  
  755.     /**
  756.      * Checks whether this shortcut contains the given sequence.
  757.      * @param keySeq the key sequence to check
  758.      * @return true if the shortcut has the given key sequence
  759.      */
  760.     bool contains( const KKeySequence& keySeq ) const;
  761.  
  762.     /**
  763.      * Sets the @p i 'th key sequence of the shortcut. You can not introduce
  764.      * gaps in the list of sequences, so you must use an @p i <= count().
  765.      * Also note that the maximum number of key sequences is MAX_SEQUENCES.
  766.      * @param i the position of the new key sequence(0 <= i <= count(), 0 <= i < MAX_SEQUENCES)
  767.      * @param keySeq the key sequence to set
  768.      * @return true if successful, false otherwise
  769.      */
  770.     bool setSeq( uint i, const KKeySequence& keySeq );
  771.  
  772.     /**
  773.      * Appends the given key sequence.  This sets it as either the keysequence or
  774.      * the alternate keysequence.  If the shortcut already has MAX_SEQUENCES
  775.      * sequences then this call does nothing, and returns false.
  776.      *
  777.      * @param keySeq the key sequence to add
  778.      * @return true if successful, false otherwise
  779.      * @see setSeq()
  780.     */
  781.     bool append( const KKeySequence& keySeq );
  782.  
  783.     /**
  784.      * Removes the given key sequence from this shortcut
  785.      * @param keySeq the key sequence to remove
  786.      * @since 3.3
  787.     */
  788.     void remove( const KKeySequence& keySeq );
  789.  
  790.     /**
  791.      * Appends the given key
  792.      * @param spec the key to add
  793.      * @return true if successful, false otherwise
  794.      * @see setSeq()
  795.      * @see MAX_SEQUENCES
  796.      * @since 3.2
  797.     */
  798.     bool append( const KKey& spec );
  799.  
  800.     /**
  801.      * Appends the sequences from the given shortcut.
  802.      * @param cut the shortcut to append
  803.      * @return true if successful, false otherwise
  804.      * @see MAX_SEQUENCES
  805.      * @since 3.2
  806.     */
  807.     bool append( const KShortcut& cut );
  808.  
  809.     /**
  810.      * Converts this shortcut to a key sequence. The first key sequence
  811.      * will be taken.
  812.      */
  813.     operator QKeySequence () const;
  814.  
  815.     /**
  816.      * Returns a description of the shortcut as semicolon-separated
  817.      * ket sequences, as returned by KKeySequence::toString().
  818.      * @return the string represenation of this shortcut
  819.      * @see KKey::toString()
  820.      * @see KKeySequence::toString()
  821.      */
  822.     QString toString() const;
  823.  
  824.     /**
  825.      * @internal
  826.      */
  827.     QString toStringInternal( const KShortcut* pcutDefault = 0 ) const;
  828.  
  829.     /**
  830.      * Returns a null shortcut.
  831.      * @return the null shortcut
  832.      * @see isNull()
  833.      * @see clear()
  834.      */
  835.     static KShortcut& null();
  836.  
  837.  protected:
  838.     uint m_nSeqs;
  839.     KKeySequence m_rgseq[MAX_SEQUENCES];
  840.  
  841.  private:
  842.     class KShortcutPrivate* d;
  843.     friend class KKeyNative;
  844.  
  845. #ifndef KDE_NO_COMPAT
  846.  public:
  847.     operator int () const    { return keyCodeQt(); }
  848. #endif
  849. };
  850.  
  851. #endif // __KSHORTCUT_H
  852.