1 files changed, 4 insertions, 4 deletions

diff --git a/microkde/kdecore/kshortcut.h b/microkde/kdecore/kshortcut.h
index 4813734..244d590 100644
--- a/microkde/kdecore/kshortcut.h
+++ b/microkde/kdecore/kshortcut.h
@@ -470,238 +470,238 @@ class KKey
          */
         //USbool operator == ( const KKeySequence& seq ) const
         //US    { return compare( seq ) == 0; }
 
         /**
          * Compares the keys of both sequences.
          * @see compare()
          */
         //USbool operator != ( const KKeySequence& seq ) const
         //US    { return compare( seq ) != 0; }
 
         /**
          * Compares the keys of both sequences.
          * @see compare()
          */
         //USbool operator < ( const KKeySequence& seq ) const
         //US    { return compare( seq ) < 0; }
         // TODO: consider adding Qt::SequenceMatch matches(...) methods for QKeySequence equivalence
 
         /**
          * Converts this key sequence to a QKeySequence.
          * @return the QKeySequence
          */
         //USQKeySequence qt() const;
         
         /**
          * Returns the qt key code of the first key.
          * @return the qt key code of the first key
          * @see Qt::Key
          * @see KKey::keyCodeQt()
          */
         //USint keyCodeQt() const;
 
         /**
          * Returns the key sequence as a number of key presses as
          * returned by @ref KKey::toString(), seperated by commas.
          * @return the string represenation of this key sequence
          * @see KKey::toString()
          */
         //USQString toString() const;
 
         /**
          * @internal
          */
 //US  QString toStringInternal() const;
 
         /**
          * Returns a null key sequence.
          * @return the null key sequence
          * @see isNull()
          * @see clear()
          */
         //USstatic KKeySequence& null();
 
 //US protected:
         //USuchar m_nKeys;
         //USuchar m_bTriggerOnRelease;
         // BCI: m_rgvar should be renamed to m_rgkey for KDE 4.0
         //USKKey m_rgvar[MAX_KEYS];
 
 //US private:
         //USclass KKeySequencePrivate* d;
         //USfriend class KKeyNative;
 //US};
 
 /**
 * The KShortcut class is used to represent a keyboard shortcut to an action.
 * A shortcut is normally a single key with modifiers, such as Ctrl+V.
 * A KShortcut object may also contain an alternate key which will also
 * activate the action it's associated to, as long as no other actions have
 * defined that key as their primary key.  Ex: Ctrl+V;Shift+Insert.
 */
 
 class KShortcut
 {
  public:
         /**
          * The maximum number of key sequences that can be contained in 
          * a KShortcut.
          */ 
         enum { MAX_SEQUENCES = 2 };
 
         /**
          * Creates a new null shortcut.
          * @see null()
          * @see isNull()
          * @see clear()
          */
         KShortcut() {}
 
         /**
          * Creates a new shortcut with the given Qt key code
          * as the only key sequence.
          * @param keyQt the qt keycode
          * @see Qt::Key
          */
-        KShortcut( int keyQt ) {}
+        KShortcut( int /*keyQt */) {}
 
         /**
          * Creates a new shortcut that contains only the given qt key
          * sequence.
          * @param keySeq the qt key sequence to add
          */
         //USKShortcut( const QKeySequence& keySeq ) {}
 
         /**
          * Creates a new shortcut that contains only the given key
          * in its only sequence.
          * @param key the key to add
          */
         //USKShortcut( const KKey& key );
 
         /**
          * Creates a new shortcut that contains only the given key
          * sequence.
          * @param keySeq the key sequence to add
          */
         //USKShortcut( const KKeySequence& keySeq );
 
         /**
          * Copies the given shortcut.
          * @param shortcut the shortcut to add
          */
         //USKShortcut( const KShortcut& shortcut );
 
         /**
          * Creates a new key sequence that contains the given key sequence.
          * The description consists of semicolon-separated keys as
          * used in @ref KKeySequence::KKeySequence(const QString&).
          * @param shortcut the description of the key
          * @see KKeySequence::KKeySequence(const QString&)
          */
-        KShortcut( const char* shortcut ) {}
+        KShortcut( const char* /*shortcut */) {}
 
         /**
          * Creates a new key sequence that contains the given key sequence.
          * The description consists of semicolon-separated keys as
          * used in @ref KKeySequence::KKeySequence(const QString&).
          * @param shortcut the description of the key
          * @see KKeySequence::KKeySequence(const QString&)
          */
-        KShortcut( const QString& shortcut ) {}
+        KShortcut( const QString& /*shortcut */) {}
         ~KShortcut() {}
 
         /**
          * Clears the shortcut. The shortcut is null after calling this 
          * function.
          * @see isNull()
          */
         //USvoid clear();
 
         /**
          * Initializes the shortcut with the given Qt key code
          * as the only key sequence.
          * @param keyQt the qt keycode
          * @see Qt::Key
          */
         //USbool init( int keyQt );
 
         /**
          * Initializes the shortcut with the given qt key sequence.
          * @param keySeq the qt key sequence to add
          */
         //USbool init( const QKeySequence& keySeq );
 
         /**
          * Initializes the shortcut with the given key as its only sequence.
          * @param key the key to add
          */
         //USbool init( const KKey& key );
 
         /**
          * Initializes the shortcut with the given qt key sequence.
          * @param keySeq the qt key sequence to add
          */
         //USbool init( const KKeySequence& keySeq );
 
         /**
          * Copies the given shortcut.
          * @param shortcut the shortcut to add
          */
         //USbool init( const KShortcut& shortcut );
 
         /**
          * Initializes the key sequence with the given key sequence.
          * The description consists of semicolon-separated keys as
          * used in @ref KKeySequence::KKeySequence(const QString&).
          * @param shortcut the description of the key
          * @see KKeySequence::KKeySequence(const QString&)
          */
         //USbool init( const QString& shortcut );
 
         /**
          * Copies the given shortcut over this shortcut.
          */
         //USKShortcut& operator =( const KShortcut& cut )
         //US    { init( cut ); return *this; }
 
         /**
          * Returns the number of sequences that are in this
          * shortcut.
          * @return the number of sequences
          * @ref MAX_SEQUENCES
          */
         //USuint count() const;
 
         /**
          * Returns the @p i'th key sequence of this shortcut.
          * @param i the number of the key sequence to retrieve
          * @return the @p i'th sequence or @ref KKeySequence::null() if
          *         there are less than @p i key sequences
          * @ref MAX_SEQUENCES
          */
         //USconst KKeySequence& seq( uint i ) const;
 
         /**
          * Returns the key code of the first key sequence, or 
          * null if there is no first key sequence.
          * @return the key code of the first sequence's first key
          * @see Qt::Key
          * @see KKeySequence::keyCodeQt()
          */
         //USint keyCodeQt() const;
 
         /**
          * Returns true if the shortcut is null (after @ref clear() or empty
          * constructor).
          * @return true if the shortcut is null
          * @see clear()
          * @see null()
          */
         bool isNull() const { return true; }
 
         /**
          * Compares this object with the given shortcut. Returns a negative 
          * number if the given shortcut is larger, 0 if they are equal and
          * a positive number this shortcut is larger. Shortcuts are
          * compared by comparing the individual key sequences, starting from the 
@@ -723,124 +723,124 @@ class KShortcut
         //US    { return compare( cut ) == 0; }
 
         /**
          * Compares the sequences of both shortcuts.
          * @see compare()
          */
         //USbool operator != ( const KShortcut& cut ) const
         //US    { return compare( cut ) != 0; }
 
         /**
          * Compares the sequences of both shortcuts.
          * @see compare()
          */
         //USbool operator < ( const KShortcut& cut ) const
         //US    { return compare( cut ) < 0; }
 
         /**
          * Checks whether this shortcut contains a sequence that starts
          * with the given key.
          * @param key the key to check
          * @return true if a key sequence starts with the key
          */
         //USbool contains( const KKey& key ) const;
 
         /**
          * Checks whether this shortcut contains a sequence that starts
          * with the given key.
          * @param key the key to check
          * @return true if a key sequence starts with the key
          */
         //USbool contains( const KKeyNative& key ) const;
 
         /**
          * Checks whether this shortcut contains the given sequence.
          * @param keySeq the key sequence to check
          * @return true if the shortcut has the given key sequence
          */
         //USbool contains( const KKeySequence& keySeq ) const;
 
         /**
          * Sets the @p i'th key sequence of the shortcut. You can not introduce 
          * gaps in the list of sequences, so you must use an @i <= @ref count(). 
          * Also note that the maximum number of key sequences is @ref MAX_SEQUENCES.
          * @param i the position of the new key sequence(<= @ref count(), 
          *          <= @ref MAX_SEQUENCES)
          * @param keySeq the key sequence to set
          * @return true if successful, false otherwise
          */
         //USbool setSeq( uint i, const KKeySequence& keySeq );
 
         /**
          * Appends the given key sequence.
          * @param keySeq the key sequence to add
          * @return true if successful, false otherwise
          * @see setSeq()
          * @see MAX_SEQUENCES
         */
         //USbool append( const KKeySequence& keySeq );
 
         /**
          * Appends the given key
          * @param spec the key to add
          * @return true if successful, false otherwise
          * @see setSeq()
          * @see MAX_SEQUENCES
          * @since 3.2
         */
         //USbool append( const KKey& spec );
 
         /**
          * Appends the sequences from the given shortcut.
          * @param cut the shortcut to append
          * @return true if successful, false otherwise
          * @see MAX_SEQUENCES
          * @since 3.2
         */
         //USbool append( const KShortcut& cut );
 
         /**
          * Converts this shortcut to a key sequence. The first key sequence
          * will be taken.
          */
         //USoperator QKeySequence () const;
 
         /**
          * Returns a description of the shortcut as semicolon-separated
          * ket sequences, as returned by @ref KKeySequence::toString().
          * @return the string represenation of this shortcut
          * @see KKey::toString()
          * @see KKeySequence::toString()
          */
         //USQString toString() const;
 
         /**
          * @internal
          */
-  QString toStringInternal( const KShortcut* pcutDefault = 0 ) const
+  QString toStringInternal( const KShortcut* /*pcutDefault*/ = 0 ) const
   {
     return "EMPTY IMPL.";
   }
 
         /**
          * Returns a null shortcut.
          * @return the null shortcut
          * @see isNull()
          * @see clear()
          */
         //USstatic KShortcut& null();
 
 //US protected:
         //USuint m_nSeqs;
         //USKKeySequence m_rgseq[MAX_SEQUENCES];
 
 //US private:
         //USclass KShortcutPrivate* d;
         //USfriend class KKeyNative;
 
 //US#ifndef KDE_NO_COMPAT
 //US public:
         //USoperator int () const    { return keyCodeQt(); }
 //US#endif
 };
 
 #endif // __KSHORTCUT_H