kkeyserver_x11.h

/*
    Copyright (C) 2001 Ellis Whitehead <ellis@kde.org>
 
    Win32 port:
    Copyright (C) 2004 Jaroslaw Staniek <js@iidea.pl>
 
    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 _KKEYSERVER_X11_H
#define _KKEYSERVER_X11_H
 
#include "tdeshortcut.h"
#include "kkeynative.h"
 
namespace KKeyServer
{
    enum ExtraModFlag { MODE_SWITCH = 0x2000 };
 
    struct TDECORE_EXPORT Sym
    {
     public:
        uint m_sym;
 
        Sym()
            { m_sym = 0; }
        Sym( uint sym )
            { m_sym = sym; }
        Sym( const TQString& s )
            { init( s ); }
 
        bool initQt( int keyQt );
 
        bool init( const TQString &s );
 
        int qt() const;
 
        TQString toStringInternal() const;
 
        TQString toString() const;
 
        uint getModsRequired() const;
 
        uint getSymVariation() const;
 
        operator uint() const { return m_sym; }
 
        Sym& operator =( uint sym ) { m_sym = sym; return *this; }
 
     private:
        TQString toString( bool bUserSpace ) const;
 
        static void capitalizeKeyname( TQString& );
    };
 
    struct TDECORE_EXPORT Key
    {
        enum { CODE_FOR_QT = 256 };
 
        uint m_code;
 
        uint m_mod;
 
        uint m_sym;
 
        bool init( const KKey& key, bool bQt );
 
        bool isNative() const { return m_code != CODE_FOR_QT; }
 
        uint code() const { return m_code; }
 
        uint mod() const { return m_mod; }
 
        uint sym() const { return m_sym; }
 
        int keyCodeQt() const { return (int) m_sym; }
 
        void setKeycodeQt( int keyQt )
            { m_code = CODE_FOR_QT; m_sym = keyQt; }
 
        Key& operator =( const KKeyNative& key );
 
        int compare( const Key& key ) const;
 
        bool operator ==( const Key& b ) const
            { return compare( b ) == 0; }
 
        bool operator <( const Key& b ) const
            { return compare( b ) < 0; }
 
        KKey key() const;
    };
 
    struct TDECORE_EXPORT Variations
    {
        enum { MAX_VARIATIONS = 4 };
 
        Key m_rgkey[MAX_VARIATIONS];
        uint m_nVariations;
 
        Variations() { m_nVariations = 0; }
 
        void init( const KKey&, bool bQt );
 
        uint count() const { return m_nVariations; }
        const Key& key( uint i ) const { return m_rgkey[i]; }
    };
 
    TDECORE_EXPORT bool initializeMods();
 
    TDECORE_EXPORT uint modX( KKey::ModFlag modFlag );
 
    TDECORE_EXPORT bool keyboardHasWinKey();
 
    TDECORE_EXPORT uint modXShift();
 
    TDECORE_EXPORT uint modXLock();
 
    TDECORE_EXPORT uint modXCtrl();
 
    TDECORE_EXPORT uint modXAlt();
 
    TDECORE_EXPORT uint modXNumLock();
 
    TDECORE_EXPORT uint modXWin();
 
    TDECORE_EXPORT uint modXScrollLock();
 
    TDECORE_EXPORT uint modXModeSwitch();
 
    TDECORE_EXPORT uint accelModMaskX();
 
    TDECORE_EXPORT bool keyQtToSym( int keyQt, uint& sym );
 
    TDECORE_EXPORT bool keyQtToMod( int keyQt, uint& mod );
 
    TDECORE_EXPORT bool symToKeyQt( uint sym, int& keyQt );
 
    TDECORE_EXPORT bool modToModQt( uint mod, int& modQt );
 
    TDECORE_EXPORT bool modToModX( uint mod, uint& modX );
 
    //wrapped for win32
    TDECORE_EXPORT bool modXToModQt( uint modX, int& modQt );
 
    TDECORE_EXPORT int qtButtonStateToMod( TQt::ButtonState s );
 
    TDECORE_EXPORT bool modXToMod( uint modX, uint& mod );
 
    TDECORE_EXPORT bool codeXToSym( uchar codeX, uint modX, uint& symX );
 
    TDECORE_EXPORT TQString modToStringInternal( uint mod );
 
    TDECORE_EXPORT TQString modToStringUser( uint mod );
 
    TDECORE_EXPORT uint stringUserToMod( const TQString& mod );
 
    TDECORE_EXPORT bool stringToSymMod( const TQString&, uint& sym, uint& mod );
 
    TDECORE_EXPORT void keyQtToKeyX( uint keyCombQt, unsigned char *pKeyCodeX, uint *pKeySymX, uint *pKeyModX );
}
 
#endif // !_KKEYSERVER_X11_H