You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1071 lines
30 KiB
1071 lines
30 KiB
/*
|
|
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.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <tqnamespace.h>
|
|
#include <tqwindowdefs.h>
|
|
|
|
#if defined(TQ_WS_X11) || defined(TQ_WS_WIN) || defined(TQ_WS_MACX) // Only compile this module if we're compiling for X11, mac or win32
|
|
|
|
#include "kkeyserver_x11.h"
|
|
#include "kkeynative.h"
|
|
#include "tdeshortcut.h"
|
|
|
|
#include <tdeconfig.h>
|
|
#include <kdebug.h>
|
|
#include <tdeglobal.h>
|
|
#include <tdelocale.h>
|
|
|
|
#ifdef TQ_WS_X11
|
|
# define XK_MISCELLANY
|
|
# define XK_XKB_KEYS
|
|
# include <X11/X.h>
|
|
# include <X11/Xlib.h>
|
|
# include <X11/Xutil.h>
|
|
# include <X11/XKBlib.h>
|
|
# include <X11/keysymdef.h>
|
|
# define X11_ONLY(arg) arg, //allows to omit an argument
|
|
#else
|
|
# include <kckey.h>
|
|
# define X11_ONLY(arg)
|
|
# define XK_ISO_Left_Tab TQt::Key_Backtab
|
|
# define XK_BackSpace TQt::Key_Backspace
|
|
# define XK_Sys_Req TQt::Key_SysReq
|
|
# define XK_Caps_Lock TQt::Key_CapsLock
|
|
# define XK_Num_Lock TQt::Key_NumLock
|
|
# define XK_Scroll_Lock TQt::Key_ScrollLock
|
|
# define XK_Prior TQt::Key_Prior
|
|
# define XK_Next TQt::Key_Next
|
|
#endif
|
|
|
|
namespace KKeyServer
|
|
{
|
|
|
|
//---------------------------------------------------------------------
|
|
// Data Structures
|
|
//---------------------------------------------------------------------
|
|
|
|
struct Mod
|
|
{
|
|
int m_mod;
|
|
};
|
|
|
|
//---------------------------------------------------------------------
|
|
// Array Structures
|
|
//---------------------------------------------------------------------
|
|
|
|
struct ModInfo
|
|
{
|
|
KKey::ModFlag mod;
|
|
int modQt;
|
|
#ifdef TQ_WS_X11
|
|
uint modX;
|
|
#endif
|
|
const char* psName;
|
|
TQString sLabel;
|
|
};
|
|
|
|
struct SymVariation
|
|
{
|
|
uint sym, symVariation;
|
|
bool bActive;
|
|
};
|
|
|
|
struct SymName
|
|
{
|
|
uint sym;
|
|
const char* psName;
|
|
};
|
|
|
|
struct TransKey {
|
|
int keySymQt;
|
|
uint keySymX;
|
|
};
|
|
|
|
//---------------------------------------------------------------------
|
|
// Arrays
|
|
//---------------------------------------------------------------------
|
|
|
|
static ModInfo g_rgModInfo[KKey::MOD_FLAG_COUNT] =
|
|
{
|
|
{ KKey::SHIFT, TQt::SHIFT, X11_ONLY(ShiftMask) I18N_NOOP("Shift"), TQString() },
|
|
{ KKey::CTRL, TQt::CTRL, X11_ONLY(ControlMask) I18N_NOOP("Ctrl"), TQString() },
|
|
{ KKey::ALT, TQt::ALT, X11_ONLY(Mod1Mask) I18N_NOOP("Alt"), TQString() },
|
|
{ KKey::WIN, KKey::QtWIN, X11_ONLY(Mod4Mask) I18N_NOOP("Win"), TQString() }
|
|
};
|
|
|
|
// Special Names List
|
|
static const SymName g_rgSymNames[] = {
|
|
{ XK_ISO_Left_Tab, "Backtab" },
|
|
{ XK_BackSpace, I18N_NOOP("Backspace") },
|
|
{ XK_Sys_Req, I18N_NOOP("SysReq") },
|
|
{ XK_Caps_Lock, I18N_NOOP("CapsLock") },
|
|
{ XK_Num_Lock, I18N_NOOP("NumLock") },
|
|
{ XK_Scroll_Lock, I18N_NOOP("ScrollLock") },
|
|
{ XK_Prior, I18N_NOOP("PageUp") },
|
|
{ XK_Next, I18N_NOOP("PageDown") },
|
|
#ifdef sun
|
|
{ XK_F11, I18N_NOOP("Stop") },
|
|
{ XK_F12, I18N_NOOP("Again") },
|
|
{ XK_F13, I18N_NOOP("Props") },
|
|
{ XK_F14, I18N_NOOP("Undo") },
|
|
{ XK_F15, I18N_NOOP("Front") },
|
|
{ XK_F16, I18N_NOOP("Copy") },
|
|
{ XK_F17, I18N_NOOP("Open") },
|
|
{ XK_F18, I18N_NOOP("Paste") },
|
|
{ XK_F19, I18N_NOOP("Find") },
|
|
{ XK_F20, I18N_NOOP("Cut") },
|
|
{ XK_F22, I18N_NOOP("Print") },
|
|
#endif
|
|
{ 0, 0 }
|
|
};
|
|
|
|
#ifdef TQ_WS_X11
|
|
static SymVariation g_rgSymVariation[] =
|
|
{
|
|
{ '/', XK_KP_Divide, false },
|
|
{ '*', XK_KP_Multiply, false },
|
|
{ '-', XK_KP_Subtract, false },
|
|
{ '+', XK_KP_Add, false },
|
|
{ XK_Return, XK_KP_Enter, false },
|
|
{ 0, 0, false }
|
|
};
|
|
|
|
// TODO: Add Mac key names list: Key_Backspace => "Delete", Key_Delete => "Del"
|
|
|
|
// These are the X equivalents to the Qt keycodes 0x1000 - 0x1026
|
|
static const TransKey g_rgQtToSymX[] =
|
|
{
|
|
{ TQt::Key_Escape, XK_Escape },
|
|
{ TQt::Key_Tab, XK_Tab },
|
|
{ TQt::Key_Backtab, XK_ISO_Left_Tab },
|
|
{ TQt::Key_Backspace, XK_BackSpace },
|
|
{ TQt::Key_Return, XK_Return },
|
|
{ TQt::Key_Enter, XK_KP_Enter },
|
|
{ TQt::Key_Insert, XK_Insert },
|
|
{ TQt::Key_Delete, XK_Delete },
|
|
{ TQt::Key_Pause, XK_Pause },
|
|
#ifdef sun
|
|
{ TQt::Key_Print, XK_F22 },
|
|
#else
|
|
{ TQt::Key_Print, XK_Print },
|
|
#endif
|
|
{ TQt::Key_SysReq, XK_Sys_Req },
|
|
{ TQt::Key_Home, XK_Home },
|
|
{ TQt::Key_End, XK_End },
|
|
{ TQt::Key_Left, XK_Left },
|
|
{ TQt::Key_Up, XK_Up },
|
|
{ TQt::Key_Right, XK_Right },
|
|
{ TQt::Key_Down, XK_Down },
|
|
{ TQt::Key_Prior, XK_Prior },
|
|
{ TQt::Key_Next, XK_Next },
|
|
//{ TQt::Key_Shift, 0 },
|
|
//{ TQt::Key_Control, 0 },
|
|
//{ TQt::Key_Meta, 0 },
|
|
//{ TQt::Key_Alt, 0 },
|
|
{ TQt::Key_CapsLock, XK_Caps_Lock },
|
|
{ TQt::Key_NumLock, XK_Num_Lock },
|
|
{ TQt::Key_ScrollLock, XK_Scroll_Lock },
|
|
{ TQt::Key_F1, XK_F1 },
|
|
{ TQt::Key_F2, XK_F2 },
|
|
{ TQt::Key_F3, XK_F3 },
|
|
{ TQt::Key_F4, XK_F4 },
|
|
{ TQt::Key_F5, XK_F5 },
|
|
{ TQt::Key_F6, XK_F6 },
|
|
{ TQt::Key_F7, XK_F7 },
|
|
{ TQt::Key_F8, XK_F8 },
|
|
{ TQt::Key_F9, XK_F9 },
|
|
{ TQt::Key_F10, XK_F10 },
|
|
{ TQt::Key_F11, XK_F11 },
|
|
{ TQt::Key_F12, XK_F12 },
|
|
{ TQt::Key_F13, XK_F13 },
|
|
{ TQt::Key_F14, XK_F14 },
|
|
{ TQt::Key_F15, XK_F15 },
|
|
{ TQt::Key_F16, XK_F16 },
|
|
{ TQt::Key_F17, XK_F17 },
|
|
{ TQt::Key_F18, XK_F18 },
|
|
{ TQt::Key_F19, XK_F19 },
|
|
{ TQt::Key_F20, XK_F20 },
|
|
{ TQt::Key_F21, XK_F21 },
|
|
{ TQt::Key_F22, XK_F22 },
|
|
{ TQt::Key_F23, XK_F23 },
|
|
{ TQt::Key_F24, XK_F24 },
|
|
{ TQt::Key_F25, XK_F25 },
|
|
{ TQt::Key_F26, XK_F26 },
|
|
{ TQt::Key_F27, XK_F27 },
|
|
{ TQt::Key_F28, XK_F28 },
|
|
{ TQt::Key_F29, XK_F29 },
|
|
{ TQt::Key_F30, XK_F30 },
|
|
{ TQt::Key_F31, XK_F31 },
|
|
{ TQt::Key_F32, XK_F32 },
|
|
{ TQt::Key_F33, XK_F33 },
|
|
{ TQt::Key_F34, XK_F34 },
|
|
{ TQt::Key_F35, XK_F35 },
|
|
{ TQt::Key_Super_L, XK_Super_L },
|
|
{ TQt::Key_Super_R, XK_Super_R },
|
|
{ TQt::Key_Menu, XK_Menu },
|
|
{ TQt::Key_Hyper_L, XK_Hyper_L },
|
|
{ TQt::Key_Hyper_R, XK_Hyper_R },
|
|
{ TQt::Key_Help, XK_Help },
|
|
//{ TQt::Key_Direction_L, XK_Direction_L }, These keys don't exist in X11
|
|
//{ TQt::Key_Direction_R, XK_Direction_R },
|
|
|
|
{ '/', XK_KP_Divide },
|
|
{ '*', XK_KP_Multiply },
|
|
{ '-', XK_KP_Subtract },
|
|
{ '+', XK_KP_Add },
|
|
{ TQt::Key_Return, XK_KP_Enter }
|
|
#if TQT_VERSION >= 0x030100
|
|
|
|
// the next lines are taken from XFree > 4.0 (X11/XF86keysyms.h), defining some special
|
|
// multimedia keys. They are included here as not every system has them.
|
|
#define XF86XK_Standby 0x1008FF10
|
|
#define XF86XK_AudioLowerVolume 0x1008FF11
|
|
#define XF86XK_AudioMute 0x1008FF12
|
|
#define XF86XK_AudioRaiseVolume 0x1008FF13
|
|
#define XF86XK_AudioPlay 0x1008FF14
|
|
#define XF86XK_AudioStop 0x1008FF15
|
|
#define XF86XK_AudioPrev 0x1008FF16
|
|
#define XF86XK_AudioNext 0x1008FF17
|
|
#define XF86XK_HomePage 0x1008FF18
|
|
#define XF86XK_Calculator 0x1008FF1D
|
|
#define XF86XK_Mail 0x1008FF19
|
|
#define XF86XK_Start 0x1008FF1A
|
|
#define XF86XK_Search 0x1008FF1B
|
|
#define XF86XK_AudioRecord 0x1008FF1C
|
|
#define XF86XK_Back 0x1008FF26
|
|
#define XF86XK_Forward 0x1008FF27
|
|
#define XF86XK_Stop 0x1008FF28
|
|
#define XF86XK_Refresh 0x1008FF29
|
|
#define XF86XK_Favorites 0x1008FF30
|
|
#define XF86XK_AudioPause 0x1008FF31
|
|
#define XF86XK_AudioMedia 0x1008FF32
|
|
#define XF86XK_MyComputer 0x1008FF33
|
|
#define XF86XK_OpenURL 0x1008FF38
|
|
#define XF86XK_Launch0 0x1008FF40
|
|
#define XF86XK_Launch1 0x1008FF41
|
|
#define XF86XK_Launch2 0x1008FF42
|
|
#define XF86XK_Launch3 0x1008FF43
|
|
#define XF86XK_Launch4 0x1008FF44
|
|
#define XF86XK_Launch5 0x1008FF45
|
|
#define XF86XK_Launch6 0x1008FF46
|
|
#define XF86XK_Launch7 0x1008FF47
|
|
#define XF86XK_Launch8 0x1008FF48
|
|
#define XF86XK_Launch9 0x1008FF49
|
|
#define XF86XK_LaunchA 0x1008FF4A
|
|
#define XF86XK_LaunchB 0x1008FF4B
|
|
#define XF86XK_LaunchC 0x1008FF4C
|
|
#define XF86XK_LaunchD 0x1008FF4D
|
|
#define XF86XK_LaunchE 0x1008FF4E
|
|
#define XF86XK_LaunchF 0x1008FF4F
|
|
#define XF86XK_MonBrightnessUp 0x1008FF02 /* Monitor/panel brightness */
|
|
#define XF86XK_MonBrightnessDown 0x1008FF03 /* Monitor/panel brightness */
|
|
#define XF86XK_KbdLightOnOff 0x1008FF04 /* Keyboards may be lit */
|
|
#define XF86XK_KbdBrightnessUp 0x1008FF05 /* Keyboards may be lit */
|
|
#define XF86XK_KbdBrightnessDown 0x1008FF06 /* Keyboards may be lit */
|
|
// end of XF86keysyms.h
|
|
,
|
|
{ TQt::Key_Standby, XF86XK_Standby },
|
|
{ TQt::Key_VolumeDown, XF86XK_AudioLowerVolume },
|
|
{ TQt::Key_VolumeMute, XF86XK_AudioMute },
|
|
{ TQt::Key_VolumeUp, XF86XK_AudioRaiseVolume },
|
|
{ TQt::Key_MediaPlay, XF86XK_AudioPlay },
|
|
{ TQt::Key_MediaStop, XF86XK_AudioStop },
|
|
{ TQt::Key_MediaPrev, XF86XK_AudioPrev },
|
|
{ TQt::Key_MediaNext, XF86XK_AudioNext },
|
|
{ TQt::Key_HomePage, XF86XK_HomePage },
|
|
{ TQt::Key_LaunchMail, XF86XK_Mail },
|
|
{ TQt::Key_Search, XF86XK_Search },
|
|
{ TQt::Key_MediaRecord, XF86XK_AudioRecord },
|
|
{ TQt::Key_LaunchMedia, XF86XK_AudioMedia },
|
|
{ TQt::Key_Launch1, XF86XK_Calculator },
|
|
{ TQt::Key_Back, XF86XK_Back },
|
|
{ TQt::Key_Forward, XF86XK_Forward },
|
|
{ TQt::Key_Stop, XF86XK_Stop },
|
|
{ TQt::Key_Refresh, XF86XK_Refresh },
|
|
{ TQt::Key_Favorites, XF86XK_Favorites },
|
|
{ TQt::Key_Launch0, XF86XK_MyComputer },
|
|
{ TQt::Key_OpenUrl, XF86XK_OpenURL },
|
|
{ TQt::Key_Launch2, XF86XK_Launch0 },
|
|
{ TQt::Key_Launch3, XF86XK_Launch1 },
|
|
{ TQt::Key_Launch4, XF86XK_Launch2 },
|
|
{ TQt::Key_Launch5, XF86XK_Launch3 },
|
|
{ TQt::Key_Launch6, XF86XK_Launch4 },
|
|
{ TQt::Key_Launch7, XF86XK_Launch5 },
|
|
{ TQt::Key_Launch8, XF86XK_Launch6 },
|
|
{ TQt::Key_Launch9, XF86XK_Launch7 },
|
|
{ TQt::Key_LaunchA, XF86XK_Launch8 },
|
|
{ TQt::Key_LaunchB, XF86XK_Launch9 },
|
|
{ TQt::Key_LaunchC, XF86XK_LaunchA },
|
|
{ TQt::Key_LaunchD, XF86XK_LaunchB },
|
|
{ TQt::Key_LaunchE, XF86XK_LaunchC },
|
|
{ TQt::Key_LaunchF, XF86XK_LaunchD },
|
|
{ TQt::Key_MonBrightnessUp, XF86XK_MonBrightnessUp },
|
|
{ TQt::Key_MonBrightnessDown, XF86XK_MonBrightnessDown },
|
|
{ TQt::Key_KeyboardLightOnOff, XF86XK_KbdLightOnOff },
|
|
{ TQt::Key_KeyboardBrightnessUp, XF86XK_KbdBrightnessUp },
|
|
{ TQt::Key_KeyboardBrightnessDown, XF86XK_KbdBrightnessDown },
|
|
#endif
|
|
};
|
|
#endif //TQ_WS_X11
|
|
|
|
//---------------------------------------------------------------------
|
|
// Initialization
|
|
//---------------------------------------------------------------------
|
|
static bool g_bInitializedMods, g_bInitializedVariations, g_bInitializedKKeyLabels;
|
|
static bool g_bMacLabels;
|
|
#ifdef TQ_WS_X11
|
|
static uint g_modXNumLock, g_modXScrollLock, g_modXModeSwitch;
|
|
|
|
bool initializeMods()
|
|
{
|
|
XModifierKeymap* xmk = XGetModifierMapping( tqt_xdisplay() );
|
|
|
|
g_rgModInfo[3].modX = g_modXNumLock = g_modXScrollLock = g_modXModeSwitch = 0;
|
|
|
|
int min_keycode, max_keycode;
|
|
int keysyms_per_keycode = 0;
|
|
XDisplayKeycodes( tqt_xdisplay(), &min_keycode, &max_keycode );
|
|
XFree( XGetKeyboardMapping( tqt_xdisplay(), min_keycode, 1, &keysyms_per_keycode ));
|
|
// Qt assumes that Alt is always Mod1Mask, so start at Mod2Mask.
|
|
for( int i = Mod2MapIndex; i < 8; i++ ) {
|
|
uint mask = (1 << i);
|
|
uint keySymX = NoSymbol;
|
|
// This used to be only XkbKeycodeToKeysym( ... , 0, 0 ), but that fails with XFree4.3.99
|
|
// and X.org R6.7 , where for some reason only ( ... , 0, 1 ) works. I have absolutely no
|
|
// idea what the problem is, but searching all posibilities until something valid is
|
|
// found fixes the problem.
|
|
for( int j = 0; j < xmk->max_keypermod && keySymX == NoSymbol; ++j )
|
|
for( int k = 0; k < keysyms_per_keycode && keySymX == NoSymbol; ++k )
|
|
keySymX = XkbKeycodeToKeysym( tqt_xdisplay(), xmk->modifiermap[xmk->max_keypermod * i + j], 0, k );
|
|
switch( keySymX ) {
|
|
case XK_Num_Lock: g_modXNumLock = mask; break; // Normally Mod2Mask
|
|
case XK_Super_L:
|
|
case XK_Super_R: g_rgModInfo[3].modX = mask; break; // Win key, Normally Mod4Mask
|
|
case XK_Meta_L:
|
|
case XK_Meta_R: if( !g_rgModInfo[3].modX ) g_rgModInfo[3].modX = mask; break; // Win alternate
|
|
case XK_Scroll_Lock: g_modXScrollLock = mask; break; // Normally Mod5Mask
|
|
case XK_Mode_switch: g_modXModeSwitch = mask; break;
|
|
}
|
|
}
|
|
|
|
XFreeModifiermap( xmk );
|
|
|
|
//TDEConfigGroupSaver cgs( TDEGlobal::config(), "Keyboard" );
|
|
// read in mod that win should be attached to
|
|
|
|
g_bInitializedMods = true;
|
|
|
|
kdDebug(125) << "KKeyServer::initializeMods(): Win Mod = 0x" << TQString::number(g_rgModInfo[3].modX, 16) << endl;
|
|
return true;
|
|
}
|
|
|
|
static void initializeVariations()
|
|
{
|
|
for( int i = 0; g_rgSymVariation[i].sym != 0; i++ )
|
|
g_rgSymVariation[i].bActive = (XKeysymToKeycode( tqt_xdisplay(), g_rgSymVariation[i].symVariation ) != 0);
|
|
g_bInitializedVariations = true;
|
|
}
|
|
#endif //TQ_WS_X11
|
|
|
|
static void intializeKKeyLabels()
|
|
{
|
|
TDEConfigGroupSaver cgs( TDEGlobal::config(), "Keyboard" );
|
|
g_rgModInfo[0].sLabel = TDEGlobal::config()->readEntry( "Label Shift", i18n(g_rgModInfo[0].psName) );
|
|
g_rgModInfo[1].sLabel = TDEGlobal::config()->readEntry( "Label Ctrl", i18n(g_rgModInfo[1].psName) );
|
|
g_rgModInfo[2].sLabel = TDEGlobal::config()->readEntry( "Label Alt", i18n(g_rgModInfo[2].psName) );
|
|
g_rgModInfo[3].sLabel = TDEGlobal::config()->readEntry( "Label Win", i18n(g_rgModInfo[3].psName) );
|
|
g_bMacLabels = (g_rgModInfo[2].sLabel == "Command");
|
|
g_bInitializedKKeyLabels = true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// class Mod
|
|
//---------------------------------------------------------------------
|
|
|
|
/*void Mod::init( const TQString& s )
|
|
{
|
|
|
|
}*/
|
|
|
|
//---------------------------------------------------------------------
|
|
// class Sym
|
|
//---------------------------------------------------------------------
|
|
|
|
bool Sym::initQt( int keyQt )
|
|
{
|
|
int symQt = keyQt & 0xffff;
|
|
|
|
if( (keyQt & TQt::UNICODE_ACCEL) || symQt < 0x1000 ) {
|
|
m_sym = TQChar(symQt).lower().unicode();
|
|
return true;
|
|
}
|
|
|
|
#ifdef TQ_WS_WIN
|
|
m_sym = symQt;
|
|
return true;
|
|
#elif defined(TQ_WS_X11)
|
|
for( uint i = 0; i < sizeof(g_rgQtToSymX)/sizeof(TransKey); i++ ) {
|
|
if( g_rgQtToSymX[i].keySymQt == symQt ) {
|
|
m_sym = g_rgQtToSymX[i].keySymX;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
m_sym = 0;
|
|
if( symQt != TQt::Key_Shift && symQt != TQt::Key_Control && symQt != TQt::Key_Alt &&
|
|
symQt != TQt::Key_Meta && symQt != TQt::Key_Direction_L && symQt != TQt::Key_Direction_R )
|
|
kdDebug(125) << "Sym::initQt( " << TQString::number(keyQt,16) << " ): failed to convert key." << endl;
|
|
return false;
|
|
#elif defined(TQ_WS_MACX)
|
|
m_sym = symQt;
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
bool Sym::init( const TQString& s )
|
|
{
|
|
// If it's a single character, get unicode value.
|
|
if( s.length() == 1 ) {
|
|
m_sym = s[0].lower().unicode();
|
|
return true;
|
|
}
|
|
|
|
// Look up in special names list
|
|
for( int i = 0; g_rgSymNames[i].sym != 0; i++ ) {
|
|
if( tqstricmp( s.latin1(), g_rgSymNames[i].psName ) == 0 ) {
|
|
m_sym = g_rgSymNames[i].sym;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
#ifdef TQ_WS_WIN
|
|
// search for name in KKeys array
|
|
for ( KKeys const *pKey = kde_KKEYS; pKey->code != 0xffff; pKey++) {
|
|
if( tqstricmp( s.latin1(), pKey->name ) == 0 ) {
|
|
m_sym = pKey->code;
|
|
return true;
|
|
}
|
|
}
|
|
m_sym = 0;
|
|
#elif defined(TQ_WS_X11)
|
|
// search X list: 's' as is, all lower, first letter in caps
|
|
m_sym = XStringToKeysym( s.latin1() );
|
|
if( !m_sym ) {
|
|
m_sym = XStringToKeysym( s.lower().latin1() );
|
|
if( !m_sym ) {
|
|
TQString s2 = s;
|
|
s2[0] = s2[0].upper();
|
|
m_sym = XStringToKeysym( s2.latin1() );
|
|
}
|
|
}
|
|
#endif
|
|
return m_sym != 0;
|
|
}
|
|
|
|
int Sym::qt() const
|
|
{
|
|
if( m_sym < 0x1000 ) {
|
|
if( m_sym >= 'a' && m_sym <= 'z' )
|
|
return TQChar(m_sym).upper();
|
|
return m_sym;
|
|
}
|
|
#ifdef TQ_WS_WIN
|
|
if( m_sym < 0x3000 )
|
|
return m_sym;
|
|
#elif defined(TQ_WS_X11)
|
|
if( m_sym < 0x3000 )
|
|
return m_sym | TQt::UNICODE_ACCEL;
|
|
|
|
for( uint i = 0; i < sizeof(g_rgQtToSymX)/sizeof(TransKey); i++ )
|
|
if( g_rgQtToSymX[i].keySymX == m_sym )
|
|
return g_rgQtToSymX[i].keySymQt;
|
|
#endif
|
|
return TQt::Key_unknown;
|
|
}
|
|
|
|
TQString Sym::toString( bool bUserSpace ) const
|
|
{
|
|
if( m_sym == 0 ) {
|
|
return TQString::null;
|
|
}
|
|
|
|
// If it's a unicode character,
|
|
#ifdef TQ_WS_WIN
|
|
else if( m_sym < 0x1000 ) {
|
|
#else
|
|
else if( m_sym < 0x3000 ) {
|
|
#endif
|
|
TQChar c = TQChar(m_sym).upper();
|
|
// Print all non-space characters directly when output is user-visible.
|
|
// Otherwise only print alphanumeric latin1 characters directly (A,B,C,1,2,3).
|
|
if( (c.latin1() && c.isLetterOrNumber())
|
|
|| (bUserSpace && !c.isSpace()) ) {
|
|
return c;
|
|
}
|
|
}
|
|
|
|
// Look up in special names list
|
|
for( int i = 0; g_rgSymNames[i].sym != 0; i++ ) {
|
|
if( m_sym == g_rgSymNames[i].sym ) {
|
|
return bUserSpace ? i18n(g_rgSymNames[i].psName) : TQString(g_rgSymNames[i].psName);
|
|
}
|
|
}
|
|
|
|
TQString s;
|
|
#ifdef TQ_WS_WIN
|
|
s = TQKeySequence( m_sym );
|
|
#elif defined(TQ_WS_X11)
|
|
// Get X-name
|
|
s = XKeysymToString( m_sym );
|
|
#endif
|
|
capitalizeKeyname( s );
|
|
return bUserSpace ? i18n("TQAccel", s.latin1()) : s;
|
|
}
|
|
|
|
TQString Sym::toStringInternal() const { return toString( false ); }
|
|
TQString Sym::toString() const { return toString( true ); }
|
|
|
|
uint Sym::getModsRequired() const
|
|
{
|
|
uint mod = 0;
|
|
#ifdef TQ_WS_X11
|
|
// FIXME: This might not be true on all keyboard layouts!
|
|
if( m_sym == XK_Sys_Req ) return KKey::ALT;
|
|
if( m_sym == XK_Break ) return KKey::CTRL;
|
|
|
|
if( m_sym < 0x3000 ) {
|
|
TQChar c(m_sym);
|
|
if( c.isLetter() && c.lower() != c.upper() && m_sym == c.upper().unicode() )
|
|
return KKey::SHIFT;
|
|
}
|
|
|
|
uchar code = XKeysymToKeycode( tqt_xdisplay(), m_sym );
|
|
if( code ) {
|
|
// need to check index 0 before the others, so that a null-mod
|
|
// can take precedence over the others, in case the modified
|
|
// key produces the same symbol.
|
|
if( m_sym == XkbKeycodeToKeysym( tqt_xdisplay(), code, 0, 0 ) )
|
|
;
|
|
else if( m_sym == XkbKeycodeToKeysym( tqt_xdisplay(), code, 0, 1 ) )
|
|
mod = KKey::SHIFT;
|
|
else if( m_sym == XkbKeycodeToKeysym( tqt_xdisplay(), code, 0, 2 ) )
|
|
mod = KKeyServer::MODE_SWITCH;
|
|
else if( m_sym == XkbKeycodeToKeysym( tqt_xdisplay(), code, 0, 3 ) )
|
|
mod = KKey::SHIFT | KKeyServer::MODE_SWITCH;
|
|
}
|
|
#endif
|
|
return mod;
|
|
}
|
|
|
|
uint Sym::getSymVariation() const
|
|
{
|
|
#ifdef TQ_WS_X11
|
|
if( !g_bInitializedVariations )
|
|
initializeVariations();
|
|
for( int i = 0; g_rgSymVariation[i].sym != 0; i++ )
|
|
if( g_rgSymVariation[i].sym == m_sym && g_rgSymVariation[i].bActive )
|
|
return g_rgSymVariation[i].symVariation;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
void Sym::capitalizeKeyname( TQString& s )
|
|
{
|
|
s[0] = s[0].upper();
|
|
int len = s.length();
|
|
if( s.endsWith( "left" ) ) s[len-4] = 'L';
|
|
else if( s.endsWith( "right" ) ) s[len-5] = 'R';
|
|
else if( s == "Sysreq" ) s[len-3] = 'R';
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// Public functions
|
|
//---------------------------------------------------------------------
|
|
|
|
#ifdef TQ_WS_X11
|
|
uint modX( KKey::ModFlag mod )
|
|
{
|
|
if( mod == KKey::WIN && !g_bInitializedMods )
|
|
initializeMods();
|
|
|
|
for( uint i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
|
|
if( g_rgModInfo[i].mod == mod )
|
|
return g_rgModInfo[i].modX;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool keyboardHasWinKey() { if( !g_bInitializedMods ) { initializeMods(); } return g_rgModInfo[3].modX != 0; }
|
|
uint modXShift() { return ShiftMask; }
|
|
uint modXLock() { return LockMask; }
|
|
uint modXCtrl() { return ControlMask; }
|
|
uint modXAlt() { return Mod1Mask; }
|
|
uint modXNumLock() { if( !g_bInitializedMods ) { initializeMods(); } return g_modXNumLock; }
|
|
uint modXWin() { if( !g_bInitializedMods ) { initializeMods(); } return g_rgModInfo[3].modX; }
|
|
uint modXScrollLock() { if( !g_bInitializedMods ) { initializeMods(); } return g_modXScrollLock; }
|
|
uint modXModeSwitch() { if( !g_bInitializedMods ) { initializeMods(); } return g_modXModeSwitch; }
|
|
|
|
uint accelModMaskX()
|
|
{
|
|
if( !g_bInitializedMods )
|
|
initializeMods();
|
|
return ShiftMask | ControlMask | Mod1Mask | g_rgModInfo[3].modX;
|
|
}
|
|
#endif //TQ_WS_X11
|
|
|
|
bool keyQtToSym( int keyQt, uint& keySym )
|
|
{
|
|
Sym sym;
|
|
if( sym.initQt( keyQt ) ) {
|
|
keySym = sym.m_sym;
|
|
return true;
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
bool keyQtToMod( int keyQt, uint& mod )
|
|
{
|
|
mod = 0;
|
|
|
|
if( keyQt & TQt::SHIFT ) mod |= KKey::SHIFT;
|
|
if( keyQt & TQt::CTRL ) mod |= KKey::CTRL;
|
|
if( keyQt & TQt::ALT ) mod |= KKey::ALT;
|
|
if( keyQt & TQt::META ) mod |= KKey::WIN;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool symToKeyQt( uint keySym, int& keyQt )
|
|
{
|
|
Sym sym( keySym );
|
|
keyQt = sym.qt();
|
|
return (keyQt != TQt::Key_unknown);
|
|
}
|
|
|
|
bool modToModQt( uint mod, int& modQt )
|
|
{
|
|
modQt = 0;
|
|
for( int i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
|
|
if( mod & g_rgModInfo[i].mod ) {
|
|
if( !g_rgModInfo[i].modQt ) {
|
|
modQt = 0;
|
|
return false;
|
|
}
|
|
modQt |= g_rgModInfo[i].modQt;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#ifdef TQ_WS_WIN
|
|
//wrapped
|
|
bool modXToModQt( uint modX, int& modQt )
|
|
{
|
|
return modToModQt( modX, modQt );
|
|
}
|
|
|
|
TDECORE_EXPORT int qtButtonStateToMod( TQt::ButtonState s )
|
|
{
|
|
int modQt = 0;
|
|
if (s & TQt::ShiftButton) modQt |= KKey::SHIFT;
|
|
if (s & TQt::ControlButton) modQt |= KKey::CTRL;
|
|
if (s & TQt::AltButton) modQt |= KKey::ALT;
|
|
return modQt;
|
|
}
|
|
|
|
bool keyboardHasWinKey() {
|
|
//! TODO
|
|
return true;
|
|
}
|
|
|
|
#elif defined(TQ_WS_MACX)
|
|
|
|
bool modXToModQt(uint modX, int& modQt)
|
|
{
|
|
return modToModQt( modX, modQt );
|
|
}
|
|
|
|
bool keyboardHasWinKey() {
|
|
//! TODO - A win key on the Mac...?
|
|
return false;
|
|
}
|
|
|
|
bool modXToMod( uint , uint& )
|
|
{
|
|
return false;
|
|
}
|
|
#elif defined(TQ_WS_X11)
|
|
|
|
bool modToModX( uint mod, uint& modX )
|
|
{
|
|
if( !g_bInitializedMods )
|
|
initializeMods();
|
|
|
|
modX = 0;
|
|
for( int i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
|
|
if( mod & g_rgModInfo[i].mod ) {
|
|
if( !g_rgModInfo[i].modX ) {
|
|
kdDebug(125) << "Invalid modifier flag." << endl;
|
|
modX = 0;
|
|
return false;
|
|
}
|
|
modX |= g_rgModInfo[i].modX;
|
|
}
|
|
}
|
|
// TODO: document 0x2000 flag
|
|
if( mod & 0x2000 )
|
|
modX |= 0x2000;
|
|
return true;
|
|
}
|
|
|
|
bool modXToModQt( uint modX, int& modQt )
|
|
{
|
|
if( !g_bInitializedMods )
|
|
initializeMods();
|
|
|
|
modQt = 0;
|
|
for( int i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
|
|
if( modX & g_rgModInfo[i].modX ) {
|
|
if( !g_rgModInfo[i].modQt ) {
|
|
modQt = 0;
|
|
return false;
|
|
}
|
|
modQt |= g_rgModInfo[i].modQt;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool modXToMod( uint modX, uint& mod )
|
|
{
|
|
if( !g_bInitializedMods )
|
|
initializeMods();
|
|
|
|
mod = 0;
|
|
for( int i = 0; i < KKey::MOD_FLAG_COUNT; i++ ) {
|
|
if( modX & g_rgModInfo[i].modX )
|
|
mod |= g_rgModInfo[i].mod;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool codeXToSym( uchar codeX, uint modX, uint& sym )
|
|
{
|
|
KeySym keySym;
|
|
XKeyPressedEvent event;
|
|
|
|
event.type = KeyPress;
|
|
event.display = tqt_xdisplay();
|
|
event.state = modX;
|
|
event.keycode = codeX;
|
|
|
|
char buffer[64];
|
|
XLookupString( &event, buffer, 63, &keySym, NULL );
|
|
sym = (uint) keySym;
|
|
return true;
|
|
}
|
|
#endif //!TQ_WS_WIN
|
|
|
|
static TQString modToString( uint mod, bool bUserSpace )
|
|
{
|
|
if( bUserSpace && !g_bInitializedKKeyLabels )
|
|
intializeKKeyLabels();
|
|
|
|
TQString s;
|
|
for( int i = KKey::MOD_FLAG_COUNT-1; i >= 0; i-- ) {
|
|
if( mod & g_rgModInfo[i].mod ) {
|
|
if( !s.isEmpty() )
|
|
s += '+';
|
|
s += (bUserSpace)
|
|
? g_rgModInfo[i].sLabel
|
|
: TQString(g_rgModInfo[i].psName);
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
TQString modToStringInternal( uint mod ) { return modToString( mod, false ); }
|
|
TQString modToStringUser( uint mod ) { return modToString( mod, true ); }
|
|
|
|
uint stringUserToMod( const TQString& mod )
|
|
{
|
|
if( !g_bInitializedKKeyLabels )
|
|
intializeKKeyLabels();
|
|
|
|
TQString s;
|
|
for( int i = KKey::MOD_FLAG_COUNT-1; i >= 0; i-- ) {
|
|
if( mod.lower() == g_rgModInfo[i].sLabel.lower())
|
|
return g_rgModInfo[i].mod;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*void keySymModToKeyX( uint sym, uint mod, unsigned char *pKeyCodeX, uint *pKeySymX, uint *pKeyModX )
|
|
{
|
|
...
|
|
uint keySymQt;
|
|
uint keySymX = 0;
|
|
unsigned char keyCodeX = 0;
|
|
uint keyModX = 0;
|
|
|
|
const char *psKeySym = 0;
|
|
|
|
if( !g_bInitialized )
|
|
Initialize();
|
|
|
|
// Get code of just the primary key
|
|
keySymQt = keyCombQt & 0xffff;
|
|
|
|
// If unicode value beneath 0x1000 (special Qt codes begin thereafter),
|
|
if( keySymQt < 0x1000 ) {
|
|
// For reasons unbeknownst to me, Qt converts 'a-z' to 'A-Z'.
|
|
// So convert it back to lowercase if SHIFT isn't held down.
|
|
if( keySymQt >= TQt::Key_A && keySymQt <= TQt::Key_Z && !(keyCombQt & TQt::SHIFT) )
|
|
keySymQt = tolower( keySymQt );
|
|
keySymX = keySymQt;
|
|
}
|
|
// Else, special key (e.g. Delete, F1, etc.)
|
|
else {
|
|
for( int i = 0; i < NB_KEYS; i++ ) {
|
|
if( keySymQt == (uint) KKEYS[i].code ) {
|
|
psKeySym = KKEYS[i].name;
|
|
//kdDebug(125) << " symbol found: \"" << psKeySym << "\"" << endl;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Get X key symbol. Only works if Qt name is same as X name.
|
|
if( psKeySym ) {
|
|
TQString sKeySym = psKeySym;
|
|
|
|
// Check for lower-case equalent first because most
|
|
// X11 names are all lower-case.
|
|
keySymX = XStringToKeysym( sKeySym.lower().ascii() );
|
|
if( keySymX == 0 )
|
|
keySymX = XStringToKeysym( psKeySym );
|
|
}
|
|
|
|
if( keySymX == 0 )
|
|
keySymX = getSymXEquiv( keySymQt );
|
|
}
|
|
|
|
if( keySymX != 0 ) {
|
|
// Get X keyboard code
|
|
keyCodeX = XKeysymToKeycode( tqt_xdisplay(), keySymX );
|
|
// Add ModeSwitch modifier bit, if necessary
|
|
keySymXMods( keySymX, 0, &keyModX );
|
|
|
|
// Get X modifier flags
|
|
for( int i = 0; i < MOD_KEYS; i++ ) {
|
|
if( keyCombQt & g_aModKeys[i].keyModMaskQt ) {
|
|
if( g_aModKeys[i].keyModMaskX )
|
|
keyModX |= g_aModKeys[i].keyModMaskX;
|
|
// Qt key calls for a modifier which the current
|
|
// X modifier map doesn't support.
|
|
else {
|
|
keySymX = 0;
|
|
keyCodeX = 0;
|
|
keyModX = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Take care of complications:
|
|
// The following keys will not have been correctly interpreted,
|
|
// because their shifted values are not activated with the
|
|
// Shift key, but rather something else. They are also
|
|
// defined twice under different keycodes.
|
|
// keycode 111 & 92: Print Sys_Req -> Sys_Req = Alt+Print
|
|
// keycode 110 & 114: Pause Break -> Break = Ctrl+Pause
|
|
if( (keyCodeX == 92 || keyCodeX == 111) &&
|
|
XkbKeycodeToKeysym( tqt_xdisplay(), 92, 0, 0 ) == XK_Print &&
|
|
XkbKeycodeToKeysym( tqt_xdisplay(), 111, 0, 0 ) == XK_Print )
|
|
{
|
|
// If Alt is pressed, then we need keycode 92, keysym XK_Sys_Req
|
|
if( keyModX & keyModXAlt() ) {
|
|
keyCodeX = 92;
|
|
keySymX = XK_Sys_Req;
|
|
}
|
|
// Otherwise, keycode 111, keysym XK_Print
|
|
else {
|
|
keyCodeX = 111;
|
|
keySymX = XK_Print;
|
|
}
|
|
}
|
|
else if( (keyCodeX == 110 || keyCodeX == 114) &&
|
|
XkbKeycodeToKeysym( tqt_xdisplay(), 110, 0, 0 ) == XK_Pause &&
|
|
XkbKeycodeToKeysym( tqt_xdisplay(), 114, 0, 0 ) == XK_Pause )
|
|
{
|
|
if( keyModX & keyModXCtrl() ) {
|
|
keyCodeX = 114;
|
|
keySymX = XK_Break;
|
|
} else {
|
|
keyCodeX = 110;
|
|
keySymX = XK_Pause;
|
|
}
|
|
}
|
|
|
|
if( pKeySymX ) *pKeySymX = keySymX;
|
|
if( pKeyCodeX ) *pKeyCodeX = keyCodeX;
|
|
if( pKeyModX ) *pKeyModX = keyModX;
|
|
}*/
|
|
|
|
//---------------------------------------------------------------------
|
|
// Key
|
|
//---------------------------------------------------------------------
|
|
|
|
bool Key::init( const KKey& key, bool bQt )
|
|
{
|
|
if( bQt ) {
|
|
m_code = CODE_FOR_QT;
|
|
m_sym = key.keyCodeQt();
|
|
} else {
|
|
KKeyNative keyNative( key );
|
|
*this = keyNative;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
KKey Key::key() const
|
|
{
|
|
if( m_code == CODE_FOR_QT )
|
|
return KKey( keyCodeQt() );
|
|
else {
|
|
#if defined(TQ_WS_WIN) || defined(TQ_WS_MACX)
|
|
return KKey();
|
|
#else
|
|
uint mod;
|
|
modXToMod( m_mod, mod );
|
|
return KKey( m_sym, mod );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
Key& Key::operator =( const KKeyNative& key )
|
|
{
|
|
m_code = key.code(); m_mod = key.mod(); m_sym = key.sym();
|
|
return *this;
|
|
}
|
|
|
|
int Key::compare( const Key& b ) const
|
|
{
|
|
if( m_code == CODE_FOR_QT )
|
|
return m_sym - b.m_sym;
|
|
if( m_sym != b.m_sym ) return m_sym - b.m_sym;
|
|
if( m_mod != b.m_mod ) return m_mod - b.m_mod;
|
|
return m_code - b.m_code;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
// Variations
|
|
//---------------------------------------------------------------------
|
|
|
|
// TODO: allow for sym to have variations, such as Plus => { Plus, KP_Add }
|
|
void Variations::init( const KKey& key, bool bQt )
|
|
{
|
|
if( key.isNull() ) {
|
|
m_nVariations = 0;
|
|
return;
|
|
}
|
|
|
|
m_nVariations = 1;
|
|
m_rgkey[0] = KKeyNative(key);
|
|
uint symVar = Sym(key.sym()).getSymVariation();
|
|
if( symVar ) {
|
|
uint modReq = Sym(m_rgkey[0].sym()).getModsRequired();
|
|
uint modReqVar = Sym(symVar).getModsRequired();
|
|
// If 'key' doesn't require any mods that are inherent in
|
|
// the primary key but not required for the alternate,
|
|
if( (key.modFlags() & modReq) == (key.modFlags() & modReqVar) ) {
|
|
m_rgkey[1] = KKeyNative(KKey(symVar, key.modFlags()));
|
|
m_nVariations = 2;
|
|
}
|
|
}
|
|
|
|
if( bQt ) {
|
|
uint nVariations = 0;
|
|
for( uint i = 0; i < m_nVariations; i++ ) {
|
|
int keyQt = KKeyNative( m_rgkey[i].code(), m_rgkey[i].mod(), m_rgkey[i].sym() ).keyCodeQt();
|
|
if( keyQt ) {
|
|
m_rgkey[nVariations++].setKeycodeQt( keyQt );
|
|
}
|
|
}
|
|
m_nVariations = nVariations;
|
|
|
|
// Two different native codes may produce a single
|
|
// Qt code. Search for duplicates.
|
|
for( uint i = 1; i < m_nVariations; i++ ) {
|
|
for( uint j = 0; j < i; j++ ) {
|
|
// If key is already present in list, then remove it.
|
|
if( m_rgkey[i].keyCodeQt() == m_rgkey[j].keyCodeQt() ) {
|
|
for( uint k = i; k < m_nVariations - 1; k++ ) {
|
|
m_rgkey[k].setKeycodeQt( m_rgkey[k+1].keyCodeQt() );
|
|
}
|
|
m_nVariations--;
|
|
i--;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} // end of namespace KKeyServer block
|
|
|
|
// FIXME: This needs to be moved to tdeshortcut.cpp, and create a
|
|
// KKeyServer::method which it will call.
|
|
// Alt+SysReq => Alt+Print
|
|
// Ctrl+Shift+Plus => Ctrl+Plus (en)
|
|
// Ctrl+Shift+Equal => Ctrl+Plus
|
|
// Ctrl+Pause => Ctrl+Break
|
|
void KKey::simplify()
|
|
{
|
|
#ifdef TQ_WS_X11
|
|
if( m_sym == XK_Sys_Req ) {
|
|
m_sym = XK_Print;
|
|
m_mod |= ALT;
|
|
} else if( m_sym == XK_ISO_Left_Tab ) {
|
|
m_sym = XK_Tab;
|
|
m_mod |= SHIFT;
|
|
} else {
|
|
// Shift+Equal => Shift+Plus (en)
|
|
m_sym = KKeyNative(*this).sym();
|
|
}
|
|
|
|
// If this is a letter, don't remove any modifiers.
|
|
if( m_sym < 0x3000 && TQChar(m_sym).isLetter() ) {
|
|
m_sym = TQChar(m_sym).lower().unicode();
|
|
}
|
|
|
|
// Remove modifers from modifier list which are implicit in the symbol.
|
|
// Ex. Shift+Plus => Plus (en)
|
|
m_mod &= ~KKeyServer::Sym(m_sym).getModsRequired();
|
|
#endif
|
|
}
|
|
|
|
#endif //TQ_WS_X11 || TQ_WS_WIN
|
|
|