tdeshortcut.h

/*  This file is part of the KDE libraries
    Copyright (C) 2001,2002 Ellis Whitehead <ellis@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/
 
#ifndef __TDESHORTCUT_H
#define __TDESHORTCUT_H
 
#include <tqkeysequence.h>
#include <tqstring.h>
#include "tdelibs_export.h"
 
class TQKeyEvent;
class KKeyNative;
 
class TDECORE_EXPORT KKey
{
 public:
    enum { MOD_FLAG_COUNT = 4 };
    enum { QtWIN = (TQt::META) };
    enum ModFlag {
        SHIFT = 0x01,
        CTRL = 0x02,
        ALT = 0x04,
        WIN = 0x08
    };
 
    KKey();
 
    KKey( int keyQt );
 
    KKey( const TQKeySequence& keySeq );
 
    KKey( const TQKeyEvent* keyEvent );
 
    KKey( const KKey& key );
 
    KKey( const TQString& key );
    KKey( uint key, uint mod );
    ~KKey();
 
 // Initialization methods
    void clear();
 
    bool init( int keyQt );
 
    bool init( const TQKeySequence& keySeq );
 
    bool init( const TQKeyEvent* keyEvent );
 
    bool init( const KKey& key );
 
    bool init( const TQString& key);
 
    bool init( uint key, uint mod );
 
    KKey& operator =( const KKey& key )
        { init( key ); return *this; }
 
 // Query methods.
    bool isNull() const;
 
    uint sym() const;
    uint modFlags() const;
 
 // Comparison Methods
    int compare( const KKey& key ) const;
 
    bool operator == ( const KKey& key ) const
        { return compare( key ) == 0; }
    bool operator != ( const KKey& key ) const
        { return compare( key ) != 0; }
    bool operator < ( const KKey& key ) const
        { return compare( key ) < 0; }
 
 // Conversion methods.
    int keyCodeQt() const;
 
    TQString toString() const;
 
    TQString toStringInternal() const;
 
 // Operation methods
    void simplify();
 
    static KKey& null();
 
    static TQString modFlagLabel( ModFlag f );
 
 private:
    /*
     * Under X11, m_key will hold an X11 key symbol.
     * For Qt/Embedded, it will hold the Qt key code.
     */
    uint m_sym;
    uint m_mod;
 
 private:
    friend class KKeyNative;
};
 
class TDECORE_EXPORT KKeySequence
{
 public:
        enum { MAX_KEYS = 4 };
 
    KKeySequence();
 
    KKeySequence( const TQKeySequence& keySeq );
 
    KKeySequence( const KKey& key );
 
    KKeySequence( const KKeyNative& key );
 
    KKeySequence( const KKeySequence& keySeq );
 
    KKeySequence( const TQString& keySeq );
 
    ~KKeySequence();
 
    void clear();
 
    bool init( const TQKeySequence& keySeq );
 
    bool init( const KKey& key );
 
    bool init( const KKeyNative& key );
 
    bool init( const KKeySequence& keySeq );
 
    bool init( const TQString& key );
 
    KKeySequence& operator =( const KKeySequence& seq )
        { init( seq ); return *this; }
 
    uint count() const;
 
    const KKey& key( uint i ) const;
 
    bool isTriggerOnRelease() const;
 
    bool setKey( uint i, const KKey& key );
 
    bool isNull() const;
 
    bool startsWith( const KKeySequence& keySeq ) const;
 
    int compare( const KKeySequence& keySeq ) const;
 
    bool operator == ( const KKeySequence& seq ) const
        { return compare( seq ) == 0; }
 
    bool operator != ( const KKeySequence& seq ) const
        { return compare( seq ) != 0; }
 
    bool operator < ( const KKeySequence& seq ) const
        { return compare( seq ) < 0; }
    // TODO: consider adding TQt::SequenceMatch matches(...) methods for TQKeySequence equivalence
 
    TQKeySequence qt() const;
 
    int keyCodeQt() const;
 
    TQString toString() const;
 
    TQString toStringInternal() const;
 
    static KKeySequence& null();
 
 protected:
    uchar m_nKeys;
    uchar m_bTriggerOnRelease;
    // BCI: m_rgvar should be renamed to m_rgkey for KDE 4.0
    KKey m_rgvar[MAX_KEYS];
 
 private:
    class KKeySequencePrivate* d;
    friend class KKeyNative;
};
 
class TDECORE_EXPORT TDEShortcut
{
 public:
    enum { MAX_SEQUENCES = 2 };
 
    TDEShortcut();
 
    TDEShortcut( int keyQt );
 
    TDEShortcut( const TQKeySequence& keySeq );
 
    TDEShortcut( const KKey& key );
 
    TDEShortcut( const KKeySequence& keySeq );
 
    TDEShortcut( const TDEShortcut& shortcut );
 
    TDEShortcut( const char* shortcut );
 
    TDEShortcut( const TQString& shortcut );
    ~TDEShortcut();
 
    void clear();
 
    bool init( int keyQt );
 
    bool init( const TQKeySequence& keySeq );
 
    bool init( const KKey& key );
 
    bool init( const KKeySequence& keySeq );
 
    bool init( const TDEShortcut& shortcut );
 
    bool init( const TQString& shortcut );
 
    TDEShortcut& operator =( const TDEShortcut& cut )
        { init( cut ); return *this; }
 
    uint count() const;
 
    const KKeySequence& seq( uint i ) const;
 
    int keyCodeQt() const;
 
    bool isNull() const;
 
    int compare( const TDEShortcut& shortcut ) const;
 
    bool operator == ( const TDEShortcut& cut ) const
        { return compare( cut ) == 0; }
 
    bool operator != ( const TDEShortcut& cut ) const
        { return compare( cut ) != 0; }
 
    bool operator < ( const TDEShortcut& cut ) const
        { return compare( cut ) < 0; }
 
    bool contains( const KKey& key ) const;
 
    bool contains( const KKeyNative& key ) const;
 
    bool contains( const KKeySequence& keySeq ) const;
 
    bool setSeq( uint i, const KKeySequence& keySeq );
 
    bool append( const KKeySequence& keySeq );
 
    void remove( const KKeySequence& keySeq );
 
    bool append( const KKey& spec );
 
    bool append( const TDEShortcut& cut );
 
    operator TQKeySequence () const;
 
    TQString toString() const;
 
    TQString toStringInternal( const TDEShortcut* pcutDefault = 0 ) const;
 
    static TDEShortcut& null();
 
 protected:
    uint m_nSeqs;
    KKeySequence m_rgseq[MAX_SEQUENCES];
 
 private:
    class TDEShortcutPrivate* d;
    friend class KKeyNative;
 
#ifndef KDE_NO_COMPAT
 public:
    operator int () const    { return keyCodeQt(); }
#endif
};
 
#endif // __TDESHORTCUT_H