00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <config.h>
00024
00025 #include <qnamespace.h>
00026 #include <qwindowdefs.h>
00027
00028 #if defined(Q_WS_X11) || defined(Q_WS_WIN) || defined(Q_WS_MACX) // Only compile this module if we're compiling for X11, mac or win32
00029
00030 #include "kkeyserver_x11.h"
00031 #include "kkeynative.h"
00032 #include "kshortcut.h"
00033
00034 #include <kconfig.h>
00035 #include <kdebug.h>
00036 #include <kglobal.h>
00037 #include <klocale.h>
00038
00039 #ifdef Q_WS_X11
00040 # define XK_MISCELLANY
00041 # define XK_XKB_KEYS
00042 # include <X11/X.h>
00043 # include <X11/Xlib.h>
00044 # include <X11/Xutil.h>
00045 # include <X11/keysymdef.h>
00046 # define X11_ONLY(arg) arg, //allows to omit an argument
00047 #else
00048 # include <kckey.h>
00049 # define X11_ONLY(arg)
00050 # define XK_ISO_Left_Tab Qt::Key_Backtab
00051 # define XK_BackSpace Qt::Key_Backspace
00052 # define XK_Sys_Req Qt::Key_SysReq
00053 # define XK_Caps_Lock Qt::Key_CapsLock
00054 # define XK_Num_Lock Qt::Key_NumLock
00055 # define XK_Scroll_Lock Qt::Key_ScrollLock
00056 # define XK_Prior Qt::Key_Prior
00057 # define XK_Next Qt::Key_Next
00058 #endif
00059
00060 namespace KKeyServer
00061 {
00062
00063
00064
00065
00066
00067 struct Mod
00068 {
00069 int m_mod;
00070 };
00071
00072
00073
00074
00075
00076 struct ModInfo
00077 {
00078 KKey::ModFlag mod;
00079 int modQt;
00080 #ifdef Q_WS_X11
00081 uint modX;
00082 #endif
00083 const char* psName;
00084 QString sLabel;
00085 };
00086
00087 struct SymVariation
00088 {
00089 uint sym, symVariation;
00090 bool bActive;
00091 };
00092
00093 struct SymName
00094 {
00095 uint sym;
00096 const char* psName;
00097 };
00098
00099 struct TransKey {
00100 int keySymQt;
00101 uint keySymX;
00102 };
00103
00104
00105
00106
00107
00108 static ModInfo g_rgModInfo[KKey::MOD_FLAG_COUNT] =
00109 {
00110 { KKey::SHIFT, Qt::SHIFT, X11_ONLY(ShiftMask) I18N_NOOP("Shift"), QString() },
00111 { KKey::CTRL, Qt::CTRL, X11_ONLY(ControlMask) I18N_NOOP("Ctrl"), QString() },
00112 { KKey::ALT, Qt::ALT, X11_ONLY(Mod1Mask) I18N_NOOP("Alt"), QString() },
00113 { KKey::WIN, KKey::QtWIN, X11_ONLY(Mod4Mask) I18N_NOOP("Win"), QString() }
00114 };
00115
00116
00117 static const SymName g_rgSymNames[] = {
00118 { XK_ISO_Left_Tab, "Backtab" },
00119 { XK_BackSpace, I18N_NOOP("Backspace") },
00120 { XK_Sys_Req, I18N_NOOP("SysReq") },
00121 { XK_Caps_Lock, I18N_NOOP("CapsLock") },
00122 { XK_Num_Lock, I18N_NOOP("NumLock") },
00123 { XK_Scroll_Lock, I18N_NOOP("ScrollLock") },
00124 { XK_Prior, I18N_NOOP("PageUp") },
00125 { XK_Next, I18N_NOOP("PageDown") },
00126 #ifdef sun
00127 { XK_F11, I18N_NOOP("Stop") },
00128 { XK_F12, I18N_NOOP("Again") },
00129 { XK_F13, I18N_NOOP("Props") },
00130 { XK_F14, I18N_NOOP("Undo") },
00131 { XK_F15, I18N_NOOP("Front") },
00132 { XK_F16, I18N_NOOP("Copy") },
00133 { XK_F17, I18N_NOOP("Open") },
00134 { XK_F18, I18N_NOOP("Paste") },
00135 { XK_F19, I18N_NOOP("Find") },
00136 { XK_F20, I18N_NOOP("Cut") },
00137 { XK_F22, I18N_NOOP("Print") },
00138 #endif
00139 { 0, 0 }
00140 };
00141
00142 #ifdef Q_WS_X11
00143 static SymVariation g_rgSymVariation[] =
00144 {
00145 { '/', XK_KP_Divide, false },
00146 { '*', XK_KP_Multiply, false },
00147 { '-', XK_KP_Subtract, false },
00148 { '+', XK_KP_Add, false },
00149 { XK_Return, XK_KP_Enter, false },
00150 { 0, 0, false }
00151 };
00152
00153
00154
00155
00156 static const TransKey g_rgQtToSymX[] =
00157 {
00158 { Qt::Key_Escape, XK_Escape },
00159 { Qt::Key_Tab, XK_Tab },
00160 { Qt::Key_Backtab, XK_ISO_Left_Tab },
00161 { Qt::Key_Backspace, XK_BackSpace },
00162 { Qt::Key_Return, XK_Return },
00163 { Qt::Key_Enter, XK_KP_Enter },
00164 { Qt::Key_Insert, XK_Insert },
00165 { Qt::Key_Delete, XK_Delete },
00166 { Qt::Key_Pause, XK_Pause },
00167 #ifdef sun
00168 { Qt::Key_Print, XK_F22 },
00169 #else
00170 { Qt::Key_Print, XK_Print },
00171 #endif
00172 { Qt::Key_SysReq, XK_Sys_Req },
00173 { Qt::Key_Home, XK_Home },
00174 { Qt::Key_End, XK_End },
00175 { Qt::Key_Left, XK_Left },
00176 { Qt::Key_Up, XK_Up },
00177 { Qt::Key_Right, XK_Right },
00178 { Qt::Key_Down, XK_Down },
00179 { Qt::Key_Prior, XK_Prior },
00180 { Qt::Key_Next, XK_Next },
00181
00182
00183
00184
00185 { Qt::Key_CapsLock, XK_Caps_Lock },
00186 { Qt::Key_NumLock, XK_Num_Lock },
00187 { Qt::Key_ScrollLock, XK_Scroll_Lock },
00188 { Qt::Key_F1, XK_F1 },
00189 { Qt::Key_F2, XK_F2 },
00190 { Qt::Key_F3, XK_F3 },
00191 { Qt::Key_F4, XK_F4 },
00192 { Qt::Key_F5, XK_F5 },
00193 { Qt::Key_F6, XK_F6 },
00194 { Qt::Key_F7, XK_F7 },
00195 { Qt::Key_F8, XK_F8 },
00196 { Qt::Key_F9, XK_F9 },
00197 { Qt::Key_F10, XK_F10 },
00198 { Qt::Key_F11, XK_F11 },
00199 { Qt::Key_F12, XK_F12 },
00200 { Qt::Key_F13, XK_F13 },
00201 { Qt::Key_F14, XK_F14 },
00202 { Qt::Key_F15, XK_F15 },
00203 { Qt::Key_F16, XK_F16 },
00204 { Qt::Key_F17, XK_F17 },
00205 { Qt::Key_F18, XK_F18 },
00206 { Qt::Key_F19, XK_F19 },
00207 { Qt::Key_F20, XK_F20 },
00208 { Qt::Key_F21, XK_F21 },
00209 { Qt::Key_F22, XK_F22 },
00210 { Qt::Key_F23, XK_F23 },
00211 { Qt::Key_F24, XK_F24 },
00212 { Qt::Key_F25, XK_F25 },
00213 { Qt::Key_F26, XK_F26 },
00214 { Qt::Key_F27, XK_F27 },
00215 { Qt::Key_F28, XK_F28 },
00216 { Qt::Key_F29, XK_F29 },
00217 { Qt::Key_F30, XK_F30 },
00218 { Qt::Key_F31, XK_F31 },
00219 { Qt::Key_F32, XK_F32 },
00220 { Qt::Key_F33, XK_F33 },
00221 { Qt::Key_F34, XK_F34 },
00222 { Qt::Key_F35, XK_F35 },
00223 { Qt::Key_Super_L, XK_Super_L },
00224 { Qt::Key_Super_R, XK_Super_R },
00225 { Qt::Key_Menu, XK_Menu },
00226 { Qt::Key_Hyper_L, XK_Hyper_L },
00227 { Qt::Key_Hyper_R, XK_Hyper_R },
00228 { Qt::Key_Help, XK_Help },
00229
00230
00231
00232 { '/', XK_KP_Divide },
00233 { '*', XK_KP_Multiply },
00234 { '-', XK_KP_Subtract },
00235 { '+', XK_KP_Add },
00236 { Qt::Key_Return, XK_KP_Enter }
00237 #if QT_VERSION >= 0x030100
00238
00239
00240
00241 #define XF86XK_Standby 0x1008FF10
00242 #define XF86XK_AudioLowerVolume 0x1008FF11
00243 #define XF86XK_AudioMute 0x1008FF12
00244 #define XF86XK_AudioRaiseVolume 0x1008FF13
00245 #define XF86XK_AudioPlay 0x1008FF14
00246 #define XF86XK_AudioStop 0x1008FF15
00247 #define XF86XK_AudioPrev 0x1008FF16
00248 #define XF86XK_AudioNext 0x1008FF17
00249 #define XF86XK_HomePage 0x1008FF18
00250 #define XF86XK_Calculator 0x1008FF1D
00251 #define XF86XK_Mail 0x1008FF19
00252 #define XF86XK_Start 0x1008FF1A
00253 #define XF86XK_Search 0x1008FF1B
00254 #define XF86XK_AudioRecord 0x1008FF1C
00255 #define XF86XK_Back 0x1008FF26
00256 #define XF86XK_Forward 0x1008FF27
00257 #define XF86XK_Stop 0x1008FF28
00258 #define XF86XK_Refresh 0x1008FF29
00259 #define XF86XK_Favorites 0x1008FF30
00260 #define XF86XK_AudioPause 0x1008FF31
00261 #define XF86XK_AudioMedia 0x1008FF32
00262 #define XF86XK_MyComputer 0x1008FF33
00263 #define XF86XK_OpenURL 0x1008FF38
00264 #define XF86XK_Launch0 0x1008FF40
00265 #define XF86XK_Launch1 0x1008FF41
00266 #define XF86XK_Launch2 0x1008FF42
00267 #define XF86XK_Launch3 0x1008FF43
00268 #define XF86XK_Launch4 0x1008FF44
00269 #define XF86XK_Launch5 0x1008FF45
00270 #define XF86XK_Launch6 0x1008FF46
00271 #define XF86XK_Launch7 0x1008FF47
00272 #define XF86XK_Launch8 0x1008FF48
00273 #define XF86XK_Launch9 0x1008FF49
00274 #define XF86XK_LaunchA 0x1008FF4A
00275 #define XF86XK_LaunchB 0x1008FF4B
00276 #define XF86XK_LaunchC 0x1008FF4C
00277 #define XF86XK_LaunchD 0x1008FF4D
00278 #define XF86XK_LaunchE 0x1008FF4E
00279 #define XF86XK_LaunchF 0x1008FF4F
00280
00281 ,
00282 { Qt::Key_Standby, XF86XK_Standby },
00283 { Qt::Key_VolumeDown, XF86XK_AudioLowerVolume },
00284 { Qt::Key_VolumeMute, XF86XK_AudioMute },
00285 { Qt::Key_VolumeUp, XF86XK_AudioRaiseVolume },
00286 { Qt::Key_MediaPlay, XF86XK_AudioPlay },
00287 { Qt::Key_MediaStop, XF86XK_AudioStop },
00288 { Qt::Key_MediaPrev, XF86XK_AudioPrev },
00289 { Qt::Key_MediaNext, XF86XK_AudioNext },
00290 { Qt::Key_HomePage, XF86XK_HomePage },
00291 { Qt::Key_LaunchMail, XF86XK_Mail },
00292 { Qt::Key_Search, XF86XK_Search },
00293 { Qt::Key_MediaRecord, XF86XK_AudioRecord },
00294 { Qt::Key_LaunchMedia, XF86XK_AudioMedia },
00295 { Qt::Key_Launch1, XF86XK_Calculator },
00296 { Qt::Key_Back, XF86XK_Back },
00297 { Qt::Key_Forward, XF86XK_Forward },
00298 { Qt::Key_Stop, XF86XK_Stop },
00299 { Qt::Key_Refresh, XF86XK_Refresh },
00300 { Qt::Key_Favorites, XF86XK_Favorites },
00301 { Qt::Key_Launch0, XF86XK_MyComputer },
00302 { Qt::Key_OpenUrl, XF86XK_OpenURL },
00303 { Qt::Key_Launch2, XF86XK_Launch0 },
00304 { Qt::Key_Launch3, XF86XK_Launch1 },
00305 { Qt::Key_Launch4, XF86XK_Launch2 },
00306 { Qt::Key_Launch5, XF86XK_Launch3 },
00307 { Qt::Key_Launch6, XF86XK_Launch4 },
00308 { Qt::Key_Launch7, XF86XK_Launch5 },
00309 { Qt::Key_Launch8, XF86XK_Launch6 },
00310 { Qt::Key_Launch9, XF86XK_Launch7 },
00311 { Qt::Key_LaunchA, XF86XK_Launch8 },
00312 { Qt::Key_LaunchB, XF86XK_Launch9 },
00313 { Qt::Key_LaunchC, XF86XK_LaunchA },
00314 { Qt::Key_LaunchD, XF86XK_LaunchB },
00315 { Qt::Key_LaunchE, XF86XK_LaunchC },
00316 { Qt::Key_LaunchF, XF86XK_LaunchD },
00317 #endif
00318 };
00319 #endif //Q_WS_X11
00320
00321
00322
00323
00324 static bool g_bInitializedMods, g_bInitializedVariations, g_bInitializedKKeyLabels;
00325 static bool g_bMacLabels;
00326 #ifdef Q_WS_X11
00327 static uint g_modXNumLock, g_modXScrollLock;
00328
00329 bool initializeMods()
00330 {
00331 XModifierKeymap* xmk = XGetModifierMapping( qt_xdisplay() );
00332
00333 g_rgModInfo[3].modX = g_modXNumLock = g_modXScrollLock = 0;
00334
00335 int min_keycode, max_keycode;
00336 int keysyms_per_keycode = 0;
00337 XDisplayKeycodes( qt_xdisplay(), &min_keycode, &max_keycode );
00338 XFree( XGetKeyboardMapping( qt_xdisplay(), min_keycode, 1, &keysyms_per_keycode ));
00339
00340 for( int i = Mod2MapIndex; i < 8; i++ ) {
00341 uint mask = (1 << i);
00342 uint keySymX = NoSymbol;
00343
00344
00345
00346
00347 for( int j = 0; j < xmk->max_keypermod && keySymX == NoSymbol; ++j )
00348 for( int k = 0; k < keysyms_per_keycode && keySymX == NoSymbol; ++k )
00349 keySymX = XKeycodeToKeysym( qt_xdisplay(), xmk->modifiermap[xmk->max_keypermod * i + j], k );
00350 switch( keySymX ) {
00351 case XK_Num_Lock: g_modXNumLock = mask; break;
00352 case XK_Super_L:
00353 case XK_Super_R: g_rgModInfo[3].modX = mask; break;
00354 case XK_Meta_L:
00355 case XK_Meta_R: if( !g_rgModInfo[3].modX ) g_rgModInfo[3].modX = mask; break;
00356 case XK_Scroll_Lock: g_modXScrollLock = mask; break;
00357 }
00358 }
00359
00360 XFreeModifiermap( xmk );
00361
00362
00363
00364
00365 g_bInitializedMods = true;
00366
00367 kdDebug(125) << "KKeyServer::initializeMods(): Win Mod = 0x" << QString::number(g_rgModInfo[3].modX, 16) << endl;
00368 return true;
00369 }
00370
00371 static void initializeVariations()
00372 {
00373 for( int i = 0; g_rgSymVariation[i].sym != 0; i++ )
00374 g_rgSymVariation[i].bActive = (XKeysymToKeycode( qt_xdisplay(), g_rgSymVariation[i].symVariation ) != 0);
00375 g_bInitializedVariations = true;
00376 }
00377 #endif //Q_WS_X11
00378
00379 static void intializeKKeyLabels()
00380 {
00381 KConfigGroupSaver cgs( KGlobal::config(), "Keyboard" );
00382 g_rgModInfo[0].sLabel = KGlobal::config()->readEntry( "Label Shift", i18n(g_rgModInfo[0].psName) );
00383 g_rgModInfo[1].sLabel = KGlobal::config()->readEntry( "Label Ctrl", i18n(g_rgModInfo[1].psName) );
00384 g_rgModInfo[2].sLabel = KGlobal::config()->readEntry( "Label Alt", i18n(g_rgModInfo[2].psName) );
00385 g_rgModInfo[3].sLabel = KGlobal::config()->readEntry( "Label Win", i18n(g_rgModInfo[3].psName) );
00386 g_bMacLabels = (g_rgModInfo[2].sLabel == "Command");
00387 g_bInitializedKKeyLabels = true;
00388 }
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403 bool Sym::initQt( int keyQt )
00404 {
00405 int symQt = keyQt & 0xffff;
00406
00407 if( (keyQt & Qt::UNICODE_ACCEL) || symQt < 0x1000 ) {
00408 m_sym = QChar(symQt).lower().unicode();
00409 return true;
00410 }
00411
00412 #ifdef Q_WS_WIN
00413 m_sym = symQt;
00414 return true;
00415 #elif defined(Q_WS_X11)
00416 for( uint i = 0; i < sizeof(g_rgQtToSymX)/sizeof(TransKey); i++ ) {
00417 if( g_rgQtToSymX[i].keySymQt == symQt ) {
00418 m_sym = g_rgQtToSymX[i].keySymX;
00419 return true;
00420 }
00421 }
00422
00423 m_sym = 0;
00424 if( symQt != Qt::Key_Shift && symQt != Qt::Key_Control && symQt != Qt::Key_Alt &&
00425 symQt != Qt::Key_Meta && symQt != Qt::Key_Direction_L && symQt != Qt::Key_Direction_R )
00426 kdDebug(125) << "Sym::initQt( " << QString::number(keyQt,16) << " ): failed to convert key." << endl;
00427 return false;
00428 #elif defined(Q_WS_MACX)
00429 m_sym = symQt;
00430 return true;
00431 #endif
00432 }
00433
00434 bool Sym::init( const QString& s )
00435 {
00436
00437 if( s.length() == 1 ) {
00438 m_sym = s[0].lower().unicode();
00439 return true;
00440 }
00441
00442
00443 for( int i = 0; g_rgSymNames[i].sym != 0; i++ ) {
00444 if( qstricmp( s.latin1(), g_rgSymNames[i].psName ) == 0 ) {
00445 m_sym = g_rgSymNames[i].sym;
00446 return true;
00447 }
00448 }
00449
00450 #ifdef Q_WS_WIN
00451
00452 for ( KKeys const *pKey = kde_KKEYS; pKey->code != 0xffff; pKey++) {
00453 if( qstricmp( s.latin1(), pKey->name ) == 0 ) {
00454 m_sym = pKey->code;
00455 return true;
00456 }
00457 }
00458 m_sym = 0;
00459 #elif defined(Q_WS_X11)
00460
00461 m_sym = XStringToKeysym( s.latin1() );
00462 if( !m_sym ) {
00463 m_sym = XStringToKeysym( s.lower().latin1() );
00464 if( !m_sym ) {
00465 QString s2 = s;
00466 s2[0] = s2[0].upper();
00467 m_sym = XStringToKeysym( s2.latin1() );
00468 }
00469 }
00470 #endif
00471 return m_sym != 0;
00472 }
00473
00474 int Sym::qt() const
00475 {
00476 if( m_sym < 0x1000 ) {
00477 if( m_sym >= 'a' && m_sym <= 'z' )
00478 return QChar(m_sym).upper();
00479 return m_sym;
00480 }
00481 #ifdef Q_WS_WIN
00482 if( m_sym < 0x3000 )
00483 return m_sym;
00484 #elif defined(Q_WS_X11)
00485 if( m_sym < 0x3000 )
00486 return m_sym | Qt::UNICODE_ACCEL;
00487
00488 for( uint i = 0; i < sizeof(g_rgQtToSymX)/sizeof(TransKey); i++ )
00489 if( g_rgQtToSymX[i].keySymX == m_sym )
00490 return g_rgQtToSymX[i].keySymQt;
00491 #endif
00492 return Qt::Key_unknown;
00493 }
00494
00495 QString Sym::toString( bool bUserSpace ) const
00496 {
00497 if( m_sym == 0 )
00498 return QString::null;
00499
00500
00501 #ifdef Q_WS_WIN
00502 else if( m_sym < 0x1000 ) {
00503 #else
00504 else if( m_sym < 0x3000 ) {
00505 #endif
00506 QChar c = QChar(m_sym).upper();
00507
00508
00509 if( (c.latin1() && c.isLetterOrNumber())
00510 || (bUserSpace && !c.isSpace()) )
00511 return c;
00512 }
00513
00514
00515 for( int i = 0; g_rgSymNames[i].sym != 0; i++ ) {
00516 if( m_sym == g_rgSymNames[i].sym )
00517 return bUserSpace ? i18n(g_rgSymNames[i].psName) : QString(g_rgSymNames[i].psName);
00518 }
00519
00520 QString s;
00521 #ifdef Q_WS_WIN
00522 s = QKeySequence( m_sym );
00523 #elif defined(Q_WS_X11)
00524
00525 s = XKeysymToString( m_sym );
00526 #endif
00527 capitalizeKeyname( s );
00528 return bUserSpace ? i18n("QAccel", s.latin1()) : s;
00529 }
00530
00531 QString Sym::toStringInternal() const { return toString( false ); }
00532 QString Sym::toString() const { return toString( true ); }
00533
00534 uint Sym::getModsRequired() const
00535 {
00536 uint mod = 0;
00537 #ifdef Q_WS_X11
00538
00539 if( m_sym == XK_Sys_Req ) return KKey::ALT;
00540 if( m_sym == XK_Break ) return KKey::CTRL;
00541
00542 if( m_sym < 0x3000 ) {
00543 QChar c(m_sym);
00544 if( c.isLetter() && c.lower() != c.upper() && m_sym == c.upper().unicode() )
00545 return KKey::SHIFT;
00546 }
00547
00548 uchar code = XKeysymToKeycode( qt_xdisplay(), m_sym );
00549 if( code ) {
00550
00551
00552
00553 if( m_sym == XKeycodeToKeysym( qt_xdisplay(), code, 0 ) )
00554 ;
00555 else if( m_sym == XKeycodeToKeysym( qt_xdisplay(), code, 1 ) )
00556 mod = KKey::SHIFT;
00557 else if( m_sym == XKeycodeToKeysym( qt_xdisplay(), code, 2 ) )
00558 mod = KKeyServer::MODE_SWITCH;
00559 else if( m_sym == XKeycodeToKeysym( qt_xdisplay(), code, 3 ) )
00560 mod = KKey::SHIFT | KKeyServer::MODE_SWITCH;
00561 }
00562 #endif
00563 return mod;
00564 }
00565
00566 uint Sym::getSymVariation() const
00567 {
00568 #ifdef Q_WS_X11
00569 if( !g_bInitializedVariations )
00570 initializeVariations();
00571 for( int i = 0; g_rgSymVariation[i].sym != 0; i++ )
00572 if( g_rgSymVariation[i].sym == m_sym && g_rgSymVariation[i].bActive )
00573 return g_rgSymVariation[i].symVariation;
00574 #endif
00575 return 0;
00576 }
00577
00578 void Sym::capitalizeKeyname( QString& s )
00579 {
00580 s[0] = s[0].upper();
00581 int len = s.length();
00582 if( s.endsWith( "left" ) ) s[len-4] = 'L';
00583 else if( s.endsWith( "right" ) ) s[len-5] = 'R';
00584 else if( s == "Sysreq" ) s[len-3] = 'R';
00585 }
00586
00587
00588
00589
00590
00591 #ifdef Q_WS_X11
00592 uint modX( KKey::ModFlag mod )
00593 {
00594 if( mod == KKey::WIN && !g_bInitializedMods )
00595 initializeMods();
00596
00597 for( uint i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
00598 if( g_rgModInfo[i].mod == mod )
00599 return g_rgModInfo[i].modX;
00600 }
00601 return 0;
00602 }
00603
00604 bool keyboardHasWinKey() { if( !g_bInitializedMods ) { initializeMods(); } return g_rgModInfo[3].modX != 0; }
00605 uint modXShift() { return ShiftMask; }
00606 uint modXLock() { return LockMask; }
00607 uint modXCtrl() { return ControlMask; }
00608 uint modXAlt() { return Mod1Mask; }
00609 uint modXNumLock() { if( !g_bInitializedMods ) { initializeMods(); } return g_modXNumLock; }
00610 uint modXWin() { if( !g_bInitializedMods ) { initializeMods(); } return g_rgModInfo[3].modX; }
00611 uint modXScrollLock() { if( !g_bInitializedMods ) { initializeMods(); } return g_modXScrollLock; }
00612
00613 uint accelModMaskX()
00614 {
00615 if( !g_bInitializedMods )
00616 initializeMods();
00617 return ShiftMask | ControlMask | Mod1Mask | g_rgModInfo[3].modX;
00618 }
00619 #endif //Q_WS_X11
00620
00621 bool keyQtToSym( int keyQt, uint& keySym )
00622 {
00623 Sym sym;
00624 if( sym.initQt( keyQt ) ) {
00625 keySym = sym.m_sym;
00626 return true;
00627 } else
00628 return false;
00629 }
00630
00631 bool keyQtToMod( int keyQt, uint& mod )
00632 {
00633 mod = 0;
00634
00635 if( keyQt & Qt::SHIFT ) mod |= KKey::SHIFT;
00636 if( keyQt & Qt::CTRL ) mod |= KKey::CTRL;
00637 if( keyQt & Qt::ALT ) mod |= KKey::ALT;
00638 if( keyQt & Qt::META ) mod |= KKey::WIN;
00639
00640 return true;
00641 }
00642
00643 bool symToKeyQt( uint keySym, int& keyQt )
00644 {
00645 Sym sym( keySym );
00646 keyQt = sym.qt();
00647 return (keyQt != Qt::Key_unknown);
00648 }
00649
00650 bool modToModQt( uint mod, int& modQt )
00651 {
00652 modQt = 0;
00653 for( int i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
00654 if( mod & g_rgModInfo[i].mod ) {
00655 if( !g_rgModInfo[i].modQt ) {
00656 modQt = 0;
00657 return false;
00658 }
00659 modQt |= g_rgModInfo[i].modQt;
00660 }
00661 }
00662 return true;
00663 }
00664
00665 #ifdef Q_WS_WIN
00666
00667 bool modXToModQt( uint modX, int& modQt )
00668 {
00669 return modToModQt( modX, modQt );
00670 }
00671
00672 KDECORE_EXPORT int qtButtonStateToMod( Qt::ButtonState s )
00673 {
00674 int modQt = 0;
00675 if (s & Qt::ShiftButton) modQt |= KKey::SHIFT;
00676 if (s & Qt::ControlButton) modQt |= KKey::CTRL;
00677 if (s & Qt::AltButton) modQt |= KKey::ALT;
00678 return modQt;
00679 }
00680
00681 bool keyboardHasWinKey() {
00683 return true;
00684 }
00685
00686 #elif defined(Q_WS_MACX)
00687
00688 bool modXToModQt(uint modX, int& modQt)
00689 {
00690 return modToModQt( modX, modQt );
00691 }
00692
00693 bool keyboardHasWinKey() {
00695 return false;
00696 }
00697
00698 bool modXToMod( uint , uint& )
00699 {
00700 return false;
00701 }
00702 #elif defined(Q_WS_X11)
00703
00704 bool modToModX( uint mod, uint& modX )
00705 {
00706 if( !g_bInitializedMods )
00707 initializeMods();
00708
00709 modX = 0;
00710 for( int i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
00711 if( mod & g_rgModInfo[i].mod ) {
00712 if( !g_rgModInfo[i].modX ) {
00713 kdDebug(125) << "Invalid modifier flag." << endl;
00714 modX = 0;
00715 return false;
00716 }
00717 modX |= g_rgModInfo[i].modX;
00718 }
00719 }
00720
00721 if( mod & 0x2000 )
00722 modX |= 0x2000;
00723 return true;
00724 }
00725
00726 bool modXToModQt( uint modX, int& modQt )
00727 {
00728 if( !g_bInitializedMods )
00729 initializeMods();
00730
00731 modQt = 0;
00732 for( int i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
00733 if( modX & g_rgModInfo[i].modX ) {
00734 if( !g_rgModInfo[i].modQt ) {
00735 modQt = 0;
00736 return false;
00737 }
00738 modQt |= g_rgModInfo[i].modQt;
00739 }
00740 }
00741 return true;
00742 }
00743
00744 bool modXToMod( uint modX, uint& mod )
00745 {
00746 if( !g_bInitializedMods )
00747 initializeMods();
00748
00749 mod = 0;
00750 for( int i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
00751 if( modX & g_rgModInfo[i].modX )
00752 mod |= g_rgModInfo[i].mod;
00753 }
00754 return true;
00755 }
00756
00757 bool codeXToSym( uchar codeX, uint modX, uint& sym )
00758 {
00759 KeySym keySym;
00760 XKeyPressedEvent event;
00761
00762 event.type = KeyPress;
00763 event.display = qt_xdisplay();
00764 event.state = modX;
00765 event.keycode = codeX;
00766
00767 XLookupString( &event, 0, 0, &keySym, 0 );
00768 sym = (uint) keySym;
00769 return true;
00770 }
00771 #endif
00772
00773 static QString modToString( uint mod, bool bUserSpace )
00774 {
00775 if( bUserSpace && !g_bInitializedKKeyLabels )
00776 intializeKKeyLabels();
00777
00778 QString s;
00779 for( int i = KKey::MOD_FLAG_COUNT-1; i >= 0; i-- ) {
00780 if( mod & g_rgModInfo[i].mod ) {
00781 if( !s.isEmpty() )
00782 s += '+';
00783 s += (bUserSpace)
00784 ? g_rgModInfo[i].sLabel
00785 : QString(g_rgModInfo[i].psName);
00786 }
00787 }
00788 return s;
00789 }
00790
00791 QString modToStringInternal( uint mod ) { return modToString( mod, false ); }
00792 QString modToStringUser( uint mod ) { return modToString( mod, true ); }
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910 bool Key::init( const KKey& key, bool bQt )
00911 {
00912 if( bQt ) {
00913 m_code = CODE_FOR_QT;
00914 m_sym = key.keyCodeQt();
00915 } else {
00916 KKeyNative keyNative( key );
00917 *this = keyNative;
00918 }
00919 return true;
00920 }
00921
00922 KKey Key::key() const
00923 {
00924 if( m_code == CODE_FOR_QT )
00925 return KKey( keyCodeQt() );
00926 else {
00927 #if defined(Q_WS_WIN) || defined(Q_WS_MACX)
00928 return KKey();
00929 #else
00930 uint mod;
00931 modXToMod( m_mod, mod );
00932 return KKey( m_sym, mod );
00933 #endif
00934 }
00935 }
00936
00937 Key& Key::operator =( const KKeyNative& key )
00938 {
00939 m_code = key.code(); m_mod = key.mod(); m_sym = key.sym();
00940 return *this;
00941 }
00942
00943 int Key::compare( const Key& b ) const
00944 {
00945 if( m_code == CODE_FOR_QT )
00946 return m_sym - b.m_sym;
00947 if( m_sym != b.m_sym ) return m_sym - b.m_sym;
00948 if( m_mod != b.m_mod ) return m_mod - b.m_mod;
00949 return m_code - b.m_code;
00950 }
00951
00952
00953
00954
00955
00956
00957 void Variations::init( const KKey& key, bool bQt )
00958 {
00959 if( key.isNull() ) {
00960 m_nVariations = 0;
00961 return;
00962 }
00963
00964 m_nVariations = 1;
00965 m_rgkey[0] = KKeyNative(key);
00966 uint symVar = Sym(key.sym()).getSymVariation();
00967 if( symVar ) {
00968 uint modReq = Sym(m_rgkey[0].sym()).getModsRequired();
00969 uint modReqVar = Sym(symVar).getModsRequired();
00970
00971
00972 if( (key.modFlags() & modReq) == (key.modFlags() & modReqVar) ) {
00973 m_rgkey[1] = KKeyNative(KKey(symVar, key.modFlags()));
00974 m_nVariations = 2;
00975 }
00976 }
00977
00978 if( bQt ) {
00979 uint nVariations = 0;
00980 for( uint i = 0; i < m_nVariations; i++ ) {
00981 int keyQt = KKeyNative( m_rgkey[i].code(), m_rgkey[i].mod(), m_rgkey[i].sym() ).keyCodeQt();
00982 if( keyQt )
00983 m_rgkey[nVariations++].setKeycodeQt( keyQt );
00984 }
00985 m_nVariations = nVariations;
00986
00987
00988
00989 for( uint i = 1; i < m_nVariations; i++ ) {
00990 for( uint j = 0; j < i; j++ ) {
00991
00992 if( m_rgkey[i].keyCodeQt() == m_rgkey[j].keyCodeQt() ) {
00993 for( uint k = i; k < m_nVariations - 1; k++ )
00994 m_rgkey[k].setKeycodeQt( m_rgkey[k+1].keyCodeQt() );
00995 m_nVariations--;
00996 i--;
00997 break;
00998 }
00999 }
01000 }
01001 }
01002 }
01003
01004 }
01005
01006
01007
01008
01009
01010
01011
01012 void KKey::simplify()
01013 {
01014 #ifdef Q_WS_X11
01015 if( m_sym == XK_Sys_Req ) {
01016 m_sym = XK_Print;
01017 m_mod |= ALT;
01018 } else if( m_sym == XK_ISO_Left_Tab ) {
01019 m_sym = XK_Tab;
01020 m_mod |= SHIFT;
01021 } else {
01022
01023 m_sym = KKeyNative(*this).sym();
01024 }
01025
01026
01027 if( m_sym < 0x3000 && QChar(m_sym).isLetter() )
01028 m_sym = QChar(m_sym).lower().unicode();
01029
01030
01031
01032 m_mod &= ~KKeyServer::Sym(m_sym).getModsRequired();
01033 #endif
01034 }
01035
01036 #endif //Q_WS_X11 || Q_WS_WIN
01037