From d3f7a9d6f1b8f6e24fb49aaa8caeaa7623ae48b5 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sat, 23 Jul 2011 17:13:36 -0500 Subject: Apply all Qt3.3.8d patches NOTE: This will *likely* break compilation of TQt4 Please wait a few days for fixes to be committed as needed! --- tqtinterface/qt4/ChangeLog.immodule | 2027 +++++++ tqtinterface/qt4/README.immodule | 107 + tqtinterface/qt4/changes.immodule | 248 + tqtinterface/qt4/configure | 134 +- tqtinterface/qt4/make-symlinks.sh | 12 + tqtinterface/qt4/mkspecs/hurd-g++/qmake.conf | 13 +- .../qt4/mkspecs/linux-g++-sparc/qmake.conf | 89 + .../qt4/mkspecs/linux-g++-sparc/qplatformdefs.h | 107 + tqtinterface/qt4/mkspecs/linux-g++/qmake.conf | 2 +- .../qt4/mkspecs/linux-g++/tqplatformdefs.h | 1 + .../src/inputmethods/imsw-multi/imsw-multi.pro | 14 + .../imsw-multi/tqmultiinputcontext.cpp | 379 ++ .../inputmethods/imsw-multi/tqmultiinputcontext.h | 124 + .../imsw-multi/tqmultiinputcontextplugin.cpp | 88 + .../imsw-multi/tqmultiinputcontextplugin.h | 63 + .../src/inputmethods/imsw-none/imsw-none.pro | 12 + .../imsw-none/tqnoneinputcontextplugin.cpp | 101 + .../imsw-none/tqnoneinputcontextplugin.h | 62 + .../qt4/plugins/src/inputmethods/inputmethods.pro | 11 + .../src/inputmethods/simple/composetable.cpp | 5605 ++++++++++++++++++++ .../qt4/plugins/src/inputmethods/simple/simple.pro | 15 + .../inputmethods/simple/tqsimpleinputcontext.cpp | 285 + .../src/inputmethods/simple/tqsimpleinputcontext.h | 93 + .../simple/tqsimpleinputcontextplugin.cpp | 86 + .../simple/tqsimpleinputcontextplugin.h | 63 + .../plugins/src/inputmethods/simple/xcompose2q.rb | 450 ++ .../src/inputmethods/xim/tqximinputcontext.h | 130 + .../src/inputmethods/xim/tqximinputcontext_x11.cpp | 930 ++++ .../inputmethods/xim/tqximinputcontextplugin.cpp | 86 + .../src/inputmethods/xim/tqximinputcontextplugin.h | 63 + .../qt4/plugins/src/inputmethods/xim/xim.pro | 14 + .../qt4/plugins/src/sqldrivers/ibase/ibase.pro | 2 +- tqtinterface/qt4/plugins/src/src.pro | 4 +- tqtinterface/qt4/qmake/option.cpp | 2 +- tqtinterface/qt4/src/__debian_export_symbols.cpp | 63 + tqtinterface/qt4/src/codecs/tqutfcodec.cpp | 2 +- tqtinterface/qt4/src/dialogs/tqdialog.cpp | 21 +- tqtinterface/qt4/src/iconview/tqiconview.cpp | 208 +- .../qt4/src/inputmethod/tqinputcontextfactory.cpp | 186 + .../qt4/src/inputmethod/tqinputcontextfactory.h | 59 + .../src/inputmethod/tqinputcontextinterface_p.h | 87 + .../qt4/src/inputmethod/tqinputcontextplugin.cpp | 231 + .../qt4/src/inputmethod/tqinputcontextplugin.h | 67 + .../qt4/src/inputmethod/tqt_inputmethod.pri | 10 + tqtinterface/qt4/src/kernel/qt_kernel.pri | 8 +- tqtinterface/qt4/src/kernel/tqapplication.cpp | 68 +- tqtinterface/qt4/src/kernel/tqapplication.h | 26 +- tqtinterface/qt4/src/kernel/tqapplication_x11.cpp | 754 ++- tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp | 18 + .../qt4/src/kernel/tqdesktopwidget_x11.cpp | 46 +- tqtinterface/qt4/src/kernel/tqdnd_x11.cpp | 138 +- tqtinterface/qt4/src/kernel/tqdragobject.cpp | 10 + tqtinterface/qt4/src/kernel/tqdragobject.h | 3 +- tqtinterface/qt4/src/kernel/tqevent.cpp | 4 + tqtinterface/qt4/src/kernel/tqfontdatabase.cpp | 34 +- tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp | 8 +- tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp | 17 +- tqtinterface/qt4/src/kernel/tqinputcontext.cpp | 856 +++ tqtinterface/qt4/src/kernel/tqinputcontext.h | 143 + tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp | 504 +- tqtinterface/qt4/src/kernel/tqnamespace.h | 92 +- tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp | 15 +- tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp | 593 ++- tqtinterface/qt4/src/kernel/tqrichtext.cpp | 20 +- tqtinterface/qt4/src/kernel/tqrichtext_p.h | 3 +- tqtinterface/qt4/src/kernel/tqt_x11_p.h | 5 + tqtinterface/qt4/src/kernel/tqwidget.cpp | 33 +- tqtinterface/qt4/src/kernel/tqwidget.h | 54 +- tqtinterface/qt4/src/kernel/tqwidget_x11.cpp | 521 +- tqtinterface/qt4/src/opengl/tqgl_x11.cpp | 4 +- tqtinterface/qt4/src/qt.pro | 17 +- .../qt4/src/sql/drivers/ibase/tqsql_ibase.cpp | 2 +- tqtinterface/qt4/src/sql/qt_sql.pri | 2 +- tqtinterface/qt4/src/tools/tqdir_unix.cpp | 23 + tqtinterface/qt4/src/tools/tqfeatures.h | 10 + tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp | 36 +- tqtinterface/qt4/src/tools/tqglobal.h | 10 +- tqtinterface/qt4/src/tools/tqlibrary.cpp | 1 + tqtinterface/qt4/src/tools/tqlocale.cpp | 15 +- tqtinterface/qt4/src/tools/tqmap.h | 1 + tqtinterface/qt4/src/tools/tqstring.h | 2 +- tqtinterface/qt4/src/tools/tqvaluelist.h | 1 + tqtinterface/qt4/src/widgets/tqbutton.h | 4 +- tqtinterface/qt4/src/widgets/tqcombobox.cpp | 32 +- tqtinterface/qt4/src/widgets/tqlineedit.cpp | 108 +- tqtinterface/qt4/src/widgets/tqlineedit.h | 1 + tqtinterface/qt4/src/widgets/tqlistview.cpp | 27 +- tqtinterface/qt4/src/widgets/tqmenubar.cpp | 26 +- tqtinterface/qt4/src/widgets/tqpopupmenu.cpp | 112 +- tqtinterface/qt4/src/widgets/tqpopupmenu.h | 1 + tqtinterface/qt4/src/widgets/tqscrollview.cpp | 5 +- tqtinterface/qt4/src/widgets/tqtextedit.cpp | 124 +- tqtinterface/qt4/src/widgets/tqtextedit.h | 5 +- tqtinterface/qt4/src/widgets/tqtooltip.cpp | 5 + .../qt4/tools/designer/tools/createcw/createcw.pro | 3 + tqtinterface/qt4/tools/designer/uic/form.cpp | 11 +- tqtinterface/qt4/tools/makeqpf/main.cpp | 6 +- tqtinterface/qt4/tools/qtconfig/mainwindow.cpp | 70 +- tqtinterface/qt4/tools/qtconfig/mainwindow.h | 1 + tqtinterface/qt4/tools/qtconfig/mainwindowbase.ui | 21 +- tqtinterface/qt4/tools/qvfb/pda.skin | 2 +- tqtinterface/qt4/tools/qvfb/qvfb.cpp | 2 +- tqtinterface/qt4/tools/qvfb/qvfbview.cpp | 2 +- 103 files changed, 15729 insertions(+), 1292 deletions(-) create mode 100644 tqtinterface/qt4/ChangeLog.immodule create mode 100644 tqtinterface/qt4/README.immodule create mode 100644 tqtinterface/qt4/changes.immodule create mode 100644 tqtinterface/qt4/make-symlinks.sh create mode 100644 tqtinterface/qt4/mkspecs/linux-g++-sparc/qmake.conf create mode 100644 tqtinterface/qt4/mkspecs/linux-g++-sparc/qplatformdefs.h create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/imsw-multi.pro create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.cpp create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.h create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.cpp create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.h create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/imsw-none/imsw-none.pro create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.cpp create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.h create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/inputmethods.pro create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/simple/composetable.cpp create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/simple/simple.pro create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontext.h create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.cpp create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.h create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/simple/xcompose2q.rb create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontext.h create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontextplugin.cpp create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontextplugin.h create mode 100644 tqtinterface/qt4/plugins/src/inputmethods/xim/xim.pro create mode 100644 tqtinterface/qt4/src/__debian_export_symbols.cpp create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.cpp create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.h create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextinterface_p.h create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.cpp create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.h create mode 100644 tqtinterface/qt4/src/inputmethod/tqt_inputmethod.pri create mode 100644 tqtinterface/qt4/src/kernel/tqinputcontext.cpp create mode 100644 tqtinterface/qt4/src/kernel/tqinputcontext.h diff --git a/tqtinterface/qt4/ChangeLog.immodule b/tqtinterface/qt4/ChangeLog.immodule new file mode 100644 index 0000000..7a10a3c --- /dev/null +++ b/tqtinterface/qt4/ChangeLog.immodule @@ -0,0 +1,2027 @@ +2004-09-10 YamaKen + + * changes.immodule + - Describe a bugfix + +2004-09-10 YamaKen + + * src/inputmethod/tqinputcontextinterface_p.h + - Update UUID of TQInputContextFactory in accordance with API change + of TQInputContext to avoid loading old invalid plugins + +2004-09-10 YamaKen + + * README.immodule + - Add 'About this release' section + - Update version information + - Update to follow the change of configure options + - Modify some English expressions + + * changes.immodule + - Move release information to README.immodule + - Add differences from previous release + - Add description about incremental change indication + + * ChangeLog.immodule + - Update + +2004-09-09 YamaKen + + * src/kernel/tqapplication.cpp + - (removePostedEvents): + * Fix infinite loop condition + * delete receiver->postedEvents if the list has been empty + +2004-09-09 YamaKen + + * This commit backports some code fragments from TQt4 branch to make + input method plugins source compatible with TQt4. + + * src/kernel/tqinputcontext.cpp + - (TQInputContext): Add 'tqparent' arg + + * src/kernel/tqinputcontext.h + - Exclude qptrlist.h when compile with TQt4 + - (struct TQInputContextMenu): Exclude member variables when compile + with TQt4 + - (TQInputContext): Add 'tqparent' arg + - (addActionsTo): New function for TQt4 + +2004-09-08 YamaKen + + * This commit renames input method module from 'input' to 'inputmehod' + because the name 'input' is too generic to indicate its function + + * configure + - Replace configuration options '-im' and '-im-ext' with + '-inputmethod' and '-inputmethod-ext' to be consistent with the + name of input method module subdirectory 'inputmethod' + - Rename the module name 'input' with 'inputmethod' + + * src/qt.pro + - Rename the module name 'input' with 'inputmethod' + - Rename some variable names inaccordance with the renaming of the + module + - Replace 'qt_input.pri' with 'qt_inputmethod.pri' in accordance + with the renaming of the file + + * src/inputmethod/tqt_input.pri + - Rename to qt_inputmethod.pri + * src/inputmethod/tqt_input.pri + - Renamed from qt_input.pri + - Replace module names + - Rename some variable names inaccordance with the renaming of the + module + +2004-09-08 YamaKen + + * Rename input module subdirectory from "input" to "inputmethod" + +2004-09-08 YamaKen + + * This commit contains following issues + - An API change. Return type of TQInputContext::identifierName and + TQInputContext::language has been changed from TQCString which is + deprecated in TQt4 to TQString to make plugins source compatible + with TQt4. + - Other backports from TQt4 branch + - Fix event receiving order inversion between TQKeyEvent and + TQIMEvent. The code is implemented based on Cougar's and + Kazuki's. Thank you the efforts. See following discussion for + further information. + http://freedesktop.org/pipermail/immodule-qt/2004-September/000447.html + http://freedesktop.org/pipermail/immodule-qt/2004-September/000497.html + + * src/kernel/tqinputcontext.h + - (identifierName, language): Change return type from TQCString to TQString + - (addMenusTo): Make TQt3 specific + * src/kernel/tqinputcontext.cpp + - (identifierName): + * Change return type from TQCString to TQString + * Modify the function description comment + - (language): Change return type from TQCString to TQString + + * src/kernel/tqwidget.cpp + - (clearFocus): Enclose immodule specific code by #if + defined(TQ_WS_X11) + + * src/kernel/tqapplication.h + - Add 'class TQIMEvent' declaration + - (removePostedEvents): New overriding function + * src/kernel/tqapplication_x11.cpp + - Remove redundant 'class TQInputContext' declaration + - (postIMEvent): Fix the event receiving order inversion problem + - (x11_apply_settings): Replace TQString::tqfind() which is deprecated + in TQt4 with TQString::startsWith() + - (postEvent): Fix invalid TQIMEvent compression that ignores IMStart + boundary + - (removePostedEvents): Original version of the function. Replace + the implementation with 2-args version. The behavior is not + changed + - (removePostedEvents): New overriding function. This function only + removes events that has specified event type. The implementation + is copied from original version of the function and modified to + accept event_type. This function is required by postIMEvent() + - (setActiveWindow): Enclose immodule specific code by #if + defined(TQ_WS_X11) + + * src/input/tqinputcontextinterface_p.h + - Modify a coding style to follow Trolltech's one for TQt3 + + * src/input/tqinputcontextplugin.h + - Fix typos in comment + * src/input/tqinputcontextplugin.cpp + - (keys, TQInputContextPlugin, ~TQInputContextPlugin): Modify the + function description comment + + * src/input/tqinputcontextfactory.h + - Remove #include "tqinputcontext.h" to reduce compilation dependency + - Add 'class TQWidget' declaration + - Remove inappropriate #ifndef TQT_NO_STRINGLIST. TQStringList is now + required feature for immodule. See also changes of qfeatures.h + * src/input/tqinputcontextfactory.cpp + - Add #include "tqinputcontext.h" + - Remove unnecessary #include "tqpopupmenu.h" + - Remove inappropriate #ifndef TQT_NO_STRINGLIST. TQStringList is now + required feature for immodule. See also changes of qfeatures.h + + * src/tools/tqfeatures.h + - Define TQT_NO_IM if TQT_NO_STRINGLIST is defined + - Define TQT_NO_IM_EXTENSIONS if TQT_NO_IM or TQT_NO_STRINGLIST is + defined + + * plugins/src/inputmethods/inputmethods.pro + - Rename conditional configuration symbol from "im" to "inputmethod" + inaccordance with chanege of configure script + + * plugins/src/inputmethods/simple/tqsimpleinputcontext.h + * plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp + * plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.h + - (identifierName, language): Change return type from TQCString to + TQString + + * plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.cpp + - (identifierName, language): Change return type from TQCString to + TQString + - (createImSelPopup): Replace TQString::tqfind() which is deprecated in + TQt4 with TQString::startsWith() + + * plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.cpp + - (create): Replace TQString::tqfind() which is deprecated in TQt4 with + TQString::startsWith() + + * plugins/src/inputmethods/xim/tqximinputcontext.h + - (language): Change return type from TQCString to TQString + - (identifierName): + * Change return type from TQCString to TQString + * Move inline implementation to qximinputcontext_x11.cpp + * plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp + - (language): Change return type from TQCString to TQString + - (identifierName): + * Change return type from TQCString to TQString + * Move implementation from qximinputcontext.h + - (language): Replace TQString::tqfind() which is deprecated in TQt4 with + TQString::startsWith() + +2004-08-19 YamaKen + + * src/input/tqinputcontextfactory.cpp + - (keys): Modify the function description comment + +2004-08-18 YamaKen + + * src/input/tqinputcontextfactory.cpp + - (create_manager): Fix plugin directory from "/input" to "/inputmethods" + +2004-08-18 YamaKen + + * src/kernel/tqapplication_x11.cpp + - (KeyTbl): Add translations for Japanese and Korean alias keys + +2004-08-18 YamaKen + + * This commit disables default IM configuration feature using qtrc and + qtconfig in BC mode. See following discussion for further + information. + http://freedesktop.org/pipermail/immodule-qt/2004-August/000416.html + + * src/kernel/tqapplication_x11.cpp + - (x11_apply_settings): + * Move immodule handling into #ifndef TQT_NO_IM rather than TQT_NO_XIM + * Move qtrc handling into #ifndef TQT_NO_IM_EXTENSIONS + + * src/inputmethods/imsw-multi/tqmultiinputcontext.cpp + - (TQMultiInputContext): Move qtrc handling into #ifndef + TQT_NO_IM_EXTENSIONS + + * tools/qtconfig/mainwindow.cpp + - (MainWindow): Move qtrc handling into #ifndef TQT_NO_IM_EXTENSIONS + + * src/kernel/tqt_x11.pri + - Remove unnecessary configuration + +2004-08-18 YamaKen + + Merge differences between qt-x11-free-3.3.2 and qt-x11-free-3.3.3 + +2004-08-18 YamaKen + + * plugins/src/inputmethods/imsw-multi/imsw-multi.pro + * plugins/src/inputmethods/simple/simple.pro + * plugins/src/inputmethods/imsw-none/imsw-none.pro + * plugins/src/inputmethods/xim/xim.pro + - Remove inappropriate 'thread' from CONFIG. Thanks to Takumi + Asaki for reporting + +2004-08-18 YamaKen + + * tools/qtconfig/mainwindow.cpp + - (MainWindow): Modify a comment + - (fileSave): Fix inappropriate /qt/DefaultInputMethodSwitcher + overwriting. Thanks Takumi Asaki for the reporting + +2004-08-17 YamaKen + + * plugins/src/inputmethods/imsw-multi/imsw-multi.pro + * plugins/src/inputmethods/simple/simple.pro + * plugins/src/inputmethods/imsw-none/imsw-none.pro + * plugins/src/inputmethods/xim/xim.pro + - Change plugin directory from $TQTDIR/plugins/input/ to + $TQTDIR/plugins/inputmethods/ + * changes.immodule + - Add a description for the change of plugin directory + +2004-08-17 YamaKen + + * src/kernel/tqnamespace.h + - (TQt::Key) Add a comment about Korean-specific keyboard + support based on the information from Choe Hwanjin. Thanks + for the information. See following discussion for further + information + http://freedesktop.org/pipermail/immodule-qt/2004-August/000402.html + - (TQt::Key) Comment out some Korean-specific keys that has an + equivalent generic key + +2004-08-14 YamaKen + + * This is preparation for qt-x11-immodule-unified-qt3.3.2-20040814 + + * ChangeLog.immodule + - Update + +2004-08-14 YamaKen + + * changes.immodule + - Add and modify some descriptions + + * configure + - Rewrite some codes to avoid patch rejection against TQt + 3.3.3. Logically equivalent. + * src/widgets/tqtextedit.cpp + - Rewrite some codes to avoid patch rejection against TQt + 3.3.3. Logically equivalent. + * src/widgets/tqlineedit.cpp + - Rewrite some codes to avoid patch rejection against TQt + 3.3.3. Logically equivalent. + +2004-08-13 LiuCougar + + cleanup: get rid of some warnings +2004-08-12 YamaKen + + * changes.immodule + - New file. This file has been written for both users and + developers to inform important changes + +2004-08-12 YamaKen + + * This is preparation for qt-x11-immodule-unified-qt3.3.2-20040812 + + * ChangeLog.immodule + - Update + +2004-08-12 YamaKen + + * src/kernel/tqwidget_x11.cpp + - (changeInputContext, createInputContext): Fix qic location + - (destroyInputContext): Add safety check + +2004-08-12 YamaKen + + * configure + - Fix incomplete qconfig configuratoin about TQT_NO_IM and + TQT_NO_IM_EXTENSIONS + + * src/kernel/tqwidget_x11.cpp + - (changeInputContext, createInputContext, destroyInputContext): Fix + invalid pointer reference + +2004-08-12 LiuCougar + + fixed a compile issue in my gentoo box (gcc 3.3.3, glibc 2.3.3 +2004-08-12 YamaKen + + * configure + - Fix option consistency handling between '-im' and '-im-ext' + + * README.immodule + - Fix a typo + +2004-08-11 YamaKen + + * README.immodule + - Modify a little + +2004-08-11 YamaKen + + * README.immodule + - New file. Some explanation has been described + + * ChangeLog.immodule + - New file + +2004-08-11 YamaKen + + * plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp + - (language): Remove TQLocale dependency to be compiled on TQt 3.2.x + or earlier + +2004-08-11 YamaKen + + * This commit merges 'Binary Compatible branch' into the trunk to + reduce maintenance cost. Now binary compatibility is + configurable. Binary incompatible features are surrounded by + #ifndef TQT_NO_IM_EXTENSIONS + + * configure + - Add '-im' option to enable immodule feature (default yes). + - Add '-im-ext' option to enable more immodule extensions (default + no). Specify this option 'no' to keep binary compatibility with + standard TQt3 + + * src/kernel/tqt_x11.pri + - Add conditional TQT_NO_IM and TQT_NO_IM_EXTENSIONS definition in + accordance with '-im' and '-im-ext' options + + * src/kernel/tqwidget.h + - (icHolderWidget): New function for TQT_NO_IM_EXTENSIONS + - (ic): Add #ifndef TQT_NO_IM_EXTENSIONS for binary incompatible + variable + - (xic): Add #ifdef TQT_NO_IM_EXTENSIONS for binary compatible + variable + * src/kernel/tqwidget_x11.cpp + - (create): Add #ifndef TQT_NO_IM_EXTENSIONS + - (destroy): Make some codes TQT_NO_IM_EXTENSIONS independent + - (createTLSysExtra): Add a code fragment for TQT_NO_IM_EXTENSIONS + - (deleteTLSysExtra): Modify a comment + - (getInputContext, changeInputContext, createInputContext, + destroyInputContext): Merge code fragments for TQT_NO_IM_EXTENSIONS + - (deleteExtra): Merge a comment for TQT_NO_IM_EXTENSIONS + + * src/kernel/tqapplication.h + - (locateICHolderWidget, icHolderWidgets, create_xim, close_xim): + New functions for TQT_NO_IM_EXTENSIONS + * src/kernel/tqapplication_x11.cpp + - (create_im, close_im): Add #ifndef TQT_NO_IM_EXTENSIONS + - (create_xim, close_xim): Merge functions for TQT_NO_IM_EXTENSIONS + - (qt_init_internal, qt_cleanup): Merge code fragments for + TQT_NO_IM_EXTENSIONS + + * plugins/src/inputmethods/inputmethods.pro + - Make plugin compilations configurable with '-im' option + +2004-08-11 YamaKen + + * plugins/src/inputmethods/xim/tqximinputcontext.h + - Replace TQXIMINPUTCONTEXT_P_H with TQXIMINPUTCONTEXT_H + + * src/widgets/tqlineedit.cpp + - (TQLineEditPrivate::updateMicroFocusHint): Modify the comment a + little + +2004-08-11 YamaKen + + * This commit is participating with recent 'keyword static of C++' + discussion. See + http://freedesktop.org/pipermail/immodule-qt/2004-August/000344.html + for further information + + * src/kernel/tqapplication_x11.cpp + - (TQETWidget::translateKeyEventInternal): Prevent interwidget key + state transition about RTL extensions. This code had been written + by Daisuke Kameda in qt-x11-immodule-all-qt3.3.1-20040316.diff + + * src/widgets/tqlineedit.cpp + - (TQLineEditPrivate::updateMicroFocusHint): Add a comment that + explains that old rect variable is intentionally static + +2004-08-11 YamaKen + + * This commit turns the argument of TQInputContext::filterEvent() into + const. See + http://freedesktop.org/pipermail/immodule-qt/2004-August/000335.html + for further information + + * src/kernel/tqinputcontext.h + - (filterEvent): Follow the API change + * src/kernel/tqinputcontext.cpp + - (filterEvent): Follow the API change + + * plugins/src/inputmethods/simple/tqsimpleinputcontext.h + - (filterEvent): Follow the API change + * plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp + - (filterEvent): Follow the API change + * plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.h + - (filterEvent): Follow the API change + * plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.cpp + - (filterEvent): Follow the API change + +2004-08-10 YamaKen + + * plugins/src/inputmethods/simple/xcompose2q.rb + - Update to accept Compose flie of X.org's X11R6.7.0 + - Accept 'XCOMM' as comment sign to accept raw source file + - Accept both " " and "\"" as valid RHS + * plugins/src/inputmethods/simple/composetable.cpp + - Update Compose table from XFree86 4.3.0 to X.org's X11R6.7.0 + +2004-08-10 YamaKen + + * This commit replaces the invalid header words 'This file is + part of the kernel module' of following files with 'This file + is part of the input method module' + + * plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.cpp + * plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.cpp + * plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.h + * plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.h + * plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.cpp + * plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp + * plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.h + * plugins/src/inputmethods/simple/tqsimpleinputcontext.h + * plugins/src/inputmethods/simple/composetable.cpp + * plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.cpp + * plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.h + * plugins/src/inputmethods/xim/tqximinputcontextplugin.cpp + * plugins/src/inputmethods/xim/tqximinputcontextplugin.h + * plugins/src/inputmethods/xim/tqximinputcontext.h + * plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp + +2004-08-10 YamaKen + + * plugins/src/inputmethods/simple/xcompose2q.rb + - Fix broken translation entries for most ASCII characters + * plugins/src/inputmethods/simple/composetable.cpp + - Translate again with fixed xcompose2q.rb. This fixes many + translation entries involving ascii character such as + " " + +2004-08-10 YamaKen + + * plugins/src/inputmethods/simple/xcompose2q.rb + - New file. This script is used for translating X's Compose + table into TQSimpleInputContext's table + - Some bugs included + - Although I had released previous versions of this script + under GPL, I have released this version under another + license. See header + +2004-08-10 YamaKen + + * plugins/src/inputmethods/simple/tqsimpleinputcontext.h + - Follow Trolltech's coding style for TQt3 + - Remove unnecessary headers + - (UNITIZE): Moved from qsimpleinputcontext.cpp. TQT_ prefix is not + required since a macro does not pollute symbol space + - (struct _ComposeTableElement): Rename to TQComposeTableElement + - (struct TQComposeTableElement): Renamed from _ComposeTableElement + - (struct _ComposeTable): Rename to TQComposeTable + - (struct TQComposeTable): Renamed from _ComposeTable + - (isPreeditRelocationEnabled): Remove unnecessary overloading + function + - (isPreeditPreservationEnabled): Remove unnecessary function + - (checkComposeTable): Follow the renaming of the types of args + - (defaultComposeTable): New static member variable + + * plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp + - Separate composing table definition to composetable.cpp + - Remove unnecessary headers + - Replace 'true' and 'false' with 'TRUE' and 'FALSE' to follow + Trolltech's coding style for TQt3 + - Replace _ComposeTableElement with TQComposeTableElement to follow + the renaming + - Replace ComposeTable with TQComposeTable to follow the renaming + - (UNITIZE): Move to qsimpleinputcontext.h + - (defaultTable): Move to composetable.cpp + - (qtComposeTable): Move to composetable.cpp as defaultComposeTable + - (filterEvent): + * Clean up + * Add a comment about key compression + * replace qtComposeTable with defaultComposeTable to follow the + renaming + - (unsetFocus): Remove unnecessary isPreeditPreservationEnabled() + check + - (identifierName): Remove 'FIXME' comment + - (isPreeditRelocationEnabled): Remove unnecessary overloading + function + - (isPreeditPreservationEnabled): Remove unnecessary function + + * plugins/src/inputmethods/simple/composetable.cpp + - New file. This file has been separated from + qsimpleinputcontext.cpp to achieve following issues + * increase table maintenance ability + * ease editing code part of TQSimpleInputContext + * ease development log tracking + * ease copyright tracking + * enclose UTF-8 comments into this file only + - Add original header from Compose file of XFree86 4.3.0 + - (defaultTable) Moved from qsimpleinputcontext.cpp + - (defaultComposeTable): New variable definition + + * plugins/src/inputmethods/simple/simple.pro + - Add composetable.cpp to SOURCES + + * plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.cpp + - (displayName, description): Modify the descriptions appropriately + +2004-08-10 YamaKen + + * plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp + - Replace #include "tqximinputcontext_p.h" with + "tqximinputcontext.h". XIM plugin is now working properly + +2004-08-10 YamaKen + + * This commit changes the XIM input method into plugin. A little + modification is still required to work. See next commit information + + * src/input/tqinputcontextfactory.cpp + - Remove XIM dependency + - (create, keys): Remove XIM dependent codes + + * src/input/tqt_input.pri + - Remove TQXIMInputContext entries + * src/input/tqximinputcontext_p.h + - Moved to plugins/src/inputmethods/xim/tqximinputcontext.h + * src/input/tqximinputcontext_x11.cpp + - Moved to plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp + + * plugins/src/inputmethods/inputmethods.pro + - Add xim to SUBDIRS + * plugins/src/inputmethods/xim + - New directory + * plugins/src/inputmethods/xim/xim.pro + - New file + * plugins/src/inputmethods/xim/tqximinputcontextplugin.h + - New file + - (class TQXIMInputContextPlugin): New class + - (TQXIMInputContextPlugin, ~TQXIMInputContextPlugin, keys, create, + languages, displayName, description): New function + * plugins/src/inputmethods/xim/tqximinputcontextplugin.cpp + - New file + * plugins/src/inputmethods/xim/tqximinputcontext.h + - Moved from src/input/tqximinputcontext_p.h. No code changes have + been applied. A little modification is required to work. See next + commit information + * plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp + - Moved from src/input/tqximinputcontext_x11.cpp. No code changes have + been applied + +2004-08-10 YamaKen + + * src/input/tqximinputcontext_p.h + - (TQXIMInputContext): Remove the arg 'widget' to conform to standard + TQInputContext API + * src/input/tqximinputcontext_x11.cpp + - (TQXIMInputContext): Remove the arg 'widget' to conform to standard + TQInputContext API + - (setHolderWidget): Add TQInputContext::setHolderWidget() to fix + inproper overriding + * src/input/tqinputcontextfactory.cpp + - (create): Remove the arg from TQXIMInputContext() + +2004-08-10 YamaKen + + * src/input/tqximinputcontext_p.h + - (setHolderWidget): New override function + * src/input/tqximinputcontext_x11.cpp + - (TQXIMInputContext): Split most part of the initialization code + into setHolderWidget() to allow null widget. This is required to + make imsw-none working properly + - (setHolderWidget): New function + +2004-08-10 YamaKen + + * src/kernel/tqapplication_x11.cpp + - (x11_apply_settings): Restrict defaultIM to be an IM-switcher. An + IM-switcher has a 'imsw-' prefix + +2004-08-10 YamaKen + + * This commit adds imsw-none IM-switcher plugin according to + following discussion with Takumi Asaki. Thanks for the opinion. + http://freedesktop.org/pipermail/immodule-qt/2004-August/000320.html + + * plugins/src/inputmethods/inputmethods.pro + - Add imsw-none to SUBDIRS + * plugins/src/inputmethods/imsw-none/imsw-none.pro + - New file + * plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.h + - New file + - (class TQNoneInputContextPlugin): New class + * plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.cpp + - New file + - (TQNoneInputContextPlugin, ~TQNoneInputContextPlugin, keys, + languages, displayName, description): New function + - (create): New function. Read key from TQT_IM_MODULE or + /qt/DefaultInputMethod of qtrc and creates input context with the + key + +2004-08-10 YamaKen + + * Rename input method plugin names to accord with other plugin names + + * plugins/src/inputmethods/imsw-multi/imsw-multi.pro + - Rename plugin name to qimsw-multi from qmultiinputcontextplugin + * plugins/src/inputmethods/simple/simple.pro + - Rename plugin name to qsimple from qsimpleinputcontextplugin + +2004-08-10 YamaKen + + * plugins/src/inputmethods/imsw-multi/multi.pro + - Move to imsw-multi.pro + * plugins/src/inputmethods/imsw-multi/imsw-multi.pro + - Move from multi.pro + +2004-08-10 YamaKen + + * plugins/src/inputmethods/multi + - Move to imsw-multi + * plugins/src/inputmethods/imsw-multi + - Move from multi + * plugins/src/inputmethods/inputmethods.pro + - Replace 'multi' with 'imsw-multi' in SUBDIRS + +2004-08-10 Kazuki Ohta + + * plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp + - add full dead/multi key entries + - fix some bugs + +2004-08-10 YamaKen + + * This commit changes pluggable popup menu API in accordance with + following discussion with Lars Knoll. Thanks for the advice. + http://freedesktop.org/pipermail/immodule-qt/2004-August/000300.html + + * src/kernel/tqinputcontext.cpp + - (actions): New function + - (exportMenusInto): Remove to rename to addMenusTo() + - (addMenusTo): + * New function. Renamed from exportMenusInto() + * Follow introduction of enum TQInputContextMenu::Action + * Add an explanation for this utility function to the function + description + + * src/kernel/tqinputcontext.h + - (TQInputContextMenu::Action): New enum + - (menus): Restrict to use with TQt3 only + - (qt4menus): Remove to replace with actions() + - (actions): New function for TQt4 + + * src/widgets/tqtextedit.cpp + - (createPopupMenu): Replace exportMenusInto() with addMenusTo() + * src/widgets/tqlineedit.cpp + - (createPopupMenu): Replace exportMenusInto() with addMenusTo() + +2004-08-10 YamaKen + + * This commit changes the two input methods into plugin + + * src/input/tqt_input.pri + - Remove TQSimpleInputContext and TQMultiInputContext entries + * src/input/tqmultiinputcontext.h + - Moved to plugins/src/inputmethods/multi/tqmultiinputcontext.h + * src/input/tqmultiinputcontext.cpp + - Moved to plugins/src/inputmethods/multi/tqmultiinputcontext.cpp + * src/input/tqsimpleinputcontext.h + - Moved to plugins/src/inputmethods/simple/tqsimpleinputcontext.h + * src/input/tqsimpleinputcontext.cpp + - Moved to plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp + + * plugins/src/src.pro + - Add 'inputmethods' to SUBDIRS. The directory name 'inputmethods' + is intended to be compatible with TQt/Embedded. Install directory + name is still kept as 'input' for backward compatibility + * plugins/src/inputmethods/inputmethods.pro + - New file + + * plugins/src/inputmethods/multi/multi.pro + - New file + * plugins/src/inputmethods/multi/tqmultiinputcontextplugin.h + - New file + * plugins/src/inputmethods/multi/tqmultiinputcontextplugin.cpp + - New file + * plugins/src/inputmethods/multi/tqmultiinputcontext.h + - Moved from src/input/tqmultiinputcontext.h. No code changes have + been applied + * plugins/src/inputmethods/multi/tqmultiinputcontext.cpp + - Moved from src/input/tqmultiinputcontext.cpp. No code changes have + been applied + + * plugins/src/inputmethods/simple/simple.pro + - New file + * plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.h + - New file + * plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.cpp + - New file + * plugins/src/inputmethods/simple/tqsimpleinputcontext.h + - Moved from src/input/tqsimpleinputcontext.h. No code changes have + been applied + * plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp + - Moved from src/input/tqsimpleinputcontext.cpp. No code changes have + been applied + + * src/input/tqinputcontextfactory.cpp + - (create): Remove dedicated instantiation handling for + TQSimpleInputContext and TQMultiInputContext + + * tools/qtconfig/mainwindow.h + - (inputMethodIdentifiers): New member variable + * tools/qtconfig/mainwindow.cpp + - (MainWindow): + * Replace identifier name of input methods with displaynames + * Add filtering out process for IM-switchers that has "imsw-" + prefix + * Disable sorting for input method names + * Modify some comments + * Simplify setCurrentItem() handling for inputMethodCombo widget + * Add recorded input method name to the display name of unknown + input method + * Save recorded input method name even if unknown input method + - (fileSave): + * Save /qt/DefaultInputMethodSwitcher with default value + "imsw-multi" + * Save identifier name of the input method rather than display name + + * src/kernel/tqinputcontext.cpp + - (class TQInputContext): Update the class description comment + + * src/input/tqinputcontextplugin.cpp + - (class TQInputContextPlugin): Update the class description comment + - (keys): Update the function description comment + - (languages, displayName, description): Add the function + description comment + + +2004-08-05 YamaKen + + * This commit adds generic pluggable popup menu feature. See + http://freedesktop.org/pipermail/immodule-qt/2004-August/000266.html + for further information. The implementation may be altered in + accordance with discussion in the list. + + * src/kernel/tqinputcontext.h + - (struct TQInputContextMenu): New struct + - (qt4menus): New function. Just a placeholder for now + - (menus): New function + - (exportMenusInto): New function + * src/kernel/tqinputcontext.cpp + - (class TQInputContext): Add 'Text widget implementor's guide' + section to the class description comment + - (menus): New function + - (exportMenusInto): New function + + * src/input/tqmultiinputcontext.h + - (qt4menus): New function. Just a placeholder for now + - (menus): New function + * src/input/tqmultiinputcontext.cpp + - (menus): + * New function to follow new API. The function merges slave menus + and TQMultiInputContext's own 'Select Input Method' menu + * The functionality is ported from TQLineEdit::createPopupMenu() + * An accelerator has been added as 'Select Input &Method' + + * src/widgets/tqtextedit.cpp + - Remove TQMultiInputContext dependency + - (createPopupMenu): Replace TQMultiInputContext dependent submenu + handling with the pluggable popup menu + * src/widgets/tqlineedit.cpp + - Remove TQMultiInputContext dependency + - (createPopupMenu): Replace TQMultiInputContext dependent submenu + handling with the pluggable popup menu + + * src/kernel/tqwidget.h + - Remove #include "tqinputcontext.h" to reduce compile time when we + hacked qinputcontext.h + +2004-08-04 Kazuki Ohta + + * src/input/tqmultiinputcontext.cpp + - use TQInputContextFactory::description and set whatsthis help + +2004-08-03 YamaKen + + * This commit adds TQInputContextFactory::description() feature + + * src/input/tqinputcontextinterface_p.h + - Update the UUID because the interface has been changed + - (description): New function + + * src/input/tqinputcontextplugin.h + - (description): New function + + * src/input/tqinputcontextfactory.h + - (description): New function + - (TQInputContextPluginPrivate::description): New function + * src/input/tqinputcontextfactory.cpp + - (description): New function + - (displayName): Replace fallback value with empty string instead of + null + +2004-08-03 YamaKen + + * This commit alters the configuration convention about + IM-switcher. See + http://freedesktop.org/pipermail/immodule-qt/2004-August/000232.html + for further information. The implementation may be altered in + accordance with discussion in the list. + + * src/kernel/tqapplication_x11.cpp + - (defaultIM): Replace "xim" with "imsw-multi" + - (x11_apply_settings): + * Replace the environment variable name TQT_IM_MODULE with + TQT_IM_SWITCHER + * Replace the qtrc variable name /qt/DefaultInputMethod with + /qt/DefaultInputMethodSwitcher + * Replace "xim" with "imsw-multi" for default plugin + + * src/input/tqmultiinputcontext.h + - (lastCreatedIMKey): Remove to rename to currentIMKey + - (currentIMKey): New member variable. Renamed from lastCreatedIMKey + because the semantics of the variable has been changed by + introduction of TQT_IM_SWITCHER + + * src/input/tqmultiinputcontext.cpp + - Replace lastCreatedIMKey with currentIMKey + - (TQMultiInputContext): Add default input method specification + feature using TQT_IM_MODULE and /qt/DefaultInputMethod + - (createImSelPopup): + * Add IM-switcher plugin elimination feature using "imsw-" prefix + * Add dispName.isNull() checking + * Apply some rewriting without altering logic for human readability + + * src/input/tqinputcontextfactory.cpp + - (create): Replace the identifier name "multi" with "imsw-multi" + +2004-08-03 Kazuki Ohta + + * This commit implements table searching suite + + - TQKeyEvent::text() is restricted to only one character, + so qsimpleic use TQChar::tqunicode() value in case keys are + pressed otherwise composing keys are pressed. + + - Composing Table is temporally deleted for testing. + Need to prepare proper entries. + Now qsimpleic can deal with capital letter more cleaner way + + * Next, I introduce X's composing parser to qsimpleic + +2004-08-02 YamaKen + + * src/kernel/tqapplication_x11.cpp + - (x11_apply_settings): Merge the comment about defaultIM + overwritten by r52 from r45 + +2004-07-31 LiuCougar + + new environment variable TQT_IM_MODULE to overwrite the default inputmethod plugin +2004-07-31 LiuCougar + + "deleteLater" is safer then "delete" TQObject directly +2004-07-30 YamaKen + + * src/kernel/tqnamespace.h + - (TQt::Key): + * Replace dead key values with new one to avoid keycode conflict + * Add a comment about the latin 1 keycodes + * Add some comments about the offset for keycode from X keycode + * src/kernel/tqevent.cpp + - (key): Add a comment about latin 1 keycodes to the function + description. + + * src/kernel/tqapplication_x11.cpp + - Define define XK_XKB_KEYS to include dead key definitions from + keysymdef.h + - Remove XK_dead_ keys definition + +2004-07-29 Kazuki Ohta + + * Change to use displayName() in IM-Switch Popupmenu + + * src/input/tqmultiinputcontext.h + - (keyDict): new variable + * src/input/tqmultiinputcontext.cpp + - (createImSelPopup): use displanName() on popup and store key in keyDict + - (changeInputMethodWithMenuId): find key from using keyDict + + * Problem * + - if key=="XIM", displayName(key) is TQString() + * Wish * + - add "virtual TQString description( const TQString &key ) = 0;" for showing the description of IM on PopupMenu as a whatsthis help + +2004-07-28 YamaKen + + * src/input/tqinputcontextinterface_p.h + - Update the UUID because the interface has been changed + - (languages): New function + - (displayName): New function + + * src/input/tqinputcontextplugin.h + - (languages): New function + - (displayName): New function + * src/input/tqinputcontextplugin.cpp + - (TQInputContextPluginPrivate::languages): New function + - (TQInputContextPluginPrivate::displayName): New function + + * src/input/tqinputcontextfactory.h + - (languages): New function + - (displayName): New function + * src/input/tqinputcontextfactory.cpp + - (languages): New function + - (displayName): New function + +2004-07-27 YamaKen + + * src/kernel/tqinputcontext.h + - (deletionRequested): New signal. Added for fatal error handling + * src/kernel/tqinputcontext.cpp + - (deletionRequested): Add the function description comment + * src/kernel/tqwidget.h + - (destroyInputContext): Change ordinary function to slot to receive + the signal TQInputContext::deletionRequested() + * src/kernel/tqwidget_x11.cpp + - (changeInputContext, createInputContext): + * Connect deletionRequested() signal of qic to destroyInputContext() + * Follow renaming of TQApplication::imEventReceived() to postIMEvent() + - (destroyInputContext): Modify the function description comment + + * src/input/tqximinputcontext_p.h + - (close): New function + * src/input/tqximinputcontext_x11.cpp + - (close_xim): + * Remove invalid TQApplication::close_im() invocation + * Add proper finalization using deletionRequested() signal + - (close): New function + + * src/kernel/tqapplication.h + - (imEventReceived): Remove this inappropriate name to rename to + postIMEvent() + - (postIMEvent): New slot. Renamed from imEventReceived() + * src/kernel/tqapplication_x11.cpp + - (imEventReceived): Remove this inappropriate name to rename to + postIMEvent() + - (postIMEvent): New slot. Renamed from imEventReceived() + - (close_im): Remove unused commented out code. The code had already + been moved to qximinputcontext.cpp + + * src/input/tqmultiinputcontext.h + - (destroyInputContext): New slot + - (imEventReceived): Remove this inappropriate name to rename to + postIMEvent() + - (postIMEvent): New slot. Renamed from imEventReceived() + * src/input/tqmultiinputcontext.cpp + - (TQT_NO_IM_TQMULTIINPUTCONTEXT_IMINDEX): New macro. Defined as default + - (filterEvent): Insert #ifdef TQT_NO_IM_TQMULTIINPUTCONTEXT_IMINDEX + - (destroyInputContext): New slot. Processes deletionRequested from slave + - (imEventReceived): Remove this inappropriate name to rename to + postIMEvent() + - (postIMEvent): New slot. Renamed from imEventReceived() + - (slave): + * Add proper instanciation code for popup menu mode + * Insert #ifdef TQT_NO_IM_TQMULTIINPUTCONTEXT_IMINDEX + - (changeInputMethod(int)): + * Add error handling for no available input methods + * Insert #ifdef TQT_NO_IM_TQMULTIINPUTCONTEXT_IMINDEX + - (changeInputMethod(TQString)): + * Add error handling for no available input methods + * Add default selection for null key + * Connect deletionRequested() signal + * Fix debug message + * src/widgets/tqtextedit.cpp + - (createPopupMenu): + * Add NULL check for input context + * Replace the label "SelectInputMethod" with "Select Input Method" + * src/widgets/tqlineedit.cpp + - (createPopupMenu): + * Add NULL check for input context + * Replace the label "SelectInputMethod" with "Select Input Method" + +2004-07-27 YamaKen + + * src/kernel/tqwidget_x11.cpp + - (changeInputContext): + * Remove unnecessary createInputContext() + * Reorder the code fragments to reduce temporal memory consumption + +2004-07-27 YamaKen + + * This commit is a comment and variable name update. No actual code is + modified. + + * src/kernel/tqinputcontext.cpp + - (class TQInputContext): Modify the class description comment + - (filterEvent): Mark the argument as /* const */ to make it const + in future + - (reset): Add a requirement to the function description comment for + reimplementation + + * src/kernel/tqapplication_x11.cpp + - (locateICHolderWidget, icHolderWidgets, changeAllInputContext): + Modify the function description comment + + * src/kernel/tqwidget_x11.cpp + - (changeInputContext): + * Rename 'name' with 'identifierName' to eliminate the ambiguity + * Modify the function description comment + * Modify a comment + * Follow Trolltech's coding style + - (createInputContext): + * Modify the function description comment + * Modify a comment + - (resetInputContext): Modify the function description comment + + * src/kernel/tqapplication_x11.cpp + - (defaultIM): Modify the comment + - (changeAllInputContext): + * Rename 'name' with 'identifierName' to eliminate the ambiguity + * Follow Trolltech's coding style + - (defaultInputMethod): Modify the function description comment + - (x11_apply_settings): Modify a comment + + * src/input/tqinputcontextplugin.cpp + - (class TQInputContextPlugin): Modify the class description comment + - (create): Modify the function description comment + + * src/input/tqinputcontextfactory.cpp + - (create): Modify the function description comment + +2004-07-24 YamaKen + + * src/kernel/tqinputcontext.cpp + - Add #if defined(TQ_WS_X11) around X11 platform specific + functions. these functions cannot be moved to + qinputcontext_x11.cpp at now since the TQInputContextPrivate is + defined in qinputcontext.cpp. This will be fixed in porting to + TQt4. + - (filterEvent): Add the function description comment according + with the Simplified API (filtering precedence, key compression) + + * src/kernel/tqapplication_x11.cpp + - (locateICHolderWidget, icHolderWidgets, changeAllInputContext): + Modify the function description comment + +2004-07-24 YamaKen + + * This commit is a comment update. No code is modified. + + * src/kernel/tqinputcontext.cpp + - (class TQInputContext): Add the class description comment according + with the Simplified API (preedit relocation is done, not entirely + completed yet) + +2004-07-24 YamaKen + + * This commit contains the fixes in response to Lars Knoll's + advice. Thanks for the advice. + + * src/kernel/tqapplication_x11.cpp + - (x11_apply_settings): Remove trUtf8() from "xim" to specify the + default input method + + * src/kernel/qapplication_x11.cpp, src/input/tqximinputcontext_x11.cpp + - (ximServer, xim_preferred_style, composingKeycode, input_mapper): + Add qt_ prefix to avoid symbol space pollution + - (qt_ximServer, qt_xim_preferred_style, qt_ximComposingKeycode, + qt_input_mapper): Renamed from above one + +2004-07-24 YamaKen + + * This commit is a comment update. No code is modified. + + * src/kernel/tqinputcontext.cpp + - (class TQInputContext): Modify several expressions + +2004-07-23 YamaKen + + * This commit is a comment update. No code is modified. + + * src/kernel/tqinputcontext.cpp + - (class TQInputContext): Add the class description comment according + with the Simplified API (preedit preservation is done, not + entirely completed yet) + - (TQInputContext, tqfocusWidget, setFocusWidget, isComposing, + setFocus, unsetFocus): Modify a typo in the function description + comment + +2004-07-23 YamaKen + + * src/input/tqsimpleinputcontext.cpp + - Modify the file header description + * src/input/tqmultiinputcontext.cpp + - Modify the file header description + * src/input/tqsimpleinputcontext.h + - Modify the file header description + * src/input/tqmultiinputcontext.h + - Modify the file header description + +2004-07-23 YamaKen + + * src/input/tqsimpleinputcontext.h + - Add a copyright and license header + + * src/input/tqsimpleinputcontext.cpp + - Add a copyright and license header + +2004-07-23 YamaKen + + * This commit is a comment update. No code is modified. + + * src/kernel/tqinputcontext.cpp + - (class TQInputContext): Add the class description comment according + with the Simplified API (not completed yet) + - (TQInputContext): Modify a expression in the function description + comment + - (sendIMEventInternal, font): Modify a typo in the function + description comment + +2004-07-23 Kazuki Ohta + + * src/input/tqsimpleinputcontext.cpp + - OOps. fix typo. + +2004-07-23 Kazuki Ohta + + * src/input/tqsimpleinputcontext.cpp + - follow TQt coding rule + - more valid capitalize case + +2004-07-23 Kazuki Ohta + + * src/input/tqinputcontextfactory.cpp + - enable TQSimpleInputContext by specifying in qtrc "DefaultInputMethod=simple" + +2004-07-23 Kazuki Ohta + + * This commit add simple table based InputContext for dead/multi key support + + * src/input/qsimpleinputcontext.h, src/input/tqsimpleinputcontext.cpp + - simple table based InputContext + +2004-07-22 Kazuki Ohta + + * kernel/qapplication_x11.cpp, kernel/qnamespace.h + - add dead key entries + +2004-07-22 YamaKen + + * This commit is a comment update. No code is modified. + + * src/kernel/tqinputcontext.cpp + - (holderWidget, setHolderWidget, tqfocusWidget, setFocusWidget, + releaseComposingWidget, isPreeditRelocationEnabled, isComposing, + sendIMEventInternal, sendIMEvent): Add the function description comment + according with the Simplified API + - (TQInputContext, setFocus, unsetFocus): Update the function + description comment according with the Simplified API + - (~TQInputContext, imEventGenerated): Add the function description + comment + - (reset, identifierName, language, filterEvent): Update the + function description comment + - (setMicroFocus, mouseHandler, reset, identifierName, language): + Modify a expression in the function description comment + + * src/kernel/tqwidget_x11.cpp + - (icHolderWidget, resetInputContext, focusInputContext, + unfocusInputContext, sendMouseEventToInputContext): Update the + function description comment + + * src/kernel/tqapplication_x11.cpp + - (imEventReceived): Update the function description comment + +2004-07-21 Kazuki Ohta + + * src/input/tqmultiinputcontext.h + - (createImSelPopup): new function + - (changeInputMethodWithMenuId): new slot + - (changeInputMethod(TQString)): new function + - (popup): new variable + - (lastCreatedIMKey): new variable + + * src/input/tqmultiinputcontext.cpp + - add #ifndef TQT_NO_IM + - (createImSelPopup): create TQPopupMenu object which can switch IM. + Currently selected IM is marked as checked. + + * src/input/tqinputcontextfactory.h + - remove "class TQPopupMenu" + + * src/widget/tqtextedit.cpp + - add im-switch popup to the menu which is shown when widget is right-clicked. + + * src/widget/tqlineedit.cpp + - add im-switch popup to the menu which is shown when widget is right-clicked. + +2004-07-21 YamaKen + + * src/kernel/tqinputcontext.cpp + - (filterEvent, setMicroFocus, mouseHandler): Update the function + description comment according with the Simplified API + - (reset, identifierName, language): Update the function description + comment + +2004-07-20 YamaKen + + * src/input/tqmultiinputcontext.cpp + - (changeInputMethod): Fix invalid imIndex circulation. Thanks + to Kazuki for reporting + +2004-07-20 YamaKen + + * This commit enables a flexible signal connection + configuration. Default behavior is based on Cougar's + suggestion. Thanks. + + * src/input/tqmultiinputcontext.h + - (beIndirectlyConnected): New instance variable + + * src/input/tqmultiinputcontext.cpp + - (TQMultiInputContext): Add beIndirectlyConnected to initializer list + - (imEventReceived): Add a function description comment + - (changeInputMethod): Connect imEventGenerated signal of slave + according with beIndirectlyConnected. The default behavior is + changed as directly connected to imEventGenerated signal of this + +2004-07-20 YamaKen + + * src/kernel/tqwidget_x11.cpp + - (setMicroFocusHint): Update the comment about XIM handling + - (focusInputContextunfocusInputContext, + sendMouseEventToInputContext): Add the function description comment + + * src/kernel/tqinputcontext_x11.cpp + - (x11FilterEvent): Update the function description comment + according with the Simplified API + +2004-07-20 YamaKen + + * src/input/tqmultiinputcontext.cpp + - (changeInputMethod): Fix the conversion to const char * from + identifierName() + +2004-07-20 YamaKen + + * src/input/tqximinputcontext_p.h + - (identifierName): Replace the result "XIM" with "xim" to be + consistent with corresponding immodule of GTK+ + + * src/kernel/tqapplication_x11.cpp + - (defaultIM, x11_apply_settings): Replace "XIM" with "xim" + + * src/input/tqinputcontextfactory.cpp + - (create, keys): Replace "XIM" with "xim" + + * tools/qtconfig/mainwindow.cpp + - (MainWindow): Replace "XIM" with "xim" + +2004-07-20 YamaKen + + * This commit enables TQInputContext proxying, and provide an + experimental immodule-switcher TQMultiInputContext as its + examples. The changes is following. + + 1. Use signal to deliver TQIMEvent instead of explicit + postEvent(). This enables TQIMEvent proxying and better platform + abstraction. Corresponding slot is created as + TQApplication::imEventReceived(). + + 2. Move some methods of TQInputContext to public from protected or + private. This enables that proxy-IM can access slave methods. + + 3. Make some methods of TQInputContext virtual. This enables + overriding the methods as proxy + + 4. Rename TQInputContext::name() to identifierName() to avoid + conflicting with TQObject::name() + + This patch does not break binary compatibility from vanilla TQt3. + But it costs immodule developer small modification. + + * src/kernel/tqinputcontext.h + - (class TQInputContext): Inherit TQObject and add TQ_OBJECT macro + - (name): Remove to rename to identifierName() to avoid conflicting + with TQObject::name() + - (identifierName): New function. Renamed from name() + - (isComposing, isPreeditRelocationEnabled): Move to public from + protected to allow proxying + - (setFocusWidget,setHolderWidget, releaseComposingWidget): Move to + public from private to allow proxying + - (tqfocusWidget, holderWidget): + * Make public from protected + * Make virtual to allow overriding the method as proxy + - (imEventGenerated): New signal + + * src/kernel/tqinputcontext.cpp + - (TQInputContext): Add TQObject() to initializer list + - (sendIMEventInternal): Replace TQApplication::postEvent with signal + emitting according to the change + - (name): Remove to rename to identifierName() to avoid conflicting + with TQObject::name() + - (identifierName): + * New function. Renamed from name() + * Return type has changed to TQCString from TQString to avoid using + of i18n string and confusing this with display name for endusers + + * src/kernel/tqwidget_x11.cpp + - (changeInputContext): Add TQObject::connect() to follow the change + of IMEvent flow + - (createInputContext): Add TQObject::connect() to follow the change + of IMEvent flow + + * src/kernel/tqapplication.h + - (imEventReceived): New slot + * src/kernel/tqapplication_x11.cpp + - (imEventReceived): New slot to relay TQIMEvent to event queue using + postEvent() + + * src/input/tqmultiinputcontext.h + - New file. Copyright and licensing information is temporarily + adapted to our cirmumstances + - (TQMultiInputContext): New class + - (TQMultiInputContext): New function + - (~TQMultiInputContext): New function + - (identifierName): New function + - (language): New function + - (x11FilterEvent): New function. Added based on Cougar's + advice. Thanks + - (filterEvent): New function + - (reset): New function + - (setFocus): New function + - (unsetFocus): New function + - (setMicroFocus): New function + - (mouseHandler): New function + - (font): New function + - (isComposing): New function + - (isPreeditRelocationEnabled): New function + - (tqfocusWidget): New function + - (holderWidget): New function + - (setFocusWidget): New function + - (setHolderWidget): New function + - (releaseComposingWidget): New function + - (slave): New function + - (slave): New function (const TQInputContext *slave() const) + - (changeInputMethod): New function + - (imEventReceived): New slot + * src/input/tqmultiinputcontext.cpp + - New file. Copyright and licensing information is temporarily + adapted to our cirmumstances + - (TQMultiInputContext): New function + - (~TQMultiInputContext): New function + - (identifierName): New function + - (language): New function + - (x11FilterEvent): New function. Added based on Cougar's + advice. Thanks + - (filterEvent): New function. Filters Control+Alt+Key_Down and + Control+Alt+Key_Up as IM selection keys as temporary + implementation. We should show popup menu + - (reset): New function + - (setFocus): New function + - (unsetFocus): New function + - (setMicroFocus): New function + - (mouseHandler): New function + - (font): New function + - (isComposing): New function + - (isPreeditRelocationEnabled): New function + - (tqfocusWidget): New function + - (holderWidget): New function + - (setFocusWidget): New function + - (setHolderWidget): New function + - (releaseComposingWidget): New function + - (slave): New function + - (slave): New function (const TQInputContext *slave() const) + - (changeInputMethod): New function + - (imEventReceived): New slot + * src/input/tqinputcontextfactory.cpp + - (create): Add TQMultiInputContext instanciation. Use the name + "multi" to specify it + * src/input/tqinputcontextfactory.h + - Add #include "tqinputcontext.h" to avoid compilation error + + * src/input/tqximinputcontext_p.h + - (class TQXIMInputContext): Add TQ_OBJECT macro to follow the API change + - (name): Remove to follow the API change + - (identifierName): + * New function. Renamed from name() + * Return type has changed to TQCString from TQString to follow the + API change + - (isPreeditRelocationEnabled): Move to public from protected to + follow the API change + - (isComposing): Remove unnecessary access permission breaker + because TQInputContext::isComposing() have made public + * src/input/tqximinputcontext_x11.cpp + - (isComposing): Remove unnecessary access permission breaker + because TQInputContext::isComposing() have made public + + * src/input/tqt_input.pri + - Add qmultiinputcontext.h and multiinputcontext.cpp + +2004-07-18 LiuCougar + + use virtual insert version to make subclasses work as expected (merged from bc-branch r19) +2004-07-16 Kazuki Ohta + + * src/input/tqinputcontextfactory.h: not the definition of TQInputContextPlugin + +2004-07-13 YamaKen + + * src/kernel/tqapplication_x11.cpp + - (x11ProcessEvent): Add comment for key event filtering considerations + - (TQETWidget::translateKeyEvent): Add comment for key compression + considerations + +2004-07-11 YamaKen + + * src/kernel/tqwidget.h + - (sendMouseEventToInputContext): Move into #if defined(TQ_WS_X11) + because it is not implemented in other platforms + +2004-07-11 YamaKen + + * This commit fixes a mismerge with my Simplified API patches + + * src/kernel/tqwidget_x11.cpp + - (destroyInputContext): Replace the code with original Simplified + API patch. See the comment to recognize the original intention + - (focusInputContext): Fix a condition to call qic->setFocus() as + originally written. See added comment to recognize the original + intention + + * src/kernel/tqwidget.h + - (changeInputContext): Move into #if defined(TQ_WS_X11) as + originally written because it is not implemented in other + platforms + + * src/input/tqximinputcontext_p.h + - (mouseHandler): Fix a typo as originally written + + * src/input/tqximinputcontext_x11.cpp + - Fix a comment location to express original intention + +2004-07-08 LiuCougar + + replace sendEvent with postEvent in qinputcontext to improve the process performance of IMCompose events +2004-07-08 YamaKen + + * Insert the comment 'UPDATED COMMENT RETQUIRED' into some places for future + modifications + * Modify some comments + * Replace 'InputMethod' in some comments with 'input method' + * Replace 'InputContext' in some comments with 'input context' + + * src/kernel/tqinputcontext.h + - Move description of TQInputContext to qinputcontext.cpp + * src/kernel/tqinputcontext.cpp + - Move description of TQInputContext from qinputcontext.h + +2004-07-07 Daisuke Kameda + + Adding the function which realize mapping arbitrary input context and widget: + TQApplication::locateICHolderWidget() + TQApplication::icHolderWidgets() + TQWidget::icHolderWidget() + TQWidget::getInputContext() + + Adding the function which changes input method: + TQApplication::changeAllInputContext() + TQWidget::changeInputContext() + TQApplication::defaultInputMethod() + + change TQApplication::create_xim() to TQApplication::create_im() + change TQApplication::close_xim() to TQApplication::close_im() + + +2004-07-06 Daisuke Kameda + + "TQLineEdit should only setMicroFocus if the cursorRect has changed" by cougar + +2004-07-06 Daisuke Kameda + + Re-Creating immodule for TQt/X11 trunk + +2004-06-22 YamaKen + + * src/kernel/tqinputcontext.h + - (sendIMEvent): Private version of sendIMEvent(). Remove to + rename to sendIMEventInternal + - (sendIMEventInternal): Rename from sendIMEvent and accept + discrete variables rather than TQEvent *e to be adaptable + to TQt/Embedded + * src/kernel/tqinputcontext.cpp + - (sendIMEvent): Protected version of sendIMEvent(). Move + TQEvent construction to sendIMEventInternal() + - (sendIMEvent): Private version of sendIMEvent(). Remove to + rename to sendIMEventInternal + - (sendIMEventInternal): + * Rename from sendIMEvent + * accept discrete variables rather than TQEvent *e to be + adaptable to TQt/Embedded + * Add placeholder for TQt/Embedded + - (setFocusWidget): Follow specification change of sendIMEvent() + +2004-06-20 YamaKen + + * src/kernel/tqevent.h + - (class TQIMError): Remove to rename to TQIMErrorEvent + - (class TQIMErrorEvent): Rename from TQIMError + - (TQIMErrorEvent::isDeleteIC): Remove to rename to isDeletionRequest + - (TQIMErrorEvent::isDeletionRequest): Rename from isDelete + + * src/kernel/tqwidget.h + - (imErrorEvent): Follow renaming of TQIMError + * src/kernel/tqwidget.cpp + - (imErrorEvent): Follow renaming of TQIMError and + TQIMError::isDeleteIC() + - (event): Follow renaming of TQIMError + + * src/kernel/tqinputcontext.h + - (ownerWidget): Remove to rename to holderWidget + - (holderWidget): Rename from ownerWidget + - (setOwnerWidget): Remove to rename to setHolderWidget + - (setHolderWidget): Rename from setOwnerWidget + - (releaseComposingWidget): New function. + * src/kernel/tqinputcontext.cpp + - (class TQInputContextPrivate): Rename ownerWidget to holderWidget + - (ownerWidget): Remove to rename to holderWidget + - (holderWidget): Rename from ownerWidget + - (setOwnerWidget): Remove to rename to setHolderWidget + - (setHolderWidget): Rename from setOwnerWidget + - (sendIMError): Follow renaming of TQIMError and + TQIMError::isDeleteIC() + - (releaseComposingWidget): New function. + + * src/input/tqinputcontextfactory.cpp + - (create): Follow renaming of TQInputContext::setOwnerWidget() + + * src/kernel/tqwidget_x11.cpp + - (destroy): Add qic->releaseComposingWidget() to reset + preserved composing information involving this widget + +2004-06-15 YamaKen + + * src/kernel/tqwidget_x11.cpp + - (setMicroFocusHint): Replace relative coordinate with + global one for qic->setMicroFocus(). This is required to + share particular IM plugin code with TQt/Embedded + + * src/widgets/tqlineedit.cpp + - (sendMouseEventToInputContext): Add button event sending + when clicking on out of preedit + + * src/widgets/tqtextedit.cpp + - (sendMouseEventToInputContext): Add button event sending + when clicking on out of preedit + + * src/input/tqximinputcontext_p.h + - (isComposing): New function + - (composing, cpos, sellen): Remove to follow API change + - (isPreeditRelocationEnabled): New overriding function to + follow API change + - (isPreeditPreservationEnabled): New function + + * src/input/tqximinputcontext_x11.cpp + - (xic_start_callback, xic_draw_callback, xic_done_callback, + x11FilterEvent, reset): Replace qic->composing with + qic->isComposing() to use automatic compose state tracking + of TQInputContext + - (TQXIMInputContext): Remove composing, cpos, sellen from + initializer list + - (sendIMEvent): Remove remembering of cpos, sellen + - (reset): Replace IMEnd event sending with + TQInputContext::reset() + - (resetClientState): Remove cpos, sellen, composing + - (isComposing): Exported interface for xic callbacks to + access protected TQInputContext::isComposing() + - (setMicroFocus): Follow API change that replaces relative + coordinate with global one + - (mouseHandler): Add approprate reset on clicking + - (setFocus, unsetFocus): Remove preedit preservation and + relocation to follow API change. They are moved to + TQInputContext as generarization + - (isPreeditRelocationEnabled): New function to follow API + change. + - (isPreeditPreservationEnabled): New function. This + indicates that whether preedit state should be preserved + or not when focusing out the widget + +2004-06-14 YamaKen + + * src/kernel/tqinputcontext.h + - (setFocus): Remove hasPreservedPreedit arg + - (unsetFocus): Remove preservePreedit arg + - (isPreeditRelocationEnabled): New function + - (isComposing): New function + + * src/kernel/tqinputcontext.cpp + - (class TQInputContextPrivate): Reorganize variables for + preedit relocation + - (TQInputContextPrivate::resetComposingState): New function + - (TQInputContextPrivate::updateComposingState): New function + - (setFocusWidget): Add preedit relocation support. Preedit + state is relocated to another text widget when the shared + context has focused on the another text widget. This + feature is mainly used by Japanese input methods + - (isPreeditRelocationEnabled): New function. Preedit + relocation is enabled only if this function returned TRUE. + - (isComposing): New function. Returns current composing + state as result of automatic compose state tracking + through sendIMEvent(). The function is for used by + subclass of TQInputContext to know preedit state of the + widget. Although TQWidget and TQInputContextFactory can + access to the function as friend, they must not use the + function to know composing state of contexts. Keep less + relationship to simplify input method development + - (sendIMEvent): New 1-arg overloaded function. The function + encupsulates platform-dependent IMEvent sending. Only + TQ_WS_X11 is supported for now. TQ_WS_TQWS should be supported + - (sendIMEvent): + * 4-args version of the overloaded function + * Isolate platform-dependent event sending process to + separated function + * Add preedit relocation support + * Add compose state tracking support + - (unsetFocus): Add reset() for simple ephemeral input + contexts + - (mouseHandler): Add reset() when clicking for simple + ephemeral input contexts + - (reset): Add preedit finalization code. Overriding + function should call this function to ensure proper + preedit state + +2004-06-11 YamaKen + + * src/kernel/tqlineedit.cpp + - (TQLineEditPrivate::xToPosInternal, TQLineEditPrivate::xToPos): + Fix loose placement to tail when clicking beyond the string + +2004-06-10 YamaKen + + * src/kernel/tqinputcontext.h + - Remove several pointers to TQWidget to share concrete IM + implementation code with TQt/Embedded. The IM model of + TQt/Embedded requires that widgets and input contexts are + existing in another process + - (TQInputContext): Remove the TQWidget * arg + - (tqfocusWidget, ownerWidget): + * Move to protected and unrecommended + * Move the inline function definition to qinputcontext.cpp + - (filterEvent): Remove unnecessary keywidget + - (setFocus): + * Remove newFocusWidget arg + * Add hasPreservedPreedit arg + - (unsetFocus): Add preservePreedit arg + - (sendIMError): New function to hide ownerWidget from + derived TQInputContext + - (composingWidget, setComposingWidget): New function to support + preedit relocation of shared context on focus transition + - (setFocusWidget, setOwnerWidget): New function to + implement internal functionality on TQt/X11 platform + - (d): New variable to hide ABI change + - (TQInputContext, operator=): New function to disable copy + constructor and operator= + + * src/kernel/tqinputcontext.cpp + - (class TQInputContextPrivate): New class to hide ABI change + - (TQInputContext): + * Follow API change + * Follow introducing TQInputContextPrivate + - (~TQInputContext): Follow introducing TQInputContextPrivate + - (ownerWidget): + * Move from qinputcontext.h + * Follow introducing TQInputContextPrivate + - (setOwnerWidget): New function to complement removal of + the arg of TQInputContext constructor + - (composingWidget, setComposingWidget): New function. These + functions are participating with preedit relocation of shared + context on focus transition + - (tqfocusWidget): + * Move from qinputcontext.h + * Follow introducing TQInputContextPrivate + * Follow introducing composingWidget + - (setFocusWidget): New function to complement removal of + the TQWidget * arg of setFocus() + - (filterEvent): Follow API change of removal of keywidget + - (sendIMEvent): Add #ifdef to isolate TQt/X11 dependent code + - (sendIMError): New function to hide ownerWidget() from + derived TQInputContext. This is required to share particular + IM plugin code with TQt/Embedded + - (setFocus, unsetFocus): Follow API change + + * src/input/tqinputcontextfactory.cpp + - (create): Add ownerWidget initialization for new context + + * src/kernel/tqwidget.cpp + - (setFocus): Remove unnecessary shared input context + checking + + * src/kernel/tqwidget_x11.cpp + - (setActiveWindow): Replace duplicated code with + focusInputContext() + - (getInputContext): Return input context only if + isInputMethodEnabled() widget, otherwise returns 0. This + is required for proper focus transition handling + - (unfocusInputContext): Follow API change of + TQInputContext::unsetFocus() + + * src/kernel/tqapplication.cpp + - (setActiveWindow): Follow change of TQWidget::unfocusInputContext() + + * src/kernel/tqapplication_x11.cpp + - (x11ProcessEvent): Follow API change of + TQInputContext::filterEvent() + + * src/input/tqximinputcontext_p.h + - (setFocus, unsetFocus): Follow API Change + - (hasFocus): New function + - (close): New function + + * src/input/tqximinputcontext.cpp + - Remove unrecommended tqfocusWidget() and ownerWidget() + - (ximWidgetList): Remove to replace with ximContextList + - (ximContextList): New variable + - (xic_draw_callback): Replace tqfocusWidget() with hasFocus() + to follow API Change + - (TQXIMInputContext): + * Follow API change + * Follow replacing to ximContextList + - (~TQXIMInputContext): + * Follow replacing to ximContextList + * Remove unnecessary TQInputContext::unsetFocus() + - (close_xim): + * Follow replacing to ximContextList + * Follow API change + - (close, hasFocus): New function. Exported interface for + xic_draw_callback to access protected features + - (setFocus, unsetFocus): Follow API change + +2004-06-09 YamaKen + + * src/kernel/tqwidget.cpp + + - (hide): Remove unfocusInputContext(). This caused + excessive invalid TQInputContext::unsetFocus(). + TQWidget::deactivateWidgetCleanup() handles + unfocusInputContext() appropriately via + tqApp->setActiveWindow( 0 ). + +2004-06-08 YamaKen + + * src/kernel/tqrichtext_p.h + - (TQTextCursor::place): New 5-args overloaded function + - (TQTextCursor::place): 3-args version of the function is + reimplemented as inline function using new 5-args one. + * src/kernel/tqrichtext.cpp + - (TQTextCursor::place): Remove 3-args version of the function + - (TQTextCursor::place): New 5-args overloaded function. This + is copied from 3-args one and added new args loosePlacing + and matchBetweenCharacters + + * src/widgets/tqtextedit.cpp + - (sendMouseEventToInputContext): Send mouse event when only + mouse cursor is placed within preedit area. This is + accomplished by new 5-args TQTextCursor::place() + - (contentsContextMenuEvent): Disable context menu when in + IM composing state + - (drawContents): Add updateMicroFocusHint() to follow + dragging of active window by the showed candidate window + - (contentsMouseMoveEvent): Fix cursor vanishing on IM + composing state + + * src/kernel/tqlineedit.cpp + - (sendMouseEventToInputContext): Exclude character at + preedit[preeditLength] from being handled as preedit + - (contextMenuEvent): Disable context menu when in IM + composing state + - (focusInEvent): Fix invalid MicroFocusHint position which + caused that candidate window is always showed at end of + the preedit when active window is show() back + +2004-06-07 YamaKen + + * src/kernel/tqwidget_x11.cpp + - (reparentSys): Fix an invalid assumption about input + context location involving destroyInputContext() + - (deleteTLSysExtra): Remove destroyInputContext() because + the input context is not a extra data and should be + destroyed in TQWidget::destroy() + - (destroyInputContext): Remove icHolderWidget() because + this function is called to destroy the input context that + belongs to the widget itself + - (destroy): Replace 'this->ic' with 'ic' + - (create): Replace 'this->ic' with 'ic' + + * src/kernel/tqwidget.cpp + - (hide): Add unfocusInputContext() + + * src/kernel/tqapplication.cpp + - (setActiveWindow): Add unfocusInputContext() + + * src/kernel/tqlineedit.cpp + - (TQLineEditPrivate::xToPosInternal): New function. Copied + from xToPos and Remove the safety limiter. + - (TQLineEditPrivate::xToPos): Reimprement using xToPosInternal + - (sendMouseEventToInputContext): + * Fix position boundary as matching with character + boundary rather than center of character + * Send mouse event when only mouse cursor is placed within + preedit area. This is accomplished by replacing xToPos() + with xToPosInternal() + +2004-06-04 YamaKen + + * src/kernel/tqinputcontext.h + - (font): New function. Returns the font of tqfocusWidget() + * src/kernel/tqinputcontext.cpp + - (font): New function + + * src/kernel/tqwidget_x11.cpp + - (setActiveWindow, focusInputContext): Avoid calling + qic->setFocus() if the target is identical widget + - (setMicroFocusHint, setActiveWindow, createInputContext, + destroyInputContext, resetInputContext, + focusInputContext): Remove obsolete comment around qic + retrieving + + * src/input/tqximinputcontext_x11.cpp + - (language): Return Chinese languages appropriately (such + as "zh_CN") + +2004-06-03 YamaKen + + * src/kernel/tqinputcontext.h + - (getOwnerWidget): Remove to rename to ownerWidget + - (ownerWidget): New function. Rename from getOwnerWidget to + be consistent with the name tqfocusWidget + - (tqfocusWidget): New function. Add to make IM-related + communication with tqfocusWidget easy. The name is imported + from TQApplication::tqfocusWidget to be supposed same role + - (language): Change return type to TQCString from const char * + - (filterEvent): Change args. Passes TQEvent *event rather than + preexpanded key event values. This is intended to pass other + IM-related events in future. The IM-related events are + supposed as TQWheelEvent, TQTabletEvent and so on + - (setFocusHint): Remove to be appropriate name + - (setMicroFocus): + * Rename from setFocusHint to be appropriate name. This + function instructs 'MicroFocus' rect within a widget that + is different to normal focus for widgets, so the name + 'setFocus' is invalid. And 'Hint' is a concept for the + manager of this class and loses the meaning when passed to + this class. The passed values are not a hint but have + well-defined actual effect, so the name 'Hint' is + invalid. Finally, TQt/Embedded 2.3.7 has a samely named + method in TQWSInputMethod + * Remove the arg 'widget' to consistent with the new + tqfocusWidget() method + - (mouseHandler): New function. The method interface is + imported from TQWSInputMethod::mouseHandler() of TQt/Embedded + 2.3.7 and extended for desktop system + - (sendIMEvent): New function. Conventional function to send + TQIMEvent to appropriate widget using tqfocusWidget(). IM + developers can send IMEvents without tracking focuswidget by + themself + - (ownerWidget): Remove to Rename to _ownerWidget + - (_ownerWidget): New variable. Renamed from ownerWidget to + avoid name conflict with ownerWidget() + - (_tqfocusWidget): New variable. + * src/kernel/tqinputcontext.cpp + - (TQInputContext): Follow API change + - (~TQInputContext): Clean up + - (filterEvent): Follow API change + - (sendIMEvent): New function. + - (setFocusHint): Remove to follow new API + - (setMicroFocus): copied from setFocusHint and reimplement to + follow new API + - (mouseHandler): New function + - (language): Follow API change + + * src/kernel/tqwidget.h + - (sendMouseEventToInputContext): New function + - (unfocusInputContext): New function + + * src/kernel/tqwidget.cpp + - (setFocus): Invoke unfocusInputContext() with previous + focus widget to delegate reset responsibility to input + context instead of resetInputContext() directly. See also + comment for further information + - (clearFocus): Add unfocusInputContext(); + - (event): Delegate reset responsibility to input context + instead of resetInputContext() directly. See also comment + for further information + + * src/kernel/tqwidget_x11.cpp + - (setMicroFocusHint): Modify to follow API change + - (setActiveWindow): Modify to follow API change + - (focusInputContext): Modify to follow API change + - (unfocusInputContext): New function + - (sendMouseEventToInputContext): New function + + * src/kernel/tqapplication_x11.cpp + - (class TQETWidget): Change translateKeyEventInternal definition + - (x11ProcessEvent): Change TQInputContext::filterEvent() + invocation to follow API change + - (translateKeyEventInternal): + * Add new arg statefulTranslation to enable duplicate call + within single event loop. This is required to support both + TQInputContext::filterEvent() and RTL extensions + * Restore accidencially omitted qt_mode_switch_remove_tqmask + handling + + * src/input/tqximinputcontext_p.h + - (class TQXIMInputContext): Follow API change of TQInputContext + - (language): Change return type to follow new API + - (setFocus): Change arg to follow new API + - (setFocusHint): Remove to follow new API + - (setMicroFocus): New method to follow new API + - (mouseHandler): New method to follow new API + - (sendIMEvent): New method (reimp) + - (tqfocusWidget): Remove to follow new API + - (cpos): New variable + - (sellen): New variable + * src/input/tqximinputcontext_x11.cpp + - (qt_compose_emptied): Remove as result of optimization. It + has become unnecessary now + - (xic_start_callback): Add IMStart event sending as + result of optimization + - (xic_draw_callback): Optimize state management for IMEvent + sending, and simplify using sendIMEvent() + - (xic_done_callback): Simplify using sendIMEvent() + - (TQXIMInputContext): + * Follow class definition change + * Follow API change + - (~TQXIMInputContext): Modify to follow API change + - (x11FilterEvent): Optimize state management for IMEvent + sending, and simplify using sendIMEvent() + - (sendIMEvent): New function. Implement to remember last + IMEvent information + - (reset): Simplify using sendIMEvent() + - (resetClientState): Follow class definition change + - (setFocusHint): Remove to follow new API + - (setMicroFocus): copied from setFocusHint and modified to + follow new API + - (mouseHandler): New function. Implemented to reset the + context on MouseButtonPress except for Japanese IM. See + also comment for further information + - (setFocus): Reimplement to follow new API. Automatically + handles appropriate IMEvent sending on focus transition + - (unsetFocus): Reimplement to follow new API. Implemented to + reset the context on FocusOut except for Japanese IM. See + also comment for further information + + * src/widgets/tqlineedit.h + - (sendMouseEventToInputContext): New function + * src/widgets/tqlineedit.cpp + - (TQLineEditPrivate::composeMode): New function + - (TQLineEditPrivate::hasIMSelection): New function + - (TQLineEditPrivate::preeditLength): New function + - (TQLineEditPrivate::imSelectionLength): New function + - (mousePressEvent, mouseMoveEvent, mouseReleaseEvent, + mouseDoubleClickEvent): Support TQInputContext::mouseHandler() + - (sendMouseEventToInputContext): New function. Retrieve the + position and call TQWidget::sendMouseEventToInputContext() + - (drawContents): Follow API change + + * src/widgets/tqtextedit.h + - (sendMouseEventToInputContext): New function + * src/widgets/tqtextedit.cpp + - (TQTextEditPrivate::composeMode): New function + - (sendMouseEventToInputContext): New function. Retrieve the + position and call TQWidget::sendMouseEventToInputContext() + - (imComposeEvent, imEndEvent): Clean up with composeMode() + - (contentsMousePressEvent, contentsMouseMoveEvent, + contentsMouseReleaseEvent, contentsMouseDoubleClickEvent): + Support TQInputContext::mouseHandler() + +2004-06-01 YamaKen + + * src/input/tqximinputcontext_x11.cpp (x11FilterEvent): Fix + commit problem except for on-the-spot style + +2004-05-31 YamaKen + + * First 'Simplified API' patch. A lot of changes to be described + +2004-03-16 Daisuke Kameda + + * A lot of changes to be described before this date. Almost + of code are written by Daisuke Kameda diff --git a/tqtinterface/qt4/README.immodule b/tqtinterface/qt4/README.immodule new file mode 100644 index 0000000..9dabe52 --- /dev/null +++ b/tqtinterface/qt4/README.immodule @@ -0,0 +1,107 @@ +immodule for TQt + + +* What is this? + + immodule for TQt is a modular, extensible input method subsystem for + TQt. + + This project brings functionality similar to the immodule for GTK+ + to the TQt library. The main goal of the project is to extend and + enhance the input method support in the TQt library, in order to + provide a modern and powerful multi-language input system. Our short + term goal is to make TQt (especially TQt/X11) "up-to-date" with other + X11-based toolkits such as GTK+. We are also focusing on what the + input method API should be for future TQt versions. + + See our webpage for further information. + + http://immodule-qt.freedesktop.org/ + + +* About this release + + qt-x11-immodule-unified-qt3.3.3-20040910 is a stable release. Since + it breaks backward compatibility (source and binary) about immodule + with our previous releases qt-x11-immodule-unified-qt3.3.3-20040819 + and qt-x11-immodule-bc-qt3.3.2-20040623, optional immodule plugins + must be updated to proper version. See 'Optional immodule plugins' + section of our download page. + + http://immodule-qt.freedesktop.org/Software/ImmoduleTQtDownload + + However, backward compatibility (source and binary) with normal TQt + 3.3.3 is kept in 'Binary Compatible' mode. + + +* How to install + + After extract the TQt archive, perform following instructions + + cd qt-x11-free-3.3.3 + patch -p0 < qt-x11-immodule-unified-qt3.3.3-20040910.diff + ./make-symlinks.sh + ./configure + + Our patch provides following two configure options. Choose 'Binary + Compatible' for normal use. + + Build TQt with 'Binary Compatible' immodule support (default) + + configure -inputmethod + + Build TQt without binary compatibility, but supports more advanced + immodule extensions. It cannot be used with ordinary application + binaries (i.e. the option is for developers) + + configure -inputmethod -inputmethod-ext + + +* How to use + + - See users manual of each input method plugins + + - Run qtconfig to choose your favorite XIM input style + + +* Environment variables + + Some environment variables are available for expert users and system + integrators. The specification is preliminary and may be changed + without notification. Be careful. + + See following examples to use the variables. + + + - set "xim" input method as default + + export TQT_IM_MODULE=xim + + + - set "simple" composing input method as default + + export TQT_IM_MODULE=simple + + + - set "xim" input method as default, and disable input method + selection menu in the context menu + + export TQT_IM_SWITCHER=imsw-none + export TQT_IM_MODULE=xim + + + - set "xim" input method as default, and enable input method + selection menu in the context menu (default configuration) + + export TQT_IM_SWITCHER=imsw-multi + export TQT_IM_MODULE=xim + + + - set "iiimqcf" that has its own input method switching framework as + default, and disable input method selection menu in the context + menu. Such configuration is required by some system integrators to + provide unified user interface for global input method switching + over the desktop + + export TQT_IM_SWITCHER=imsw-none + export TQT_IM_MODULE=iiimqcf diff --git a/tqtinterface/qt4/changes.immodule b/tqtinterface/qt4/changes.immodule new file mode 100644 index 0000000..4eaac8d --- /dev/null +++ b/tqtinterface/qt4/changes.immodule @@ -0,0 +1,248 @@ +This file describes significant change from +qt-x11-immodule-bc-qt3.3.2-20040623. + +Differences from previous release +(qt-x11-immodule-unified-qt3.3.3-20040819) are itemized with '+' +sign. Search it to track incremental change. + +**************************************************************************** +* For users * +**************************************************************************** + +General +------- + ++ A strange character inversion problem on some input methods has been + fixed + + +Input methods +------------- + +- Added "simple" input method which provides dead/multi key composing + for latin languages + + +User Interface +-------------- + +- Added input method selection menu in the context menu of text + widgets + + +Configuration +------------- + ++ default IM configuration feature of qtconfig has been disabled in BC + mode. This is a political change to avoid the confusion about input + method configuration in accordance with GTK+ environment. + + See following discussion for further information. + + http://freedesktop.org/pipermail/immodule-qt/2004-August/000416.html + +- Added new environment variables TQT_IM_SWITCHER and TQT_IM_MODULE to + set user's favorite input method as default. See README.immodule for + examples. + + +Build & Install +--------------- + ++ configure options have been changed for internal reasons. See 'How + to install' section of README.immodule + +- This version of immodule requires corresponding version of each + input method plugins (i.e. update your additional input method + plugins) + +- Plugin directory has been changed from $TQTDIR/plugins/input/ to + $TQTDIR/plugins/inputmethods/. Delete old directory. + +- Some codes have been changed to allow compiling against TQt 3.2.x or + earlier. + + +**************************************************************************** +* For develpers * +**************************************************************************** + +Documents +--------- + +- Almost description of TQInputContext and TQInputContextPlugin has been + filled. Feel free to ask obscure things at our mailinglist. + + +New features +------------ + +- Pluggable input method switcher + + Now we can write input method switcher as an ordinary input method + plugin. The two plugins 'imsw-multi' and 'imsw-none' are provided as + default. But the architecture needs more discussion about whether + the design is right or not. Join the discussion. + +- Pluggable popup menu + + Any input method can provide its own popup menu. See + http://freedesktop.org/pipermail/immodule-qt/2004-August/000266.html + for further information. + +- TQInputContext proxying + + Some methods of TQInputContext have been changed to enable + TQInputContext proxying. This feature is required to implement + pluggable input method switcher. + + +General +------- + ++ TQInputContext has been source compatible with TQt4 version. Basic + input method plugin can be source compatible without #ifdef. Only + pluggable popup menu requires #ifdef'ed different code. In addition, + be careful about use of classes that is deprecated in TQt4. + +- Our two development tree for TQt3 'Binary Compatible' and 'ALL' have + been merged into this unified source tree. The source tree is called + 'Unified' patch. + +- 'dead keys' for latin languages have been added into TQt::Key + +- Added plugins/src/inputmethods directory to build input method + plugins within the TQt source tree. The directory name 'inputmethods' + is intended to be compatible with TQt/Embedded. Install directory + name is still kept as 'input' for backward compatibility + +- Changed XIM input method to a plugin instead of directly link into + libqt + +- Plugin directory has been changed from $TQTDIR/plugins/input/ to + $TQTDIR/plugins/inputmethods/. Replace install directory with new + one. + +- Fixed some bugs in previous qt-x11-immodule-bc-qt3.3.2-20040623. See + following log for more detail. + + * src/kernel/tqwidget_x11.cpp + - (destroyInputContext): Replace the code with original Simplified + API patch. See the comment to recognize the original intention + - (focusInputContext): Fix a condition to call qic->setFocus() as + originally written. See added comment to recognize the original + intention + +- TQLocale dependency has been removed to be compiled on TQt 3.2.x or + earlier + +- Many internal improvements and cleanups + + +API Changes in qt-x11-immodule-unified-qt3.3.3-20040910 +------------------------------------------------------- ++ TQInputContext + + * TQInputContext() + + Added 'tqparent' arg to be compatible with TQt4. Since the arg + defaults to 0, no modification of plugins are required. + + * language() + * identifierName() + + Return type of these two methods have been changed from TQCString + which is deprecated in TQt4 to TQString to make plugins source + compatible with TQt4. + + * addActionsTo() + + New method for TQt4 text widget developer + + +API Changes in qt-x11-immodule-unified-qt3.3.3-20040812 +------------------------------------------------------- + +- TQInputContext proxying + + TQInputContext have been changed as follows to enable TQInputContext + proxying. + + 1. Use signal to deliver TQIMEvent instead of explicit + postEvent(). This enables TQIMEvent proxying and better platform + abstraction. Corresponding slot is created as + TQApplication::imEventReceived(). + + 2. Move some methods of TQInputContext to public from protected or + private. This enables that proxy-IM can access slave methods. + + 3. Make some methods of TQInputContext virtual. This enables + overriding the methods as proxy + + 4. Rename TQInputContext::name() to identifierName() to avoid + conflicting with TQObject::name() + + +- TQInputContext + + * language() + + New method to indicate current language + + * menus() + + New method for the pluggable popup menu feature + + * addMenusTo() + + New method for text widget developer + + * deletionRequested() + + New signal to request deletion of this instance. This is added for + fatal error handling + + * identifierName() + + This replaces name() of previous API to avoid conflicting with + TQObject::name(), and to distinguish the role from displayName() + + * filterEvent() + + Turn the argument into const. See + http://freedesktop.org/pipermail/immodule-qt/2004-August/000335.html + for further information + + * isComposing + * isPreeditRelocationEnabled + + Move to public from protected to allow proxying + + * setFocusWidget + * setHolderWidget + * releaseComposingWidget + + Move to public from private to allow proxying + + * tqfocusWidget + * holderWidget + + - Make public from protected to allow proxying + - Make virtual to allow overriding the method as proxy + +- TQInputContextPlugin + + * languages() + + New method which returns what languages are supported by the + TQInputContext instance + + * displayName() + + New method which returns a user friendly i18n-ized name of the + TQInputContext instance + + * description() + + New method which returns a i18n-ized brief description of the + TQInputContext instance diff --git a/tqtinterface/qt4/configure b/tqtinterface/qt4/configure index 3d7e39f..8a952c0 100755 --- a/tqtinterface/qt4/configure +++ b/tqtinterface/qt4/configure @@ -34,7 +34,44 @@ SUPPORTED= #------------------------------------------------------------------------------- # need that throughout the script -UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown +DPKG_ARCH=`(dpkg-architecture -qDEB_HOST_ARCH) 2>/dev/null` || UNAME_MACHINE=unknown +case $DPKG_ARCH in + amd64) + UNAME_MACHINE="x86_64" + ;; + arm) + UNAME_MACHINE="armv4l" + ;; + armel) + UNAME_MACHINE="armv5tel" + ;; + hppa) + UNAME_MACHINE="parisc64" + ;; + hurd-i386) + UNAME_MACHINE="i686-AT386" + ;; + i386) + UNAME_MACHINE="i686" + ;; + kfreebsd-amd64) + UNAME_MACHINE="x86_64" + ;; + kfreebsd-i386) + UNAME_MACHINE="i586" + ;; + mipsel) + UNAME_MACHINE="mips" + ;; + powerpc) + UNAME_MACHINE="ppc" + ;; + *) + UNAME_MACHINE="$DPKG_ARCH" + ;; + + +esac UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown @@ -81,7 +118,7 @@ Edition="free" Licensee="Free" Products="qt-free" -MODULES="styles tools kernel widgets dialogs iconview workspace" +MODULES="styles tools kernel widgets dialogs iconview workspace inputmethod" MODULES="$MODULES network canvas table xml opengl sql" CFG_MODULES_AVAILABLE=$MODULES QMAKE_VARS="$QMAKE_VARS \"TQT_PRODUCT=$Products\"" @@ -126,6 +163,9 @@ CFG_SQL_AVAILABLE= CFG_SQL_AUTODETECTED= CFG_GFX_AVAILABLE= CFG_STYLE_AVAILABLE= +#Keep this position for CFG_IM* to avoid patch rejection +CFG_IM=yes +CFG_IM_EXT=no CFG_TABLET=auto CFG_XKB=auto CFG_NIS=auto @@ -257,6 +297,12 @@ while [ "$#" -gt 0 ]; do VAR=fatal_error VAL=no ;; + #TQt style yes options for immodule + #Keep this place to avoid patch rejection + -inputmethod|-inputmethod-ext) + VAR=`echo $1 | sed "s,^-\(.*\),\1,"` + VAL=yes + ;; -embedded) VAR=embedded # this option may or may not be followed by an argument @@ -876,6 +922,20 @@ while [ "$#" -gt 0 ]; do dlopen-opengl) CFG_DLOPEN_OPENGL="$VAL" ;; + inputmethod) + if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then + CFG_IM="$VAL" + else + UNKNOWN_OPT=yes + fi + ;; + inputmethod-ext) + if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then + CFG_IM_EXT="$VAL" + else + UNKNOWN_OPT=yes + fi + ;; *) UNKNOWN_OPT=yes ;; @@ -1181,7 +1241,7 @@ if [ "$CFG_EMBEDDED" != "no" ]; then XPLATFORM="qws/solaris-$CFG_EMBEDDED-g++" fi ;; - Linux:*) + Linux:*|GNU:*|GNU/*:*) if [ -z "$PLATFORM" ]; then case "$UNAME_MACHINE" in *86) @@ -1236,9 +1296,6 @@ if [ -z "$PLATFORM" ]; then QNX:*) PLATFORM=qnx-g++ ;; - GNU:*) - PLATFORM=hurd-g++ - ;; dgux:*) PLATFORM=dgux-g++ ;; @@ -1285,7 +1342,7 @@ if [ -z "$PLATFORM" ]; then - Also available for Tru64: tru64-g++ " ;; - Linux:*) + Linux:*|GNU:*|GNU/*:*) PLATFORM=linux-g++ PLATFORM_NOTES=" - Also available for Linux: linux-kcc linux-icc linux-cxx @@ -1482,7 +1539,7 @@ if echo $MODULES | grep sql >/dev/null; then ODBC_REQ="-lodbc sql.h sqlext.h" TDS_REQ="-lsybdb sybfront.h sybdb.h" DB2_REQ="-ldb2 sqlcli.h sqlcli1.h" - IBASE_REQ="-lgds ibase.h" + IBASE_REQ="-lfbclient ibase.h" for _SQLDR in $CFG_SQL_AVAILABLE; do case $_SQLDR in mysql) @@ -1755,6 +1812,13 @@ if [ "$PLATFORM_QWS" = "yes" ]; then CFG_GFX_AVAILABLE=`echo $CFG_GFX_AVAILABLE` fi +# immodule extensions +if [ "$CFG_IM" = "no" ]; then + CFG_IM_EXT=no +fi +if [ "$CFG_IM_EXT" = "yes" ]; then + CFG_IM=yes +fi #------------------------------------------------------------------------------- # help - interactive parts of the script _after_ this section please @@ -2062,6 +2126,20 @@ if [ "$PLATFORM_X11" = "yes" ]; then XKY="*" XKN=" " fi + if [ "$CFG_IM" = "no" ]; then + IMY=" " + IMN="*" + else + IMY="*" + IMN=" " + fi + if [ "$CFG_IM_EXT" = "no" ]; then + IXY=" " + IXN="*" + else + IXY="*" + IXN=" " + fi cat << EOF Qt/X11 only: @@ -2110,6 +2188,14 @@ Qt/X11 only: -dlopen-opengl ..... Qt uses dlopen(3) to resolve OpenGL functions (instead of linking with OpenGL libraries directly). + $IMN -no-inputmethod .... Do not compile immodule (extensible input method) + support. + $IMY -inputmethod ....... Compile immodule support. + + $IXN -no-inputmethod-ext Do not compile more immodule extensions support. + $IXY -inputmethod-ext ... Compile more immodule extensions support. + (breaks ABI with standard TQt3). + EOF fi @@ -2665,6 +2751,16 @@ if [ "$PLATFORM_X11" = "yes" ]; then if [ "$CFG_XKB" = "yes" ]; then QMAKE_CONFIG="$QMAKE_CONFIG xkb" fi + if [ "$CFG_IM" = "yes" ]; then + TQMAKE_CONFIG="$TQMAKE_CONFIG inputmethod" + elif [ "$CFG_IM" = "no" ]; then + TQCONFIG_FLAGS="$TQCONFIG_FLAGS TQT_NO_IM" + fi + if [ "$CFG_IM_EXT" = "yes" ]; then + TQMAKE_CONFIG="$TQMAKE_CONFIG inputmethod-ext" + elif [ "$CFG_IM_EXT" = "no" ]; then + TQCONFIG_FLAGS="$TQCONFIG_FLAGS TQT_NO_IM_EXTENSIONS" + fi elif [ "$PLATFORM_MAC" = "yes" ]; then if [ "$CFG_TABLET" = "yes" ]; then QMAKE_CONFIG="$QMAKE_CONFIG tablet" @@ -2760,15 +2856,15 @@ case "$COMPILER" in g++*) # GNU C++ QMAKE_CONF_COMPILER=`grep "QMAKE_CXX[^_A-Z0-9a-z]" $QMAKESPEC/qmake.conf | sed "s,.* *= *\(.*\)$,\1,"` - COMPILER_VERSION=`${QMAKE_CONF_COMPILER} --version 2>/dev/null` + COMPILER_VERSION=`${QMAKE_CONF_COMPILER} --version 2>/dev/null | sed 's,^[^0-9]*,,g'` case "$COMPILER_VERSION" in - *2.95.*) + 2.95.*) COMPILER_VERSION="2.95.*" ;; - *3.*) + 3.*) COMPILER_VERSION="3.*" ;; - *4.*) + 4.*) COMPILER_VERSION="4" ;; *) @@ -2789,7 +2885,7 @@ esac # minimal-config small-config medium-config large-config full-config # # Modules: -# styles tools kernel widgets dialogs iconview workspace +# styles tools kernel widgets dialogs iconview workspace inputmethod # # Enterprise/Open Source edition modules: # network canvas table xml opengl sql @@ -2797,6 +2893,8 @@ esac # Options: # stl # +# X11 : inputmethod-ext +# # Things that do not affect the Qt API/ABI: # system-jpeg no-jpeg jpeg # system-mng no-mng mng @@ -2818,10 +2916,10 @@ esac # tablet # ipv6 # -# X11 : xftnameunparse x11sm xinerama xcursor xrandr xrender xftfreetype xkb +# X11 : xftnameunparse x11sm xinerama xcursor xrandr xrender xftfreetype xkb inputmethod # Embedded: embedded ft # -ALL_OPTIONS="styles tools kernel widgets dialogs iconview workspace network canvas table xml opengl sql stl" +ALL_OPTIONS="styles tools kernel widgets dialogs iconview workspace inputmethod network canvas table xml opengl sql stl" BUILD_CONFIG= BUILD_OPTIONS= @@ -2835,7 +2933,7 @@ for config_option in $QMAKE_CONFIG; do BUILD_CONFIG="$config_option" ;; - styles|tools|kernel|widgets|dialogs|iconview|workspace|network|canvas|table|xml|opengl|sql|stl) + styles|tools|kernel|widgets|dialogs|iconview|workspace|inputmethod|network|canvas|table|xml|opengl|sql|stl) # these config options affect the Qt API/ABI. they should influence # the generation of the buildkey, so we don't skip them SKIP="no" @@ -3182,6 +3280,8 @@ if [ "$PLATFORM_X11" = "yes" ]; then echo "XRender support ..... $CFG_XRENDER" echo "Xft support ......... $CFG_FREETYPE" echo "XKB Support ......... $CFG_XKB" + echo "immodule support .... $CFG_IM" + echo "immodule ext support $CFG_IM_EXT" elif [ "$PLATFORM_MAC" = "yes" ]; then echo "Accessibility ....... $CFG_ACCESSIBILITY" echo "Tablet support ...... $CFG_TABLET" @@ -3207,7 +3307,7 @@ EXEC="" echo "Finding project files. Please wait..." if [ -z "$QMAKE_PROJECTS" ]; then - QMAKE_PROJECTS=`find $relpath/. -name '*.pro' -print | sed 's-/\./-/-'` + QMAKE_PROJECTS=`find $relpath/. -name '.pc' -prune -o -name '*.pro' -print | sed 's-/\./-/-'` else TQT_PROJECTS= for a in `echo $QMAKE_PROJECTS`; do diff --git a/tqtinterface/qt4/make-symlinks.sh b/tqtinterface/qt4/make-symlinks.sh new file mode 100644 index 0000000..5d78317 --- /dev/null +++ b/tqtinterface/qt4/make-symlinks.sh @@ -0,0 +1,12 @@ +#!/bin/sh +cd include +rm -f q*.h +ln -s ../src/*/tq*.h . +ln -s ../extensions/*/src/q*.h . +ln -s ../tools/assistant/lib/qassistantclient.h . +ln -s ../tools/designer/uilib/qwidgetfactory.h . +rm -f q*_p.h +cd private +rm -f q*_p.h +ln -s ../../src/*/tq*_p.h . + diff --git a/tqtinterface/qt4/mkspecs/hurd-g++/qmake.conf b/tqtinterface/qt4/mkspecs/hurd-g++/qmake.conf index 6c43133..5744d6a 100644 --- a/tqtinterface/qt4/mkspecs/hurd-g++/qmake.conf +++ b/tqtinterface/qt4/mkspecs/hurd-g++/qmake.conf @@ -15,7 +15,7 @@ TQMAKE_LEX = flex TQMAKE_LEXFLAGS = TQMAKE_YACC = yacc TQMAKE_YACCFLAGS = -d -TQMAKE_CFLAGS = +TQMAKE_CFLAGS = -pipe TQMAKE_CFLAGS_DEPS = -M TQMAKE_CFLAGS_WARN_ON = -Wall -W TQMAKE_CFLAGS_WARN_OFF = -w @@ -23,6 +23,7 @@ TQMAKE_CFLAGS_RELEASE = -O2 TQMAKE_CFLAGS_DEBUG = -g TQMAKE_CFLAGS_SHLIB = -fPIC TQMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses +TQMAKE_CFLAGS_THREAD = -D_REENTRANT TQMAKE_CXX = g++ TQMAKE_CXXFLAGS = $$TQMAKE_CFLAGS @@ -33,6 +34,7 @@ TQMAKE_CXXFLAGS_RELEASE = $$TQMAKE_CFLAGS_RELEASE TQMAKE_CXXFLAGS_DEBUG = $$TQMAKE_CFLAGS_DEBUG TQMAKE_CXXFLAGS_SHLIB = $$TQMAKE_CFLAGS_SHLIB TQMAKE_CXXFLAGS_YACC = $$TQMAKE_CFLAGS_YACC +TQMAKE_CXXFLAGS_THREAD = $$TQMAKE_CFLAGS_THREAD TQMAKE_INCDIR = TQMAKE_LIBDIR = @@ -51,14 +53,19 @@ TQMAKE_LFLAGS_DEBUG = TQMAKE_LFLAGS_SHLIB = -shared TQMAKE_LFLAGS_PLUGIN = $$TQMAKE_LFLAGS_SHLIB TQMAKE_LFLAGS_SONAME = -Wl,-soname, +TQMAKE_LFLAGS_THREAD = -TQMAKE_LIBS = +# The following trick (TQMAKE_LIBS{,_THREAD}) is needed at the moment +TQMAKE_LIBS = -lpthread TQMAKE_LIBS_DYNLOAD = -ldl TQMAKE_LIBS_X11 = -lXext -lX11 -lm +TQMAKE_LIBS_X11SM = -lSM -lICE +TQMAKE_LIBS_NIS = -lnsl TQMAKE_LIBS_QT = -lqt - +TQMAKE_LIBS_TQT_THREAD = -lqt-mt TQMAKE_LIBS_OPENGL = -lGLU -lGL -lXmu TQMAKE_LIBS_OPENGL_QT = -lGL -lXmu +TQMAKE_LIBS_THREAD = TQMAKE_TQMOC = $(TQTDIR)/bin/tqmoc TQMAKE_UIC = $(TQTDIR)/bin/uic diff --git a/tqtinterface/qt4/mkspecs/linux-g++-sparc/qmake.conf b/tqtinterface/qt4/mkspecs/linux-g++-sparc/qmake.conf new file mode 100644 index 0000000..0ce5f93 --- /dev/null +++ b/tqtinterface/qt4/mkspecs/linux-g++-sparc/qmake.conf @@ -0,0 +1,89 @@ +# +# +# qmake configuration for linux-g++ +# + +MAKEFILE_GENERATOR = UNIX +TEMPLATE = app +CONFIG += qt warn_on release incremental link_prl thread +TQMAKE_INCREMENTAL_STYLE = sublib + +TQMAKE_CC = gcc +TQMAKE_LEX = flex +TQMAKE_LEXFLAGS = +TQMAKE_YACC = yacc +TQMAKE_YACCFLAGS = -d +TQMAKE_YACCFLAGS_MANGLE = -p $base -b $base +TQMAKE_YACC_HEADER = $base.tab.h +TQMAKE_YACC_SOURCE = $base.tab.c +TQMAKE_CFLAGS = -pipe -g +TQMAKE_CFLAGS_DEPS = -M +TQMAKE_CFLAGS_WARN_ON = -Wall -W +TQMAKE_CFLAGS_WARN_OFF = -w +TQMAKE_CFLAGS_RELEASE = -O1 +TQMAKE_CFLAGS_DEBUG = -O0 +TQMAKE_CFLAGS_SHLIB = -fPIC +TQMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses +TQMAKE_CFLAGS_THREAD = -D_REENTRANT + +TQMAKE_CXX = g++ +TQMAKE_CXXFLAGS = $$TQMAKE_CFLAGS +TQMAKE_CXXFLAGS_DEPS = $$TQMAKE_CFLAGS_DEPS +TQMAKE_CXXFLAGS_WARN_ON = $$TQMAKE_CFLAGS_WARN_ON +TQMAKE_CXXFLAGS_WARN_OFF = $$TQMAKE_CFLAGS_WARN_OFF +TQMAKE_CXXFLAGS_RELEASE = $$TQMAKE_CFLAGS_RELEASE +TQMAKE_CXXFLAGS_DEBUG = $$TQMAKE_CFLAGS_DEBUG +TQMAKE_CXXFLAGS_SHLIB = $$TQMAKE_CFLAGS_SHLIB +TQMAKE_CXXFLAGS_YACC = $$TQMAKE_CFLAGS_YACC +TQMAKE_CXXFLAGS_THREAD = $$TQMAKE_CFLAGS_THREAD + +TQMAKE_INCDIR = +TQMAKE_LIBDIR = +TQMAKE_INCDIR_X11 = /usr/X11R6/include +TQMAKE_LIBDIR_X11 = /usr/X11R6/lib +TQMAKE_INCDIR_QT = $(TQTDIR)/include +TQMAKE_LIBDIR_QT = $(TQTDIR)/lib +TQMAKE_INCDIR_OPENGL = /usr/X11R6/include +TQMAKE_LIBDIR_OPENGL = /usr/X11R6/lib + +TQMAKE_LINK = g++ +TQMAKE_LINK_SHLIB = g++ +TQMAKE_LFLAGS = +TQMAKE_LFLAGS_RELEASE = +TQMAKE_LFLAGS_DEBUG = +TQMAKE_LFLAGS_SHLIB = -shared +TQMAKE_LFLAGS_PLUGIN = $$TQMAKE_LFLAGS_SHLIB +TQMAKE_LFLAGS_SONAME = -Wl,-soname, +TQMAKE_LFLAGS_THREAD = +TQMAKE_RPATH = + +TQMAKE_LIBS = +TQMAKE_LIBS_DYNLOAD = -ldl +TQMAKE_LIBS_X11 = -lXext -lX11 -lm +TQMAKE_LIBS_X11SM = -lSM -lICE +TQMAKE_LIBS_NIS = -lnsl +TQMAKE_LIBS_QT = -lqt +TQMAKE_LIBS_TQT_THREAD = -lqt-mt +TQMAKE_LIBS_OPENGL = -lGLU -lGL -lXmu +TQMAKE_LIBS_OPENGL_QT = -lGL -lXmu +TQMAKE_LIBS_THREAD = -lpthread + +TQMAKE_TQMOC = $(TQTDIR)/bin/tqmoc +TQMAKE_UIC = $(TQTDIR)/bin/uic + +TQMAKE_AR = ar cqs +TQMAKE_RANLIB = + +TQMAKE_TAR = tar -cf +TQMAKE_GZIP = gzip -9f + +TQMAKE_COPY = cp -f +TQMAKE_COPY_FILE = $(COPY) +TQMAKE_COPY_DIR = $(COPY) -r +TQMAKE_MOVE = mv -f +TQMAKE_DEL_FILE = rm -f +TQMAKE_DEL_DIR = rmdir +TQMAKE_STRIP = +TQMAKE_STRIPFLAGS_LIB += --strip-unneeded +TQMAKE_CHK_DIR_EXISTS = test -d +TQMAKE_MKDIR = mkdir -p diff --git a/tqtinterface/qt4/mkspecs/linux-g++-sparc/qplatformdefs.h b/tqtinterface/qt4/mkspecs/linux-g++-sparc/qplatformdefs.h new file mode 100644 index 0000000..c6212e7 --- /dev/null +++ b/tqtinterface/qt4/mkspecs/linux-g++-sparc/qplatformdefs.h @@ -0,0 +1,107 @@ +#ifndef TQPLATFORMDEFS_H +#define TQPLATFORMDEFS_H + +// Get TQt defines/settings + +#include "tqglobal.h" + +// Set any POSIX/XOPEN defines at the top of this file to turn on specific APIs + +// DNS system header files are a mess! +// includes . is using +// 'u_char' and includes . Now the problem is that +// defines 'u_char' only if __USE_BSD is defined. +// __USE_BSD is defined in if _BSD_SOURCE is defined. +#ifndef _BSD_SOURCE +# define _BSD_SOURCE +#endif + +// 1) need to reset default environment if _BSD_SOURCE is defined +// 2) need to specify POSIX thread interfaces explicitly in glibc 2.0 +// 3) it seems older glibc need this to include the X/Open stuff +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif + +#include + + +// We are hot - unistd.h should have turned on the specific APIs we requested + + +#ifdef TQT_THREAD_SUPPORT +#include +#endif + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +// DNS header files are not fully covered by X/Open specifications. +// In particular nothing is said about res_* :/ +// Header files and are not included +// by on older versions of the GNU C library. Note that +// must be included before . +#include +#include +#include + + +#if !defined(TQT_NO_COMPAT) +#define TQT_STATBUF struct stat +#define TQT_STATBUF4TSTAT struct stat +#define TQT_STAT ::stat +#define TQT_FSTAT ::fstat +#define TQT_STAT_REG S_IFREG +#define TQT_STAT_DIR S_IFDIR +#define TQT_STAT_MASK S_IFMT +#define TQT_STAT_LNK S_IFLNK +#define TQT_FILENO fileno +#define TQT_OPEN ::open +#define TQT_CLOSE ::close +#define TQT_LSEEK ::lseek +#define TQT_READ ::read +#define TQT_WRITE ::write +#define TQT_ACCESS ::access +#define TQT_GETCWD ::getcwd +#define TQT_CHDIR ::chdir +#define TQT_MKDIR ::mkdir +#define TQT_RMDIR ::rmdir +#define TQT_OPEN_RDONLY O_RDONLY +#define TQT_OPEN_WRONLY O_WRONLY +#define TQT_OPEN_RDWR O_RDWR +#define TQT_OPEN_CREAT O_CREAT +#define TQT_OPEN_TRUNC O_TRUNC +#define TQT_OPEN_APPEND O_APPEND +#endif + +#define TQT_SIGNAL_RETTYPE void +#define TQT_SIGNAL_ARGS int +#define TQT_SIGNAL_IGNORE SIG_IGN + +#if defined(__GLIBC__) && (__GLIBC__ >= 2) +#define TQT_SOCKLEN_T socklen_t +#else +#define TQT_SOCKLEN_T int +#endif + +#if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE >= 500) +#define TQT_SNPRINTF ::snprintf +#define TQT_VSNPRINTF ::vsnprintf +#endif + +#define TQT_MITSHM + +#endif // TQPLATFORMDEFS_H diff --git a/tqtinterface/qt4/mkspecs/linux-g++/qmake.conf b/tqtinterface/qt4/mkspecs/linux-g++/qmake.conf index dfd63a5..2ce3d73 100644 --- a/tqtinterface/qt4/mkspecs/linux-g++/qmake.conf +++ b/tqtinterface/qt4/mkspecs/linux-g++/qmake.conf @@ -5,7 +5,7 @@ MAKEFILE_GENERATOR = UNIX TEMPLATE = app -CONFIG += qt warn_on release incremental link_prl +CONFIG += qt warn_on release incremental link_prl thread TQMAKE_INCREMENTAL_STYLE = sublib TQMAKE_CC = gcc diff --git a/tqtinterface/qt4/mkspecs/linux-g++/tqplatformdefs.h b/tqtinterface/qt4/mkspecs/linux-g++/tqplatformdefs.h index 1732994..c6212e7 100644 --- a/tqtinterface/qt4/mkspecs/linux-g++/tqplatformdefs.h +++ b/tqtinterface/qt4/mkspecs/linux-g++/tqplatformdefs.h @@ -102,5 +102,6 @@ #define TQT_VSNPRINTF ::vsnprintf #endif +#define TQT_MITSHM #endif // TQPLATFORMDEFS_H diff --git a/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/imsw-multi.pro b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/imsw-multi.pro new file mode 100644 index 0000000..a333916 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/imsw-multi.pro @@ -0,0 +1,14 @@ +TEMPLATE = lib +TARGET = qimsw-multi +DESTDIR = ../../../inputmethods + +INCLUDEPATH += . +CONFIG += qt warn_on debug plugin +target.path += $$plugins.path/inputmethods +INSTALLS += target + +# Input +HEADERS += qmultiinputcontext.h \ + qmultiinputcontextplugin.h +SOURCES += qmultiinputcontext.cpp \ + qmultiinputcontextplugin.cpp diff --git a/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.cpp b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.cpp new file mode 100644 index 0000000..a3caede --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.cpp @@ -0,0 +1,379 @@ +/**************************************************************************** +** $Id$ +** +** Implementation of TQMultiInputContext class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQT_NO_IM +#include "tqmultiinputcontext.h" +#include +#include +#include +#ifndef TQT_NO_IM_EXTENSIONS +#include +#endif + +#include + +#define TQT_NO_IM_TQMULTIINPUTCONTEXT_IMINDEX + +TQMultiInputContext::TQMultiInputContext() + : TQInputContext(), _slave( 0 ), imIndex( 0 ), cachedFocus( FALSE ), + cachedFocusWidget( 0 ), cachedHolderWidget( 0 ), + beIndirectlyConnected( FALSE ), popup( NULL ), currentIMKey( TQString() ) +{ + keyDict.setAutoDelete( true ); + keyDict.clear(); + + if ( getenv( "TQT_IM_MODULE" ) ) { + currentIMKey = getenv( "TQT_IM_MODULE" ); + } else { +#ifndef TQT_NO_IM_EXTENSIONS + TQSettings settings; + currentIMKey = settings.readEntry( "/qt/DefaultInputMethod", "xim" ); +#else + currentIMKey = "xim"; +#endif + } +} + +TQMultiInputContext::~TQMultiInputContext() +{ + keyDict.clear(); +} + + +TQString TQMultiInputContext::identifierName() +{ + return ( slave() ) ? slave()->identifierName() : ""; +} + +TQString TQMultiInputContext::language() +{ + return ( slave() ) ? slave()->language() : ""; +} + + +#if defined(TQ_WS_X11) +bool TQMultiInputContext::x11FilterEvent( TQWidget *keywidget, XEvent *event ) +{ + return ( slave() ) ? slave()->x11FilterEvent( keywidget, event ) : FALSE; +} +#endif // TQ_WS_X11 + + +bool TQMultiInputContext::filterEvent( const TQEvent *event ) +{ +#if !defined(TQT_NO_IM_TQMULTIINPUTCONTEXT_IMINDEX) + if ( event->type() == TQEvent::KeyPress ) { + TQKeyEvent *keyevent = (TQKeyEvent *)event; + + // filter selection key + // Control+Alt+Key_Down: change to next input method + // Control+Alt+Key_Up: change to previous input method + if ( ( keyevent->state() & TQt::ControlButton ) && + ( keyevent->state() & TQt::AltButton ) ) { + if ( keyevent->key() == TQt::Key_Up ) { + changeInputMethod( --imIndex ); + return TRUE; + } else if ( keyevent->key() == TQt::Key_Down ) { + changeInputMethod( ++imIndex ); + return TRUE; + } + } + } +#endif + + return ( slave() ) ? slave()->filterEvent( event ) : FALSE; +} + +void TQMultiInputContext::reset() +{ + if ( slave() ) + slave()->reset(); +} + + +void TQMultiInputContext::setFocus() +{ + cachedFocus = TRUE; + if ( slave() ) + slave()->setFocus(); +} + +void TQMultiInputContext::unsetFocus() +{ + cachedFocus = FALSE; + if ( slave() ) + slave()->unsetFocus(); +} + +void TQMultiInputContext::setMicroFocus( int x, int y, int w, int h, TQFont *f ) +{ + if ( slave() ) + slave()->setMicroFocus( x, y, w, h, f ); +} + +void TQMultiInputContext::mouseHandler( int x, TQEvent::Type type, + TQt::ButtonState button, + TQt::ButtonState state ) +{ + if ( slave() ) + slave()->mouseHandler( x, type, button, state ); +} + +TQFont TQMultiInputContext::font() const +{ + return ( slave() ) ? slave()->font() : TQInputContext::font(); +} + +void TQMultiInputContext::destroyInputContext() +{ + if ( _slave ) { + // _slave->reset() may not properly work in the case, so we + // manually resets the composing state of text widget + if ( _slave->tqfocusWidget() ) { + TQIMEvent *terminator = new TQIMEvent( TQEvent::IMEnd, TQString(), -1 ); + emit imEventGenerated( _slave->tqfocusWidget(), terminator ); + } + _slave->deleteLater(); + _slave = 0; + } +} + + +/*! + This function is a placeholder for future experiment or extension + such as commit string snooping. set beIndirectlyConnected = TRUE + to activate this virtual function. +*/ +void TQMultiInputContext::postIMEvent( TQObject *receiver, TQIMEvent *event ) +{ + emit imEventGenerated( receiver, event ); +} + + +#if defined(TQ_WS_X11) +TQWidget *TQMultiInputContext::tqfocusWidget() const +{ + return ( slave() ) ? slave()->tqfocusWidget() : 0; +} + +TQWidget *TQMultiInputContext::holderWidget() const +{ + return ( slave() ) ? slave()->holderWidget() : 0; +} + + +void TQMultiInputContext::setFocusWidget( TQWidget *w ) +{ + cachedFocusWidget = w; + if ( slave() ) + slave()->setFocusWidget( w ); +} + +void TQMultiInputContext::setHolderWidget( TQWidget *w ) +{ + cachedHolderWidget = w; + if ( slave() ) + slave()->setHolderWidget( w ); +} + +void TQMultiInputContext::releaseComposingWidget( TQWidget *w ) +{ + if ( slave() ) + slave()->releaseComposingWidget( w ); +} + +#endif + +bool TQMultiInputContext::isComposing() const +{ + return ( slave() ) ? slave()->isComposing() : FALSE; +} + +bool TQMultiInputContext::isPreeditRelocationEnabled() +{ + return ( slave() ) ? slave()->isPreeditRelocationEnabled() : FALSE; +} + +TQInputContext *TQMultiInputContext::slave() +{ + if ( ! _slave ) { +#if !defined(TQT_NO_IM_TQMULTIINPUTCONTEXT_IMINDEX) + changeInputMethod( imIndex ); +#else + changeInputMethod( currentIMKey ); +#endif + } + + return _slave; +} + +const TQInputContext *TQMultiInputContext::slave() const +{ + return _slave; +} + +void TQMultiInputContext::changeInputMethod( int newIndex ) +{ +#if !defined(TQT_NO_IM_TQMULTIINPUTCONTEXT_IMINDEX) + TQStringList keys = TQInputContextFactory::keys(); + if ( keys.size() == 0 ) + return; + + if ( newIndex >= (int)keys.size() ) { + imIndex = 0; + } else if ( newIndex < 0 ) { + imIndex = keys.size() - 1; + } else { + imIndex = newIndex; + } + + changeInputMethod( keys[imIndex] ); +#endif +} + +void TQMultiInputContext::changeInputMethod( TQString key ) +{ + TQStringList keys = TQInputContextFactory::keys(); + if ( keys.size() == 0 ) + return; + + if ( key.isEmpty() ) + key = keys[0]; + + if ( _slave ) { + _slave->reset(); + delete _slave; + } + + _slave = TQInputContextFactory::create( key, cachedHolderWidget ); + if ( _slave ) { + insertChild( _slave ); + + const char *method; + if ( beIndirectlyConnected ) { + method = TQT_SLOT(imEventReceived(TQObject *,TQIMEvent *)); + } else { + method = TQT_SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)); + } + connect( _slave, TQT_SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)), + this, method ); + connect( _slave, TQT_SIGNAL(deletionRequested()), + this, TQT_SLOT(destroyInputContext()) ); + + if ( cachedFocus ) { + _slave->setFocus(); + _slave->setFocusWidget( cachedFocusWidget ); + } + + currentIMKey = key; + + //qDebug( "TQMultiInputContext::changeInputMethod(): index=%d, slave=%s", + // imIndex, (const char *)_slave->identifierName() ); + } +} + +TQPtrList *TQMultiInputContext::menus() +{ + TQInputContextMenu *imSelMenu = new TQInputContextMenu; + imSelMenu->title = tr( "Select Input &Method" ); + imSelMenu->popup = createImSelPopup(); + + TQPtrList *result = new TQPtrList; + result->append( imSelMenu ); + + TQPtrList *slaveMenus = ( slave() ) ? slave()->menus() : 0; + if ( slaveMenus ) { + for ( TQPtrList::Iterator it = slaveMenus->begin(); + it != slaveMenus->end(); + ++it ) { + TQInputContextMenu *slaveMenu = *it; + result->append( slaveMenu ); + } + delete slaveMenus; + } + + return result; +} + +TQPopupMenu *TQMultiInputContext::createImSelPopup() +{ + if ( popup ) + delete popup; + + popup = new TQPopupMenu(); + keyDict.clear(); + + TQStringList keys = TQInputContextFactory::keys(); + for ( uint i=0; i < keys.size(); i++ ) { + TQString idName = keys[i]; + bool isIMSwitcher = idName.startsWith( "imsw-" ); + + if ( ! isIMSwitcher ) { + TQString dispName = TQInputContextFactory::displayName( idName ); + if ( dispName.isEmpty() ) + dispName = idName; + + int id = popup->insertItem( dispName ); + keyDict.insert( (long)id, new TQString( idName ) ); + + if ( idName == currentIMKey ) + popup->setItemChecked( id, true ); + + TQString descriptionStr = TQInputContextFactory::description( idName ); + if ( ! descriptionStr.isEmpty() ) + popup->setWhatsThis( id, descriptionStr ); + } + } + + TQObject::connect( popup, TQT_SIGNAL(activated(int)), + this, TQT_SLOT(changeInputMethodWithMenuId(int)) ); + + return popup; +} + +void TQMultiInputContext::changeInputMethodWithMenuId( int menuid ) +{ + TQString *key = keyDict.tqfind( (long)menuid ); + changeInputMethod( (*key) ); +} + +#endif diff --git a/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.h b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.h new file mode 100644 index 0000000..c18a2c7 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontext.h @@ -0,0 +1,124 @@ +/**************************************************************************** +** $Id$ +** +** Definition of TQMultiInputContext class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQMULTIINPUTCONTEXT_H +#define TQMULTIINPUTCONTEXT_H + +#ifndef TQT_NO_IM + +#include +#include +#include +#include +#include + +class TQPopupMenu; + +class TQMultiInputContext : public TQInputContext +{ + TQ_OBJECT +public: + TQMultiInputContext(); + ~TQMultiInputContext(); + + TQString identifierName(); + TQString language(); + +#if defined(TQ_WS_X11) + bool x11FilterEvent( TQWidget *keywidget, XEvent *event ); +#endif // TQ_WS_X11 + bool filterEvent( const TQEvent *event ); + void reset(); + + void setFocus(); + void unsetFocus(); + void setMicroFocus( int x, int y, int w, int h, TQFont *f = 0 ); + void mouseHandler( int x, TQEvent::Type type, + TQt::ButtonState button, TQt::ButtonState state ); + TQFont font() const; + bool isComposing() const; + bool isPreeditRelocationEnabled(); + +#if ([[[TQT_VERSION IS DEPRECATED]]]-0 >= 0x040000) + TQPtrList *qt4menus(); +#endif + TQPtrList *menus(); + TQPopupMenu *createImSelPopup(); + +#if defined(TQ_WS_X11) + TQWidget *tqfocusWidget() const; + TQWidget *holderWidget() const; + + void setFocusWidget( TQWidget *w ); + void setHolderWidget( TQWidget *w ); + void releaseComposingWidget( TQWidget *w ); +#endif + +public slots: + virtual void destroyInputContext(); + virtual void postIMEvent( TQObject *receiver, TQIMEvent *event ); + +protected slots: + void changeInputMethodWithMenuId( int menuid ); + +protected: + TQInputContext *slave(); + const TQInputContext *slave() const; + + void changeInputMethod( int newIndex ); + void changeInputMethod( TQString name ); + + TQInputContext *_slave; + int imIndex; + bool cachedFocus; + TQWidget *cachedFocusWidget; + TQWidget *cachedHolderWidget; + bool beIndirectlyConnected; + + TQIntDict keyDict; + TQGuardedPtr popup; + TQString currentIMKey; +}; + +#endif //TQ_NO_IM + +#endif // TQMULTIINPUTCONTEXT_H diff --git a/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.cpp b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.cpp new file mode 100644 index 0000000..1a64459 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.cpp @@ -0,0 +1,88 @@ +/**************************************************************************** +** $Id$ +** +** Implementation of TQMultiInputContextPlugin class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQT_NO_IM +#include "tqmultiinputcontext.h" +#include "tqmultiinputcontextplugin.h" +#include +#include + + +TQMultiInputContextPlugin::TQMultiInputContextPlugin() +{ +} + +TQMultiInputContextPlugin::~TQMultiInputContextPlugin() +{ +} + +TQStringList TQMultiInputContextPlugin::keys() const +{ + // input method switcher should named with "imsw-" prefix to + // prevent to be listed in ordinary input method list. + return TQStringList( "imsw-multi" ); +} + +TQInputContext *TQMultiInputContextPlugin::create( const TQString &key ) +{ + return new TQMultiInputContext; +} + +TQStringList TQMultiInputContextPlugin::languages( const TQString &key ) +{ + return TQStringList( "" ); +} + +TQString TQMultiInputContextPlugin::displayName( const TQString &key ) +{ + return tr( "Multiple Input Method Switcher" ); +} + +TQString TQMultiInputContextPlugin::description( const TQString &key ) +{ + return tr( "Multiple input method switcher that uses the context menu of the text widgets" ); +} + + +TQ_EXPORT_PLUGIN( TQMultiInputContextPlugin ) + +#endif diff --git a/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.h b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.h new file mode 100644 index 0000000..5c5d09f --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/imsw-multi/tqmultiinputcontextplugin.h @@ -0,0 +1,63 @@ +/**************************************************************************** +** $Id$ +** +** Definition of TQMultiInputContextPlugin class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQT_NO_IM +#include "tqmultiinputcontext.h" +#include +#include + + +class TQMultiInputContextPlugin : public TQInputContextPlugin +{ + TQ_OBJECT +public: + TQMultiInputContextPlugin(); + ~TQMultiInputContextPlugin(); + + TQStringList keys() const; + TQInputContext *create( const TQString &key ); + TQStringList languages( const TQString &key ); + TQString displayName( const TQString &key ); + TQString description( const TQString &key ); +}; + +#endif diff --git a/tqtinterface/qt4/plugins/src/inputmethods/imsw-none/imsw-none.pro b/tqtinterface/qt4/plugins/src/inputmethods/imsw-none/imsw-none.pro new file mode 100644 index 0000000..0671e96 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/imsw-none/imsw-none.pro @@ -0,0 +1,12 @@ +TEMPLATE = lib +TARGET = qimsw-none +DESTDIR = ../../../inputmethods + +INCLUDEPATH += . +CONFIG += qt warn_on debug plugin +target.path += $$plugins.path/inputmethods +INSTALLS += target + +# Input +HEADERS += qnoneinputcontextplugin.h +SOURCES += qnoneinputcontextplugin.cpp diff --git a/tqtinterface/qt4/plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.cpp b/tqtinterface/qt4/plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.cpp new file mode 100644 index 0000000..a3b3b0d --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.cpp @@ -0,0 +1,101 @@ +/**************************************************************************** +** $Id$ +** +** Implementation of TQNoneInputContextPlugin class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQT_NO_IM +#include "tqnoneinputcontextplugin.h" +#include +#include +#include + + +TQNoneInputContextPlugin::TQNoneInputContextPlugin() +{ +} + +TQNoneInputContextPlugin::~TQNoneInputContextPlugin() +{ +} + +TQStringList TQNoneInputContextPlugin::keys() const +{ + // input method switcher should named with "imsw-" prefix to + // prevent to be listed in ordinary input method list. + return TQStringList( "imsw-none" ); +} + +TQInputContext *TQNoneInputContextPlugin::create( const TQString &key ) +{ + TQString actuallySpecifiedKey; + + bool isIMSwitcher = key.startsWith( "imsw-" ); + if ( ! isIMSwitcher ) + return 0; + + if ( getenv( "TQT_IM_MODULE" ) ) { + actuallySpecifiedKey = getenv( "TQT_IM_MODULE" ); + } else { + TQSettings settings; + actuallySpecifiedKey = settings.readEntry( "/qt/DefaultInputMethod", "xim" ); + } + + return TQInputContextFactory::create( actuallySpecifiedKey, 0 ); +} + +TQStringList TQNoneInputContextPlugin::languages( const TQString &key ) +{ + return TQStringList( "" ); +} + +TQString TQNoneInputContextPlugin::displayName( const TQString &key ) +{ + return tr( "Dummy Input Method Switcher" ); +} + +TQString TQNoneInputContextPlugin::description( const TQString &key ) +{ + return tr( "Dummy input method switcher that uses the context menu of the text widgets" ); +} + + +TQ_EXPORT_PLUGIN( TQNoneInputContextPlugin ) + +#endif diff --git a/tqtinterface/qt4/plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.h b/tqtinterface/qt4/plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.h new file mode 100644 index 0000000..a85ada3 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/imsw-none/tqnoneinputcontextplugin.h @@ -0,0 +1,62 @@ +/**************************************************************************** +** $Id$ +** +** Definition of TQNoneInputContextPlugin class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQT_NO_IM +#include +#include + + +class TQNoneInputContextPlugin : public TQInputContextPlugin +{ + TQ_OBJECT +public: + TQNoneInputContextPlugin(); + ~TQNoneInputContextPlugin(); + + TQStringList keys() const; + TQInputContext *create( const TQString &key ); + TQStringList languages( const TQString &key ); + TQString displayName( const TQString &key ); + TQString description( const TQString &key ); +}; + +#endif diff --git a/tqtinterface/qt4/plugins/src/inputmethods/inputmethods.pro b/tqtinterface/qt4/plugins/src/inputmethods/inputmethods.pro new file mode 100644 index 0000000..df31467 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/inputmethods.pro @@ -0,0 +1,11 @@ +TEMPLATE = subdirs + +unix { + !embedded:!mac:CONFIG += x11 +} +# XIM should be enabled only for X11 platform, but following +# configuration is not working properly yet +#im:x11:SUBDIRS += xim + +inputmethod:SUBDIRS += imsw-none imsw-multi simple +inputmethod:SUBDIRS += xim diff --git a/tqtinterface/qt4/plugins/src/inputmethods/simple/composetable.cpp b/tqtinterface/qt4/plugins/src/inputmethods/simple/composetable.cpp new file mode 100644 index 0000000..070d2a4 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/simple/composetable.cpp @@ -0,0 +1,5605 @@ +/**************************************************************************** +** $Id$ +** +** Compose table for TQSimpleInputContext class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +// The compose table included in file is converted from a Compose file +// of X.org's X11R6.7.0. Original header is follows + +// UTF-8 (Unicode) compose sequence +// David.Monniaux@ens.fr +// +// $XFree86: xc/nls/Compose/en_US.UTF-8,v 1.11 2004/01/06 13:14:04 pascal Exp $ + + +#include "tqsimpleinputcontext.h" + +#include + +static const TQComposeTableElement defaultTable[] = { +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE +// /* broken */ { {0x0000, 0x0000, 0, 0, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE +// /* broken */ { {0x0000, 0x0000, 0x004f, 0, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {0x0000, 0x0000, 0x0055, 0, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {0x0000, 0x0000, 0x006f, 0, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {0x0000, 0x0000, 0x0075, 0, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {0x0000, 0x0041, 0, 0, 0, 0}, 0x00c1 }, // U00C1 # LATIN CAPITAL LETTER A WITH ACUTE +// /* broken */ { {0x0000, 0x0041, 0, 0, 0, 0}, 0x00c0 }, // U00C0 # LATIN CAPITAL LETTER A WITH GRAVE +// /* broken */ { {0x0000, 0x0041, 0, 0, 0, 0}, 0x00c3 }, // U00C3 # LATIN CAPITAL LETTER A WITH TILDE +// /* broken */ { {0x0000, 0x0041, 0, 0, 0, 0}, 0x1ea2 }, // U1EA2 # LATIN CAPITAL LETTER A WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0041, 0, 0, 0, 0}, 0x1ea0 }, // U1EA0 # LATIN CAPITAL LETTER A WITH DOT BELOW +// /* broken */ { {0x0000, 0x0042, 0, 0, 0, 0}, 0x1e04 }, // U1E04 # LATIN CAPITAL LETTER B WITH DOT BELOW +// /* broken */ { {0x0000, 0x0043, 0, 0, 0, 0}, 0x0106 }, // U0106 # LATIN CAPITAL LETTER C WITH ACUTE +// /* broken */ { {0x0000, 0x0044, 0, 0, 0, 0}, 0x1e0c }, // U1E0C # LATIN CAPITAL LETTER D WITH DOT BELOW +// /* broken */ { {0x0000, 0x0045, 0, 0, 0, 0}, 0x1ebc }, // U1EBC # LATIN CAPITAL LETTER E WITH TILDE +// /* broken */ { {0x0000, 0x0045, 0, 0, 0, 0}, 0x1eb8 }, // U1EB8 # LATIN CAPITAL LETTER E WITH DOT BELOW +// /* broken */ { {0x0000, 0x0045, 0, 0, 0, 0}, 0x00c9 }, // U00C9 # LATIN CAPITAL LETTER E WITH ACUTE +// /* broken */ { {0x0000, 0x0045, 0, 0, 0, 0}, 0x00c8 }, // U00C8 # LATIN CAPITAL LETTER E WITH GRAVE +// /* broken */ { {0x0000, 0x0045, 0, 0, 0, 0}, 0x1eba }, // U1EBA # LATIN CAPITAL LETTER E WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0047, 0, 0, 0, 0}, 0x01f4 }, // U01F4 # LATIN CAPITAL LETTER G WITH ACUTE +// /* broken */ { {0x0000, 0x0048, 0, 0, 0, 0}, 0x1e24 }, // U1E24 # LATIN CAPITAL LETTER H WITH DOT BELOW +// /* broken */ { {0x0000, 0x0049, 0, 0, 0, 0}, 0x00cd }, // U00CD # LATIN CAPITAL LETTER I WITH ACUTE +// /* broken */ { {0x0000, 0x0049, 0, 0, 0, 0}, 0x00cc }, // U00CC # LATIN CAPITAL LETTER I WITH GRAVE +// /* broken */ { {0x0000, 0x0049, 0, 0, 0, 0}, 0x1ec8 }, // U1EC8 # LATIN CAPITAL LETTER I WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0049, 0, 0, 0, 0}, 0x0128 }, // U0128 # LATIN CAPITAL LETTER I WITH TILDE +// /* broken */ { {0x0000, 0x0049, 0, 0, 0, 0}, 0x1eca }, // U1ECA # LATIN CAPITAL LETTER I WITH DOT BELOW +// /* broken */ { {0x0000, 0x004b, 0, 0, 0, 0}, 0x1e30 }, // U1E30 # LATIN CAPITAL LETTER K WITH ACUTE +// /* broken */ { {0x0000, 0x004b, 0, 0, 0, 0}, 0x1e32 }, // U1E32 # LATIN CAPITAL LETTER K WITH DOT BELOW +// /* broken */ { {0x0000, 0x004c, 0, 0, 0, 0}, 0x0139 }, // U0139 # LATIN CAPITAL LETTER L WITH ACUTE +// /* broken */ { {0x0000, 0x004c, 0, 0, 0, 0}, 0x1e36 }, // U1E36 # LATIN CAPITAL LETTER L WITH DOT BELOW +// /* broken */ { {0x0000, 0x004d, 0, 0, 0, 0}, 0x1e42 }, // U1E42 # LATIN CAPITAL LETTER M WITH DOT BELOW +// /* broken */ { {0x0000, 0x004d, 0, 0, 0, 0}, 0x1e3e }, // U1E3E # LATIN CAPITAL LETTER M WITH ACUTE +// /* broken */ { {0x0000, 0x004e, 0, 0, 0, 0}, 0x1e46 }, // U1E46 # LATIN CAPITAL LETTER N WITH DOT BELOW +// /* broken */ { {0x0000, 0x004e, 0, 0, 0, 0}, 0x0143 }, // U0143 # LATIN CAPITAL LETTER N WITH ACUTE +// /* broken */ { {0x0000, 0x004e, 0, 0, 0, 0}, 0x01f8 }, // U01F8 # LATIN CAPITAL LETTER N WITH GRAVE +// /* broken */ { {0x0000, 0x004e, 0, 0, 0, 0}, 0x00d1 }, // U00D1 # LATIN CAPITAL LETTER N WITH TILDE +// /* broken */ { {0x0000, 0x004f, 0, 0, 0, 0}, 0x00d5 }, // U00D5 # LATIN CAPITAL LETTER O WITH TILDE +// /* broken */ { {0x0000, 0x004f, 0, 0, 0, 0}, 0x00d3 }, // U00D3 # LATIN CAPITAL LETTER O WITH ACUTE +// /* broken */ { {0x0000, 0x004f, 0, 0, 0, 0}, 0x1ecc }, // U1ECC # LATIN CAPITAL LETTER O WITH DOT BELOW +// /* broken */ { {0x0000, 0x004f, 0, 0, 0, 0}, 0x00d2 }, // U00D2 # LATIN CAPITAL LETTER O WITH GRAVE +// /* broken */ { {0x0000, 0x004f, 0, 0, 0, 0}, 0x1ece }, // U1ECE # LATIN CAPITAL LETTER O WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0050, 0, 0, 0, 0}, 0x1e54 }, // U1E54 # LATIN CAPITAL LETTER P WITH ACUTE +// /* broken */ { {0x0000, 0x0052, 0, 0, 0, 0}, 0x1e5a }, // U1E5A # LATIN CAPITAL LETTER R WITH DOT BELOW +// /* broken */ { {0x0000, 0x0052, 0, 0, 0, 0}, 0x0154 }, // U0154 # LATIN CAPITAL LETTER R WITH ACUTE +// /* broken */ { {0x0000, 0x0053, 0, 0, 0, 0}, 0x015a }, // U015A # LATIN CAPITAL LETTER S WITH ACUTE +// /* broken */ { {0x0000, 0x0053, 0, 0, 0, 0}, 0x1e62 }, // U1E62 # LATIN CAPITAL LETTER S WITH DOT BELOW +// /* broken */ { {0x0000, 0x0054, 0, 0, 0, 0}, 0x1e6c }, // U1E6C # LATIN CAPITAL LETTER T WITH DOT BELOW +// /* broken */ { {0x0000, 0x0055, 0, 0, 0, 0}, 0x00da }, // U00DA # LATIN CAPITAL LETTER U WITH ACUTE +// /* broken */ { {0x0000, 0x0055, 0, 0, 0, 0}, 0x00d9 }, // U00D9 # LATIN CAPITAL LETTER U WITH GRAVE +// /* broken */ { {0x0000, 0x0055, 0, 0, 0, 0}, 0x0168 }, // U0168 # LATIN CAPITAL LETTER U WITH TILDE +// /* broken */ { {0x0000, 0x0055, 0, 0, 0, 0}, 0x1ee4 }, // U1EE4 # LATIN CAPITAL LETTER U WITH DOT BELOW +// /* broken */ { {0x0000, 0x0055, 0, 0, 0, 0}, 0x1ee6 }, // U1EE6 # LATIN CAPITAL LETTER U WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0056, 0, 0, 0, 0}, 0x1e7e }, // U1E7E # LATIN CAPITAL LETTER V WITH DOT BELOW +// /* broken */ { {0x0000, 0x0056, 0, 0, 0, 0}, 0x1e7c }, // U1E7C # LATIN CAPITAL LETTER V WITH TILDE +// /* broken */ { {0x0000, 0x0057, 0, 0, 0, 0}, 0x1e82 }, // U1E82 # LATIN CAPITAL LETTER W WITH ACUTE +// /* broken */ { {0x0000, 0x0057, 0, 0, 0, 0}, 0x1e88 }, // U1E88 # LATIN CAPITAL LETTER W WITH DOT BELOW +// /* broken */ { {0x0000, 0x0057, 0, 0, 0, 0}, 0x1e80 }, // U1E80 # LATIN CAPITAL LETTER W WITH GRAVE +// /* broken */ { {0x0000, 0x0059, 0, 0, 0, 0}, 0x1ef8 }, // U1EF8 # LATIN CAPITAL LETTER Y WITH TILDE +// /* broken */ { {0x0000, 0x0059, 0, 0, 0, 0}, 0x1ef2 }, // U1EF2 # LATIN CAPITAL LETTER Y WITH GRAVE +// /* broken */ { {0x0000, 0x0059, 0, 0, 0, 0}, 0x00dd }, // U00DD # LATIN CAPITAL LETTER Y WITH ACUTE +// /* broken */ { {0x0000, 0x0059, 0, 0, 0, 0}, 0x1ef6 }, // U1EF6 # LATIN CAPITAL LETTER Y WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0059, 0, 0, 0, 0}, 0x1ef4 }, // U1EF4 # LATIN CAPITAL LETTER Y WITH DOT BELOW +// /* broken */ { {0x0000, 0x005a, 0, 0, 0, 0}, 0x0179 }, // U0179 # LATIN CAPITAL LETTER Z WITH ACUTE +// /* broken */ { {0x0000, 0x005a, 0, 0, 0, 0}, 0x1e92 }, // U1E92 # LATIN CAPITAL LETTER Z WITH DOT BELOW +// /* broken */ { {0x0000, 0x0061, 0, 0, 0, 0}, 0x1ea1 }, // U1EA1 # LATIN SMALL LETTER A WITH DOT BELOW +// /* broken */ { {0x0000, 0x0061, 0, 0, 0, 0}, 0x1ea3 }, // U1EA3 # LATIN SMALL LETTER A WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0061, 0, 0, 0, 0}, 0x00e0 }, // U00E0 # LATIN SMALL LETTER A WITH GRAVE +// /* broken */ { {0x0000, 0x0061, 0, 0, 0, 0}, 0x00e3 }, // U00E3 # LATIN SMALL LETTER A WITH TILDE +// /* broken */ { {0x0000, 0x0061, 0, 0, 0, 0}, 0x00e1 }, // U00E1 # LATIN SMALL LETTER A WITH ACUTE +// /* broken */ { {0x0000, 0x0062, 0, 0, 0, 0}, 0x1e05 }, // U1E05 # LATIN SMALL LETTER B WITH DOT BELOW +// /* broken */ { {0x0000, 0x0063, 0, 0, 0, 0}, 0x0107 }, // U0107 # LATIN SMALL LETTER C WITH ACUTE +// /* broken */ { {0x0000, 0x0064, 0, 0, 0, 0}, 0x1e0d }, // U1E0D # LATIN SMALL LETTER D WITH DOT BELOW +// /* broken */ { {0x0000, 0x0065, 0, 0, 0, 0}, 0x00e8 }, // U00E8 # LATIN SMALL LETTER E WITH GRAVE +// /* broken */ { {0x0000, 0x0065, 0, 0, 0, 0}, 0x1ebb }, // U1EBB # LATIN SMALL LETTER E WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0065, 0, 0, 0, 0}, 0x1eb9 }, // U1EB9 # LATIN SMALL LETTER E WITH DOT BELOW +// /* broken */ { {0x0000, 0x0065, 0, 0, 0, 0}, 0x00e9 }, // U00E9 # LATIN SMALL LETTER E WITH ACUTE +// /* broken */ { {0x0000, 0x0065, 0, 0, 0, 0}, 0x1ebd }, // U1EBD # LATIN SMALL LETTER E WITH TILDE +// /* broken */ { {0x0000, 0x0067, 0, 0, 0, 0}, 0x01f5 }, // U01F5 # LATIN SMALL LETTER G WITH ACUTE +// /* broken */ { {0x0000, 0x0068, 0, 0, 0, 0}, 0x1e25 }, // U1E25 # LATIN SMALL LETTER H WITH DOT BELOW +// /* broken */ { {0x0000, 0x0069, 0, 0, 0, 0}, 0x00ec }, // U00EC # LATIN SMALL LETTER I WITH GRAVE +// /* broken */ { {0x0000, 0x0069, 0, 0, 0, 0}, 0x0129 }, // U0129 # LATIN SMALL LETTER I WITH TILDE +// /* broken */ { {0x0000, 0x0069, 0, 0, 0, 0}, 0x1ecb }, // U1ECB # LATIN SMALL LETTER I WITH DOT BELOW +// /* broken */ { {0x0000, 0x0069, 0, 0, 0, 0}, 0x00ed }, // U00ED # LATIN SMALL LETTER I WITH ACUTE +// /* broken */ { {0x0000, 0x0069, 0, 0, 0, 0}, 0x1ec9 }, // U1EC9 # LATIN SMALL LETTER I WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x006b, 0, 0, 0, 0}, 0x1e33 }, // U1E33 # LATIN SMALL LETTER K WITH DOT BELOW +// /* broken */ { {0x0000, 0x006b, 0, 0, 0, 0}, 0x1e31 }, // U1E31 # LATIN SMALL LETTER K WITH ACUTE +// /* broken */ { {0x0000, 0x006c, 0, 0, 0, 0}, 0x1e37 }, // U1E37 # LATIN SMALL LETTER L WITH DOT BELOW +// /* broken */ { {0x0000, 0x006c, 0, 0, 0, 0}, 0x013a }, // U013A # LATIN SMALL LETTER L WITH ACUTE +// /* broken */ { {0x0000, 0x006d, 0, 0, 0, 0}, 0x1e43 }, // U1E43 # LATIN SMALL LETTER M WITH DOT BELOW +// /* broken */ { {0x0000, 0x006d, 0, 0, 0, 0}, 0x1e3f }, // U1E3F # LATIN SMALL LETTER M WITH ACUTE +// /* broken */ { {0x0000, 0x006e, 0, 0, 0, 0}, 0x00f1 }, // U00F1 # LATIN SMALL LETTER N WITH TILDE +// /* broken */ { {0x0000, 0x006e, 0, 0, 0, 0}, 0x0144 }, // U0144 # LATIN SMALL LETTER N WITH ACUTE +// /* broken */ { {0x0000, 0x006e, 0, 0, 0, 0}, 0x01f9 }, // U01F9 # LATIN SMALL LETTER N WITH GRAVE +// /* broken */ { {0x0000, 0x006e, 0, 0, 0, 0}, 0x1e47 }, // U1E47 # LATIN SMALL LETTER N WITH DOT BELOW +// /* broken */ { {0x0000, 0x006f, 0, 0, 0, 0}, 0x00f5 }, // U00F5 # LATIN SMALL LETTER O WITH TILDE +// /* broken */ { {0x0000, 0x006f, 0, 0, 0, 0}, 0x00f2 }, // U00F2 # LATIN SMALL LETTER O WITH GRAVE +// /* broken */ { {0x0000, 0x006f, 0, 0, 0, 0}, 0x1ecf }, // U1ECF # LATIN SMALL LETTER O WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x006f, 0, 0, 0, 0}, 0x00f3 }, // U00F3 # LATIN SMALL LETTER O WITH ACUTE +// /* broken */ { {0x0000, 0x006f, 0, 0, 0, 0}, 0x1ecd }, // U1ECD # LATIN SMALL LETTER O WITH DOT BELOW +// /* broken */ { {0x0000, 0x0070, 0, 0, 0, 0}, 0x1e55 }, // U1E55 # LATIN SMALL LETTER P WITH ACUTE +// /* broken */ { {0x0000, 0x0072, 0, 0, 0, 0}, 0x0155 }, // U0155 # LATIN SMALL LETTER R WITH ACUTE +// /* broken */ { {0x0000, 0x0072, 0, 0, 0, 0}, 0x1e5b }, // U1E5B # LATIN SMALL LETTER R WITH DOT BELOW +// /* broken */ { {0x0000, 0x0073, 0, 0, 0, 0}, 0x1e63 }, // U1E63 # LATIN SMALL LETTER S WITH DOT BELOW +// /* broken */ { {0x0000, 0x0073, 0, 0, 0, 0}, 0x015b }, // U015B # LATIN SMALL LETTER S WITH ACUTE +// /* broken */ { {0x0000, 0x0074, 0, 0, 0, 0}, 0x1e6d }, // U1E6D # LATIN SMALL LETTER T WITH DOT BELOW +// /* broken */ { {0x0000, 0x0075, 0, 0, 0, 0}, 0x0169 }, // U0169 # LATIN SMALL LETTER U WITH TILDE +// /* broken */ { {0x0000, 0x0075, 0, 0, 0, 0}, 0x1ee7 }, // U1EE7 # LATIN SMALL LETTER U WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0075, 0, 0, 0, 0}, 0x00f9 }, // U00F9 # LATIN SMALL LETTER U WITH GRAVE +// /* broken */ { {0x0000, 0x0075, 0, 0, 0, 0}, 0x00fa }, // U00FA # LATIN SMALL LETTER U WITH ACUTE +// /* broken */ { {0x0000, 0x0075, 0, 0, 0, 0}, 0x1ee5 }, // U1EE5 # LATIN SMALL LETTER U WITH DOT BELOW +// /* broken */ { {0x0000, 0x0076, 0, 0, 0, 0}, 0x1e7d }, // U1E7D # LATIN SMALL LETTER V WITH TILDE +// /* broken */ { {0x0000, 0x0076, 0, 0, 0, 0}, 0x1e7f }, // U1E7F # LATIN SMALL LETTER V WITH DOT BELOW +// /* broken */ { {0x0000, 0x0077, 0, 0, 0, 0}, 0x1e81 }, // U1E81 # LATIN SMALL LETTER W WITH GRAVE +// /* broken */ { {0x0000, 0x0077, 0, 0, 0, 0}, 0x1e83 }, // U1E83 # LATIN SMALL LETTER W WITH ACUTE +// /* broken */ { {0x0000, 0x0077, 0, 0, 0, 0}, 0x1e89 }, // U1E89 # LATIN SMALL LETTER W WITH DOT BELOW +// /* broken */ { {0x0000, 0x0079, 0, 0, 0, 0}, 0x1ef5 }, // U1EF5 # LATIN SMALL LETTER Y WITH DOT BELOW +// /* broken */ { {0x0000, 0x0079, 0, 0, 0, 0}, 0x1ef9 }, // U1EF9 # LATIN SMALL LETTER Y WITH TILDE +// /* broken */ { {0x0000, 0x0079, 0, 0, 0, 0}, 0x1ef7 }, // U1EF7 # LATIN SMALL LETTER Y WITH HOOK ABOVE +// /* broken */ { {0x0000, 0x0079, 0, 0, 0, 0}, 0x1ef3 }, // U1EF3 # LATIN SMALL LETTER Y WITH GRAVE +// /* broken */ { {0x0000, 0x0079, 0, 0, 0, 0}, 0x00fd }, // U00FD # LATIN SMALL LETTER Y WITH ACUTE +// /* broken */ { {0x0000, 0x007a, 0, 0, 0, 0}, 0x1e93 }, // U1E93 # LATIN SMALL LETTER Z WITH DOT BELOW +// /* broken */ { {0x0000, 0x007a, 0, 0, 0, 0}, 0x017a }, // U017A # LATIN SMALL LETTER Z WITH ACUTE +// /* broken */ { {0x0000, 0x00c2, 0, 0, 0, 0}, 0x1ea6 }, // U1EA6 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, 0x00c2, 0, 0, 0, 0}, 0x1ea8 }, // U1EA8 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, 0x00c2, 0, 0, 0, 0}, 0x1eaa }, // U1EAA # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, 0x00c2, 0, 0, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, 0x00c5, 0, 0, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE +// /* broken */ { {0x0000, 0x00c6, 0, 0, 0, 0}, 0x01fc }, // U01FC # LATIN CAPITAL LETTER AE WITH ACUTE +// /* broken */ { {0x0000, 0x00c7, 0, 0, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE +// /* broken */ { {0x0000, 0x00ca, 0, 0, 0, 0}, 0x1ec0 }, // U1EC0 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, 0x00ca, 0, 0, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, 0x00ca, 0, 0, 0, 0}, 0x1ec2 }, // U1EC2 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, 0x00ca, 0, 0, 0, 0}, 0x1ec4 }, // U1EC4 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, 0x00cf, 0, 0, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, 0x00d4, 0, 0, 0, 0}, 0x1ed4 }, // U1ED4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, 0x00d4, 0, 0, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, 0x00d4, 0, 0, 0, 0}, 0x1ed2 }, // U1ED2 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, 0x00d4, 0, 0, 0, 0}, 0x1ed6 }, // U1ED6 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, 0x00d5, 0, 0, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {0x0000, 0x00d8, 0, 0, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {0x0000, 0x00dc, 0, 0, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, 0x00dc, 0, 0, 0, 0}, 0x01db }, // U01DB # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE +// /* broken */ { {0x0000, 0x00e2, 0, 0, 0, 0}, 0x1eab }, // U1EAB # LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, 0x00e2, 0, 0, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, 0x00e2, 0, 0, 0, 0}, 0x1ea9 }, // U1EA9 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, 0x00e2, 0, 0, 0, 0}, 0x1ea7 }, // U1EA7 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, 0x00e5, 0, 0, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE +// /* broken */ { {0x0000, 0x00e6, 0, 0, 0, 0}, 0x01fd }, // U01FD # LATIN SMALL LETTER AE WITH ACUTE +// /* broken */ { {0x0000, 0x00e7, 0, 0, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE +// /* broken */ { {0x0000, 0x00ea, 0, 0, 0, 0}, 0x1ec5 }, // U1EC5 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, 0x00ea, 0, 0, 0, 0}, 0x1ec1 }, // U1EC1 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, 0x00ea, 0, 0, 0, 0}, 0x1ec3 }, // U1EC3 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, 0x00ea, 0, 0, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, 0x00ef, 0, 0, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, 0x00f4, 0, 0, 0, 0}, 0x1ed3 }, // U1ED3 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, 0x00f4, 0, 0, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, 0x00f4, 0, 0, 0, 0}, 0x1ed5 }, // U1ED5 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, 0x00f4, 0, 0, 0, 0}, 0x1ed7 }, // U1ED7 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, 0x00f5, 0, 0, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {0x0000, 0x00f8, 0, 0, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {0x0000, 0x00fc, 0, 0, 0, 0}, 0x01dc }, // U01DC # LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE +// /* broken */ { {0x0000, 0x00fc, 0, 0, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, 0x0102, 0, 0, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE +// /* broken */ { {0x0000, 0x0102, 0, 0, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE +// /* broken */ { {0x0000, 0x0102, 0, 0, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE +// /* broken */ { {0x0000, 0x0102, 0, 0, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE +// /* broken */ { {0x0000, 0x0103, 0, 0, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE +// /* broken */ { {0x0000, 0x0103, 0, 0, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE +// /* broken */ { {0x0000, 0x0103, 0, 0, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE +// /* broken */ { {0x0000, 0x0103, 0, 0, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE +// /* broken */ { {0x0000, 0x0112, 0, 0, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE +// /* broken */ { {0x0000, 0x0112, 0, 0, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE +// /* broken */ { {0x0000, 0x0113, 0, 0, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE +// /* broken */ { {0x0000, 0x0113, 0, 0, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE +// /* broken */ { {0x0000, 0x014c, 0, 0, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE +// /* broken */ { {0x0000, 0x014c, 0, 0, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE +// /* broken */ { {0x0000, 0x014d, 0, 0, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE +// /* broken */ { {0x0000, 0x014d, 0, 0, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE +// /* broken */ { {0x0000, 0x0168, 0, 0, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {0x0000, 0x0169, 0, 0, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {0x0000, 0x0313, 0x0391, 0, 0, 0}, 0x1f0a }, // U1F0A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x0391, 0, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x0395, 0, 0, 0}, 0x1f1a }, // U1F1A # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x0395, 0, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x0397, 0, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x0397, 0, 0, 0}, 0x1f2a }, // U1F2A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x0399, 0, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x0399, 0, 0, 0}, 0x1f3a }, // U1F3A # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x039f, 0, 0, 0}, 0x1f4a }, // U1F4A # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x039f, 0, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x03a9, 0, 0, 0}, 0x1f6a }, // U1F6A # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x03a9, 0, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x03b1, 0, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x03b1, 0, 0, 0}, 0x1f02 }, // U1F02 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x03b5, 0, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x03b5, 0, 0, 0}, 0x1f12 }, // U1F12 # GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x03b7, 0, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x03b7, 0, 0, 0}, 0x1f22 }, // U1F22 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x03b9, 0, 0, 0}, 0x1f32 }, // U1F32 # GREEK SMALL LETTER IOTA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x03b9, 0, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x03bf, 0, 0, 0}, 0x1f42 }, // U1F42 # GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x03bf, 0, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x03c5, 0, 0, 0}, 0x1f52 }, // U1F52 # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x03c5, 0, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0313, 0x03c9, 0, 0, 0}, 0x1f62 }, // U1F62 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x0313, 0x03c9, 0, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x0391, 0, 0, 0}, 0x1f0b }, // U1F0B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x0391, 0, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x0395, 0, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x0395, 0, 0, 0}, 0x1f1b }, // U1F1B # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x0397, 0, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x0397, 0, 0, 0}, 0x1f2b }, // U1F2B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x0399, 0, 0, 0}, 0x1f3b }, // U1F3B # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x0399, 0, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x039f, 0, 0, 0}, 0x1f4b }, // U1F4B # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x039f, 0, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x03a5, 0, 0, 0}, 0x1f5b }, // U1F5B # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x03a5, 0, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x03a9, 0, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x03a9, 0, 0, 0}, 0x1f6b }, // U1F6B # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x03b1, 0, 0, 0}, 0x1f03 }, // U1F03 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x03b1, 0, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x03b5, 0, 0, 0}, 0x1f13 }, // U1F13 # GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x03b5, 0, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x03b7, 0, 0, 0}, 0x1f23 }, // U1F23 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x03b7, 0, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x03b9, 0, 0, 0}, 0x1f33 }, // U1F33 # GREEK SMALL LETTER IOTA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x03b9, 0, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x03bf, 0, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x03bf, 0, 0, 0}, 0x1f43 }, // U1F43 # GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x03c5, 0, 0, 0}, 0x1f53 }, // U1F53 # GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x03c5, 0, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0314, 0x03c9, 0, 0, 0}, 0x1f63 }, // U1F63 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x0314, 0x03c9, 0, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x0391, 0, 0, 0, 0}, 0x0386 }, // U0386 # GREEK CAPITAL LETTER ALPHA WITH TONOS +// /* broken */ { {0x0000, 0x0391, 0, 0, 0, 0}, 0x1fba }, // U1FBA # GREEK CAPITAL LETTER ALPHA WITH VARIA +// /* broken */ { {0x0000, 0x0395, 0, 0, 0, 0}, 0x0388 }, // U0388 # GREEK CAPITAL LETTER EPSILON WITH TONOS +// /* broken */ { {0x0000, 0x0395, 0, 0, 0, 0}, 0x1fc8 }, // U1FC8 # GREEK CAPITAL LETTER EPSILON WITH VARIA +// /* broken */ { {0x0000, 0x0397, 0, 0, 0, 0}, 0x1fca }, // U1FCA # GREEK CAPITAL LETTER ETA WITH VARIA +// /* broken */ { {0x0000, 0x0397, 0, 0, 0, 0}, 0x0389 }, // U0389 # GREEK CAPITAL LETTER ETA WITH TONOS +// /* broken */ { {0x0000, 0x0399, 0, 0, 0, 0}, 0x038a }, // U038A # GREEK CAPITAL LETTER IOTA WITH TONOS +// /* broken */ { {0x0000, 0x0399, 0, 0, 0, 0}, 0x1fda }, // U1FDA # GREEK CAPITAL LETTER IOTA WITH VARIA +// /* broken */ { {0x0000, 0x039f, 0, 0, 0, 0}, 0x038c }, // U038C # GREEK CAPITAL LETTER OMICRON WITH TONOS +// /* broken */ { {0x0000, 0x039f, 0, 0, 0, 0}, 0x1ff8 }, // U1FF8 # GREEK CAPITAL LETTER OMICRON WITH VARIA +// /* broken */ { {0x0000, 0x03a5, 0, 0, 0, 0}, 0x038e }, // U038E # GREEK CAPITAL LETTER UPSILON WITH TONOS +// /* broken */ { {0x0000, 0x03a5, 0, 0, 0, 0}, 0x1fea }, // U1FEA # GREEK CAPITAL LETTER UPSILON WITH VARIA +// /* broken */ { {0x0000, 0x03a9, 0, 0, 0, 0}, 0x038f }, // U038F # GREEK CAPITAL LETTER OMEGA WITH TONOS +// /* broken */ { {0x0000, 0x03a9, 0, 0, 0, 0}, 0x1ffa }, // U1FFA # GREEK CAPITAL LETTER OMEGA WITH VARIA +// /* broken */ { {0x0000, 0x03b1, 0, 0, 0, 0}, 0x03ac }, // U03AC # GREEK SMALL LETTER ALPHA WITH TONOS +// /* broken */ { {0x0000, 0x03b1, 0, 0, 0, 0}, 0x1f70 }, // U1F70 # GREEK SMALL LETTER ALPHA WITH VARIA +// /* broken */ { {0x0000, 0x03b5, 0, 0, 0, 0}, 0x03ad }, // U03AD # GREEK SMALL LETTER EPSILON WITH TONOS +// /* broken */ { {0x0000, 0x03b5, 0, 0, 0, 0}, 0x1f72 }, // U1F72 # GREEK SMALL LETTER EPSILON WITH VARIA +// /* broken */ { {0x0000, 0x03b7, 0, 0, 0, 0}, 0x03ae }, // U03AE # GREEK SMALL LETTER ETA WITH TONOS +// /* broken */ { {0x0000, 0x03b7, 0, 0, 0, 0}, 0x1f74 }, // U1F74 # GREEK SMALL LETTER ETA WITH VARIA +// /* broken */ { {0x0000, 0x03b9, 0, 0, 0, 0}, 0x03af }, // U03AF # GREEK SMALL LETTER IOTA WITH TONOS +// /* broken */ { {0x0000, 0x03b9, 0, 0, 0, 0}, 0x1f76 }, // U1F76 # GREEK SMALL LETTER IOTA WITH VARIA +// /* broken */ { {0x0000, 0x03bf, 0, 0, 0, 0}, 0x03cc }, // U03CC # GREEK SMALL LETTER OMICRON WITH TONOS +// /* broken */ { {0x0000, 0x03bf, 0, 0, 0, 0}, 0x1f78 }, // U1F78 # GREEK SMALL LETTER OMICRON WITH VARIA +// /* broken */ { {0x0000, 0x03c5, 0, 0, 0, 0}, 0x03cd }, // U03CD # GREEK SMALL LETTER UPSILON WITH TONOS +// /* broken */ { {0x0000, 0x03c5, 0, 0, 0, 0}, 0x1f7a }, // U1F7A # GREEK SMALL LETTER UPSILON WITH VARIA +// /* broken */ { {0x0000, 0x03c9, 0, 0, 0, 0}, 0x03ce }, // U03CE # GREEK SMALL LETTER OMEGA WITH TONOS +// /* broken */ { {0x0000, 0x03c9, 0, 0, 0, 0}, 0x1f7c }, // U1F7C # GREEK SMALL LETTER OMEGA WITH VARIA +// /* broken */ { {0x0000, 0x03ca, 0, 0, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS +// /* broken */ { {0x0000, 0x03ca, 0, 0, 0, 0}, 0x1fd2 }, // U1FD2 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA +// /* broken */ { {0x0000, 0x03cb, 0, 0, 0, 0}, 0x1fe2 }, // U1FE2 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA +// /* broken */ { {0x0000, 0x03cb, 0, 0, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS +// /* broken */ { {0x0000, 0x0413, 0, 0, 0, 0}, 0x0403 }, // U0403 # CYRILLIC CAPITAL LETTER GJE +// /* broken */ { {0x0000, 0x0415, 0, 0, 0, 0}, 0x0400 }, // U0400 # CYRILLIC CAPITAL LETTER IE WITH GRAVE +// /* broken */ { {0x0000, 0x0418, 0, 0, 0, 0}, 0x040d }, // U040D # CYRILLIC CAPITAL LETTER I WITH GRAVE +// /* broken */ { {0x0000, 0x041a, 0, 0, 0, 0}, 0x040c }, // U040C # CYRILLIC CAPITAL LETTER KJE +// /* broken */ { {0x0000, 0x0433, 0, 0, 0, 0}, 0x0453 }, // U0453 # CYRILLIC SMALL LETTER GJE +// /* broken */ { {0x0000, 0x0435, 0, 0, 0, 0}, 0x0450 }, // U0450 # CYRILLIC SMALL LETTER IE WITH GRAVE +// /* broken */ { {0x0000, 0x0438, 0, 0, 0, 0}, 0x045d }, // U045D # CYRILLIC SMALL LETTER I WITH GRAVE +// /* broken */ { {0x0000, 0x043a, 0, 0, 0, 0}, 0x045c }, // U045C # CYRILLIC SMALL LETTER KJE +// /* broken */ { {0x0000, 0x1f00, 0, 0, 0, 0}, 0x1f02 }, // U1F02 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f00, 0, 0, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f01, 0, 0, 0, 0}, 0x1f03 }, // U1F03 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f01, 0, 0, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f08, 0, 0, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f08, 0, 0, 0, 0}, 0x1f0a }, // U1F0A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f09, 0, 0, 0, 0}, 0x1f0b }, // U1F0B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f09, 0, 0, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f10, 0, 0, 0, 0}, 0x1f12 }, // U1F12 # GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f10, 0, 0, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f11, 0, 0, 0, 0}, 0x1f13 }, // U1F13 # GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f11, 0, 0, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f18, 0, 0, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f18, 0, 0, 0, 0}, 0x1f1a }, // U1F1A # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f19, 0, 0, 0, 0}, 0x1f1b }, // U1F1B # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f19, 0, 0, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f20, 0, 0, 0, 0}, 0x1f22 }, // U1F22 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f20, 0, 0, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f21, 0, 0, 0, 0}, 0x1f23 }, // U1F23 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f21, 0, 0, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f28, 0, 0, 0, 0}, 0x1f2a }, // U1F2A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f28, 0, 0, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f29, 0, 0, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f29, 0, 0, 0, 0}, 0x1f2b }, // U1F2B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f30, 0, 0, 0, 0}, 0x1f32 }, // U1F32 # GREEK SMALL LETTER IOTA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f30, 0, 0, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f31, 0, 0, 0, 0}, 0x1f33 }, // U1F33 # GREEK SMALL LETTER IOTA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f31, 0, 0, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f38, 0, 0, 0, 0}, 0x1f3a }, // U1F3A # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f38, 0, 0, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f39, 0, 0, 0, 0}, 0x1f3b }, // U1F3B # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f39, 0, 0, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f40, 0, 0, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f40, 0, 0, 0, 0}, 0x1f42 }, // U1F42 # GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f41, 0, 0, 0, 0}, 0x1f43 }, // U1F43 # GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f41, 0, 0, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f48, 0, 0, 0, 0}, 0x1f4a }, // U1F4A # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f48, 0, 0, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f49, 0, 0, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f49, 0, 0, 0, 0}, 0x1f4b }, // U1F4B # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f50, 0, 0, 0, 0}, 0x1f52 }, // U1F52 # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f50, 0, 0, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f51, 0, 0, 0, 0}, 0x1f53 }, // U1F53 # GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f51, 0, 0, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f59, 0, 0, 0, 0}, 0x1f5b }, // U1F5B # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f59, 0, 0, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f60, 0, 0, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f60, 0, 0, 0, 0}, 0x1f62 }, // U1F62 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f61, 0, 0, 0, 0}, 0x1f63 }, // U1F63 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f61, 0, 0, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA +// /* broken */ { {0x0000, 0x1f68, 0, 0, 0, 0}, 0x1f6a }, // U1F6A # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA +// /* broken */ { {0x0000, 0x1f68, 0, 0, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA +// /* broken */ { {0x0000, 0x1f69, 0, 0, 0, 0}, 0x1f6b }, // U1F6B # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA +// /* broken */ { {0x0000, 0x1f69, 0, 0, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0000, 0x004f, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0000, 0x006f, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0049, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0055, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0055, 0, 0}, 0x01db }, // U01DB # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0069, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0075, 0, 0}, 0x01dc }, // U01DC # LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0075, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03b9, 0, 0}, 0x1fd2 }, // U1FD2 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03b9, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03c5, 0, 0}, 0x1fe2 }, // U1FE2 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03c5, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0, 0}, 0x1f0b }, // U1F0B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0395, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0395, 0, 0}, 0x1f1b }, // U1F1B # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0, 0}, 0x1f2b }, // U1F2B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0399, 0, 0}, 0x1f3b }, // U1F3B # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0399, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x039f, 0, 0}, 0x1f4b }, // U1F4B # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x039f, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a5, 0, 0}, 0x1f5b }, // U1F5B # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a5, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0, 0}, 0x1f6b }, // U1F6B # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0, 0}, 0x1f03 }, // U1F03 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b5, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b5, 0, 0}, 0x1f13 }, // U1F13 # GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0, 0}, 0x1f23 }, // U1F23 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b9, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b9, 0, 0}, 0x1f33 }, // U1F33 # GREEK SMALL LETTER IOTA WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03bf, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03bf, 0, 0}, 0x1f43 }, // U1F43 # GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c5, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c5, 0, 0}, 0x1f53 }, // U1F53 # GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0, 0}, 0x1f63 }, // U1F63 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0, 0}, 0x1f0a }, // U1F0A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0395, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0395, 0, 0}, 0x1f1a }, // U1F1A # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0, 0}, 0x1f2a }, // U1F2A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0399, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0399, 0, 0}, 0x1f3a }, // U1F3A # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x039f, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x039f, 0, 0}, 0x1f4a }, // U1F4A # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0, 0}, 0x1f6a }, // U1F6A # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0, 0}, 0x1f02 }, // U1F02 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b5, 0, 0}, 0x1f12 }, // U1F12 # GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b5, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0, 0}, 0x1f22 }, // U1F22 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b9, 0, 0}, 0x1f32 }, // U1F32 # GREEK SMALL LETTER IOTA WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b9, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03bf, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03bf, 0, 0}, 0x1f42 }, // U1F42 # GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c5, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c5, 0, 0}, 0x1f52 }, // U1F52 # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0, 0}, 0x1f62 }, // U1F62 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0043, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0063, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002f, 0x004f, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x002f, 0x006f, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0041, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0041, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0041, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0061, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0061, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0061, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0041, 0, 0}, 0x1ea8 }, // U1EA8 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0041, 0, 0}, 0x1ea6 }, // U1EA6 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0041, 0, 0}, 0x1eaa }, // U1EAA # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0041, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0045, 0, 0}, 0x1ec4 }, // U1EC4 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0045, 0, 0}, 0x1ec2 }, // U1EC2 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0045, 0, 0}, 0x1ec0 }, // U1EC0 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0045, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004f, 0, 0}, 0x1ed6 }, // U1ED6 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004f, 0, 0}, 0x1ed4 }, // U1ED4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004f, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004f, 0, 0}, 0x1ed2 }, // U1ED2 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0061, 0, 0}, 0x1ea9 }, // U1EA9 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0061, 0, 0}, 0x1ea7 }, // U1EA7 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0061, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0061, 0, 0}, 0x1eab }, // U1EAB # LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0065, 0, 0}, 0x1ec5 }, // U1EC5 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0065, 0, 0}, 0x1ec1 }, // U1EC1 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0065, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0065, 0, 0}, 0x1ec3 }, // U1EC3 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006f, 0, 0}, 0x1ed7 }, // U1ED7 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006f, 0, 0}, 0x1ed5 }, // U1ED5 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006f, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006f, 0, 0}, 0x1ed3 }, // U1ED3 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0045, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005f, 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005f, 0x004f, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0065, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006f, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0041, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0041, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0041, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0061, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0061, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0061, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0041, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0061, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x007e, 0x004f, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0055, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x007e, 0x006f, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0075, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0045, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x00af, 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x00af, 0x004f, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0065, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x00af, 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Multi_key), 0x00af, 0x006f, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0, 0}, 0x1eaa }, // U1EAA # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0, 0}, 0x1ea6 }, // U1EA6 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0, 0}, 0x1ea8 }, // U1EA8 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0, 0}, 0x1ec4 }, // U1EC4 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0, 0}, 0x1ec0 }, // U1EC0 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0, 0}, 0x1ec2 }, // U1EC2 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0, 0}, 0x1ed2 }, // U1ED2 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0, 0}, 0x1ed4 }, // U1ED4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0, 0}, 0x1ed6 }, // U1ED6 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0, 0}, 0x1eab }, // U1EAB # LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0, 0}, 0x1ea9 }, // U1EA9 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0, 0}, 0x1ea7 }, // U1EA7 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0, 0}, 0x1ec3 }, // U1EC3 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0, 0}, 0x1ec1 }, // U1EC1 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0, 0}, 0x1ec5 }, // U1EC5 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0, 0}, 0x1ed3 }, // U1ED3 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0, 0}, 0x1ed7 }, // U1ED7 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0, 0}, 0x1ed5 }, // U1ED5 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Tilde), 0x0055, 0, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Tilde), 0x0075, 0, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Macron), 0x0045, 0, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Macron), 0x0045, 0, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Macron), 0x004f, 0, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Macron), 0x004f, 0, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Macron), 0x0065, 0, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Macron), 0x0065, 0, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Macron), 0x006f, 0, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Macron), 0x006f, 0, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0049, 0, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0, 0}, 0x01db }, // U01DB # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0069, 0, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0, 0}, 0x01dc }, // U01DC # LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0, 0}, 0x1fd2 }, // U1FD2 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0, 0}, 0x1fe2 }, // U1FE2 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Abovering), 0x0041, 0, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Abovering), 0x0061, 0, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Cedilla), 0x0043, 0, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Cedilla), 0x0063, 0, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE +// /* broken */ { {0x0000, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE + { {0x030f, 0x0041, 0, 0, 0, 0}, 0x0200 }, // U0200 # LATIN CAPITAL LETTER A WITH DOUBLE GRAVE + { {0x030f, 0x0045, 0, 0, 0, 0}, 0x0204 }, // U0204 # LATIN CAPITAL LETTER E WITH DOUBLE GRAVE + { {0x030f, 0x0049, 0, 0, 0, 0}, 0x0208 }, // U0208 # LATIN CAPITAL LETTER I WITH DOUBLE GRAVE + { {0x030f, 0x004f, 0, 0, 0, 0}, 0x020c }, // U020C # LATIN CAPITAL LETTER O WITH DOUBLE GRAVE + { {0x030f, 0x0052, 0, 0, 0, 0}, 0x0210 }, // U0210 # LATIN CAPITAL LETTER R WITH DOUBLE GRAVE + { {0x030f, 0x0055, 0, 0, 0, 0}, 0x0214 }, // U0214 # LATIN CAPITAL LETTER U WITH DOUBLE GRAVE + { {0x030f, 0x0061, 0, 0, 0, 0}, 0x0201 }, // U0201 # LATIN SMALL LETTER A WITH DOUBLE GRAVE + { {0x030f, 0x0065, 0, 0, 0, 0}, 0x0205 }, // U0205 # LATIN SMALL LETTER E WITH DOUBLE GRAVE + { {0x030f, 0x0069, 0, 0, 0, 0}, 0x0209 }, // U0209 # LATIN SMALL LETTER I WITH DOUBLE GRAVE + { {0x030f, 0x006f, 0, 0, 0, 0}, 0x020d }, // U020D # LATIN SMALL LETTER O WITH DOUBLE GRAVE + { {0x030f, 0x0072, 0, 0, 0, 0}, 0x0211 }, // U0211 # LATIN SMALL LETTER R WITH DOUBLE GRAVE + { {0x030f, 0x0075, 0, 0, 0, 0}, 0x0215 }, // U0215 # LATIN SMALL LETTER U WITH DOUBLE GRAVE + { {0x030f, 0x0474, 0, 0, 0, 0}, 0x0476 }, // U0476 # CYRILLIC CAPITAL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT + { {0x030f, 0x0475, 0, 0, 0, 0}, 0x0477 }, // U0477 # CYRILLIC SMALL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT + { {0x0311, 0x0041, 0, 0, 0, 0}, 0x0202 }, // U0202 # LATIN CAPITAL LETTER A WITH INVERTED BREVE + { {0x0311, 0x0045, 0, 0, 0, 0}, 0x0206 }, // U0206 # LATIN CAPITAL LETTER E WITH INVERTED BREVE + { {0x0311, 0x0049, 0, 0, 0, 0}, 0x020a }, // U020A # LATIN CAPITAL LETTER I WITH INVERTED BREVE + { {0x0311, 0x004f, 0, 0, 0, 0}, 0x020e }, // U020E # LATIN CAPITAL LETTER O WITH INVERTED BREVE + { {0x0311, 0x0052, 0, 0, 0, 0}, 0x0212 }, // U0212 # LATIN CAPITAL LETTER R WITH INVERTED BREVE + { {0x0311, 0x0055, 0, 0, 0, 0}, 0x0216 }, // U0216 # LATIN CAPITAL LETTER U WITH INVERTED BREVE + { {0x0311, 0x0061, 0, 0, 0, 0}, 0x0203 }, // U0203 # LATIN SMALL LETTER A WITH INVERTED BREVE + { {0x0311, 0x0065, 0, 0, 0, 0}, 0x0207 }, // U0207 # LATIN SMALL LETTER E WITH INVERTED BREVE + { {0x0311, 0x0069, 0, 0, 0, 0}, 0x020b }, // U020B # LATIN SMALL LETTER I WITH INVERTED BREVE + { {0x0311, 0x006f, 0, 0, 0, 0}, 0x020f }, // U020F # LATIN SMALL LETTER O WITH INVERTED BREVE + { {0x0311, 0x0072, 0, 0, 0, 0}, 0x0213 }, // U0213 # LATIN SMALL LETTER R WITH INVERTED BREVE + { {0x0311, 0x0075, 0, 0, 0, 0}, 0x0217 }, // U0217 # LATIN SMALL LETTER U WITH INVERTED BREVE + { {0x0313, 0x0391, 0, 0, 0, 0}, 0x1f08 }, // U1F08 # GREEK CAPITAL LETTER ALPHA WITH PSILI + { {0x0313, 0x0395, 0, 0, 0, 0}, 0x1f18 }, // U1F18 # GREEK CAPITAL LETTER EPSILON WITH PSILI + { {0x0313, 0x0397, 0, 0, 0, 0}, 0x1f28 }, // U1F28 # GREEK CAPITAL LETTER ETA WITH PSILI + { {0x0313, 0x0399, 0, 0, 0, 0}, 0x1f38 }, // U1F38 # GREEK CAPITAL LETTER IOTA WITH PSILI + { {0x0313, 0x039f, 0, 0, 0, 0}, 0x1f48 }, // U1F48 # GREEK CAPITAL LETTER OMICRON WITH PSILI + { {0x0313, 0x03a9, 0, 0, 0, 0}, 0x1f68 }, // U1F68 # GREEK CAPITAL LETTER OMEGA WITH PSILI + { {0x0313, 0x03b1, 0, 0, 0, 0}, 0x1f00 }, // U1F00 # GREEK SMALL LETTER ALPHA WITH PSILI + { {0x0313, 0x03b5, 0, 0, 0, 0}, 0x1f10 }, // U1F10 # GREEK SMALL LETTER EPSILON WITH PSILI + { {0x0313, 0x03b7, 0, 0, 0, 0}, 0x1f20 }, // U1F20 # GREEK SMALL LETTER ETA WITH PSILI + { {0x0313, 0x03b9, 0, 0, 0, 0}, 0x1f30 }, // U1F30 # GREEK SMALL LETTER IOTA WITH PSILI + { {0x0313, 0x03bf, 0, 0, 0, 0}, 0x1f40 }, // U1F40 # GREEK SMALL LETTER OMICRON WITH PSILI + { {0x0313, 0x03c1, 0, 0, 0, 0}, 0x1fe4 }, // U1FE4 # GREEK SMALL LETTER RHO WITH PSILI + { {0x0313, 0x03c5, 0, 0, 0, 0}, 0x1f50 }, // U1F50 # GREEK SMALL LETTER UPSILON WITH PSILI + { {0x0313, 0x03c9, 0, 0, 0, 0}, 0x1f60 }, // U1F60 # GREEK SMALL LETTER OMEGA WITH PSILI + { {0x0314, 0x0391, 0, 0, 0, 0}, 0x1f09 }, // U1F09 # GREEK CAPITAL LETTER ALPHA WITH DASIA + { {0x0314, 0x0395, 0, 0, 0, 0}, 0x1f19 }, // U1F19 # GREEK CAPITAL LETTER EPSILON WITH DASIA + { {0x0314, 0x0397, 0, 0, 0, 0}, 0x1f29 }, // U1F29 # GREEK CAPITAL LETTER ETA WITH DASIA + { {0x0314, 0x0399, 0, 0, 0, 0}, 0x1f39 }, // U1F39 # GREEK CAPITAL LETTER IOTA WITH DASIA + { {0x0314, 0x039f, 0, 0, 0, 0}, 0x1f49 }, // U1F49 # GREEK CAPITAL LETTER OMICRON WITH DASIA + { {0x0314, 0x03a1, 0, 0, 0, 0}, 0x1fec }, // U1FEC # GREEK CAPITAL LETTER RHO WITH DASIA + { {0x0314, 0x03a5, 0, 0, 0, 0}, 0x1f59 }, // U1F59 # GREEK CAPITAL LETTER UPSILON WITH DASIA + { {0x0314, 0x03a9, 0, 0, 0, 0}, 0x1f69 }, // U1F69 # GREEK CAPITAL LETTER OMEGA WITH DASIA + { {0x0314, 0x03b1, 0, 0, 0, 0}, 0x1f01 }, // U1F01 # GREEK SMALL LETTER ALPHA WITH DASIA + { {0x0314, 0x03b5, 0, 0, 0, 0}, 0x1f11 }, // U1F11 # GREEK SMALL LETTER EPSILON WITH DASIA + { {0x0314, 0x03b7, 0, 0, 0, 0}, 0x1f21 }, // U1F21 # GREEK SMALL LETTER ETA WITH DASIA + { {0x0314, 0x03b9, 0, 0, 0, 0}, 0x1f31 }, // U1F31 # GREEK SMALL LETTER IOTA WITH DASIA + { {0x0314, 0x03bf, 0, 0, 0, 0}, 0x1f41 }, // U1F41 # GREEK SMALL LETTER OMICRON WITH DASIA + { {0x0314, 0x03c1, 0, 0, 0, 0}, 0x1fe5 }, // U1FE5 # GREEK SMALL LETTER RHO WITH DASIA + { {0x0314, 0x03c5, 0, 0, 0, 0}, 0x1f51 }, // U1F51 # GREEK SMALL LETTER UPSILON WITH DASIA + { {0x0314, 0x03c9, 0, 0, 0, 0}, 0x1f61 }, // U1F61 # GREEK SMALL LETTER OMEGA WITH DASIA + { {0x0324, 0x0055, 0, 0, 0, 0}, 0x1e72 }, // U1E72 # LATIN CAPITAL LETTER U WITH DIAERESIS BELOW + { {0x0324, 0x0075, 0, 0, 0, 0}, 0x1e73 }, // U1E73 # LATIN SMALL LETTER U WITH DIAERESIS BELOW + { {0x0325, 0x0041, 0, 0, 0, 0}, 0x1e00 }, // U1E00 # LATIN CAPITAL LETTER A WITH RING BELOW + { {0x0325, 0x0061, 0, 0, 0, 0}, 0x1e01 }, // U1E01 # LATIN SMALL LETTER A WITH RING BELOW + { {0x0326, 0x0053, 0, 0, 0, 0}, 0x0218 }, // U0218 # LATIN CAPITAL LETTER S WITH COMMA BELOW + { {0x0326, 0x0054, 0, 0, 0, 0}, 0x021a }, // U021A # LATIN CAPITAL LETTER T WITH COMMA BELOW + { {0x0326, 0x0073, 0, 0, 0, 0}, 0x0219 }, // U0219 # LATIN SMALL LETTER S WITH COMMA BELOW + { {0x0326, 0x0074, 0, 0, 0, 0}, 0x021b }, // U021B # LATIN SMALL LETTER T WITH COMMA BELOW + { {0x032d, 0x0044, 0, 0, 0, 0}, 0x1e12 }, // U1E12 # LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW + { {0x032d, 0x0045, 0, 0, 0, 0}, 0x1e18 }, // U1E18 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW + { {0x032d, 0x004c, 0, 0, 0, 0}, 0x1e3c }, // U1E3C # LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW + { {0x032d, 0x004e, 0, 0, 0, 0}, 0x1e4a }, // U1E4A # LATIN CAPITAL LETTER N WITH CIRCUMFLEX BELOW + { {0x032d, 0x0054, 0, 0, 0, 0}, 0x1e70 }, // U1E70 # LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW + { {0x032d, 0x0055, 0, 0, 0, 0}, 0x1e76 }, // U1E76 # LATIN CAPITAL LETTER U WITH CIRCUMFLEX BELOW + { {0x032d, 0x0064, 0, 0, 0, 0}, 0x1e13 }, // U1E13 # LATIN SMALL LETTER D WITH CIRCUMFLEX BELOW + { {0x032d, 0x0065, 0, 0, 0, 0}, 0x1e19 }, // U1E19 # LATIN SMALL LETTER E WITH CIRCUMFLEX BELOW + { {0x032d, 0x006c, 0, 0, 0, 0}, 0x1e3d }, // U1E3D # LATIN SMALL LETTER L WITH CIRCUMFLEX BELOW + { {0x032d, 0x006e, 0, 0, 0, 0}, 0x1e4b }, // U1E4B # LATIN SMALL LETTER N WITH CIRCUMFLEX BELOW + { {0x032d, 0x0074, 0, 0, 0, 0}, 0x1e71 }, // U1E71 # LATIN SMALL LETTER T WITH CIRCUMFLEX BELOW + { {0x032d, 0x0075, 0, 0, 0, 0}, 0x1e77 }, // U1E77 # LATIN SMALL LETTER U WITH CIRCUMFLEX BELOW + { {0x032e, 0x0048, 0, 0, 0, 0}, 0x1e2a }, // U1E2A # LATIN CAPITAL LETTER H WITH BREVE BELOW + { {0x032e, 0x0068, 0, 0, 0, 0}, 0x1e2b }, // U1E2B # LATIN SMALL LETTER H WITH BREVE BELOW + { {0x0330, 0x0045, 0, 0, 0, 0}, 0x1e1a }, // U1E1A # LATIN CAPITAL LETTER E WITH TILDE BELOW + { {0x0330, 0x0049, 0, 0, 0, 0}, 0x1e2c }, // U1E2C # LATIN CAPITAL LETTER I WITH TILDE BELOW + { {0x0330, 0x0055, 0, 0, 0, 0}, 0x1e74 }, // U1E74 # LATIN CAPITAL LETTER U WITH TILDE BELOW + { {0x0330, 0x0065, 0, 0, 0, 0}, 0x1e1b }, // U1E1B # LATIN SMALL LETTER E WITH TILDE BELOW + { {0x0330, 0x0069, 0, 0, 0, 0}, 0x1e2d }, // U1E2D # LATIN SMALL LETTER I WITH TILDE BELOW + { {0x0330, 0x0075, 0, 0, 0, 0}, 0x1e75 }, // U1E75 # LATIN SMALL LETTER U WITH TILDE BELOW + { {0x0331, 0x0042, 0, 0, 0, 0}, 0x1e06 }, // U1E06 # LATIN CAPITAL LETTER B WITH LINE BELOW + { {0x0331, 0x0044, 0, 0, 0, 0}, 0x1e0e }, // U1E0E # LATIN CAPITAL LETTER D WITH LINE BELOW + { {0x0331, 0x004b, 0, 0, 0, 0}, 0x1e34 }, // U1E34 # LATIN CAPITAL LETTER K WITH LINE BELOW + { {0x0331, 0x004c, 0, 0, 0, 0}, 0x1e3a }, // U1E3A # LATIN CAPITAL LETTER L WITH LINE BELOW + { {0x0331, 0x004e, 0, 0, 0, 0}, 0x1e48 }, // U1E48 # LATIN CAPITAL LETTER N WITH LINE BELOW + { {0x0331, 0x0052, 0, 0, 0, 0}, 0x1e5e }, // U1E5E # LATIN CAPITAL LETTER R WITH LINE BELOW + { {0x0331, 0x0054, 0, 0, 0, 0}, 0x1e6e }, // U1E6E # LATIN CAPITAL LETTER T WITH LINE BELOW + { {0x0331, 0x005a, 0, 0, 0, 0}, 0x1e94 }, // U1E94 # LATIN CAPITAL LETTER Z WITH LINE BELOW + { {0x0331, 0x0062, 0, 0, 0, 0}, 0x1e07 }, // U1E07 # LATIN SMALL LETTER B WITH LINE BELOW + { {0x0331, 0x0064, 0, 0, 0, 0}, 0x1e0f }, // U1E0F # LATIN SMALL LETTER D WITH LINE BELOW + { {0x0331, 0x0068, 0, 0, 0, 0}, 0x1e96 }, // U1E96 # LATIN SMALL LETTER H WITH LINE BELOW + { {0x0331, 0x006b, 0, 0, 0, 0}, 0x1e35 }, // U1E35 # LATIN SMALL LETTER K WITH LINE BELOW + { {0x0331, 0x006c, 0, 0, 0, 0}, 0x1e3b }, // U1E3B # LATIN SMALL LETTER L WITH LINE BELOW + { {0x0331, 0x006e, 0, 0, 0, 0}, 0x1e49 }, // U1E49 # LATIN SMALL LETTER N WITH LINE BELOW + { {0x0331, 0x0072, 0, 0, 0, 0}, 0x1e5f }, // U1E5F # LATIN SMALL LETTER R WITH LINE BELOW + { {0x0331, 0x0074, 0, 0, 0, 0}, 0x1e6f }, // U1E6F # LATIN SMALL LETTER T WITH LINE BELOW + { {0x0331, 0x007a, 0, 0, 0, 0}, 0x1e95 }, // U1E95 # LATIN SMALL LETTER Z WITH LINE BELOW + { {0x0342, 0x0313, 0x0391, 0, 0, 0}, 0x1f0e }, // U1F0E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {0x0342, 0x0313, 0x0397, 0, 0, 0}, 0x1f2e }, // U1F2E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI + { {0x0342, 0x0313, 0x0399, 0, 0, 0}, 0x1f3e }, // U1F3E # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI + { {0x0342, 0x0313, 0x03a9, 0, 0, 0}, 0x1f6e }, // U1F6E # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {0x0342, 0x0313, 0x03b1, 0, 0, 0}, 0x1f06 }, // U1F06 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {0x0342, 0x0313, 0x03b7, 0, 0, 0}, 0x1f26 }, // U1F26 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI + { {0x0342, 0x0313, 0x03b9, 0, 0, 0}, 0x1f36 }, // U1F36 # GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI + { {0x0342, 0x0313, 0x03c5, 0, 0, 0}, 0x1f56 }, // U1F56 # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI + { {0x0342, 0x0313, 0x03c9, 0, 0, 0}, 0x1f66 }, // U1F66 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {0x0342, 0x0314, 0x0391, 0, 0, 0}, 0x1f0f }, // U1F0F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {0x0342, 0x0314, 0x0397, 0, 0, 0}, 0x1f2f }, // U1F2F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI + { {0x0342, 0x0314, 0x0399, 0, 0, 0}, 0x1f3f }, // U1F3F # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI + { {0x0342, 0x0314, 0x03a5, 0, 0, 0}, 0x1f5f }, // U1F5F # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {0x0342, 0x0314, 0x03a9, 0, 0, 0}, 0x1f6f }, // U1F6F # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {0x0342, 0x0314, 0x03b1, 0, 0, 0}, 0x1f07 }, // U1F07 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {0x0342, 0x0314, 0x03b7, 0, 0, 0}, 0x1f27 }, // U1F27 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI + { {0x0342, 0x0314, 0x03b9, 0, 0, 0}, 0x1f37 }, // U1F37 # GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI + { {0x0342, 0x0314, 0x03c5, 0, 0, 0}, 0x1f57 }, // U1F57 # GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {0x0342, 0x0314, 0x03c9, 0, 0, 0}, 0x1f67 }, // U1F67 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {0x0342, 0x03b1, 0, 0, 0, 0}, 0x1fb6 }, // U1FB6 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI + { {0x0342, 0x03b7, 0, 0, 0, 0}, 0x1fc6 }, // U1FC6 # GREEK SMALL LETTER ETA WITH PERISPOMENI + { {0x0342, 0x03b9, 0, 0, 0, 0}, 0x1fd6 }, // U1FD6 # GREEK SMALL LETTER IOTA WITH PERISPOMENI + { {0x0342, 0x03c5, 0, 0, 0, 0}, 0x1fe6 }, // U1FE6 # GREEK SMALL LETTER UPSILON WITH PERISPOMENI + { {0x0342, 0x03c9, 0, 0, 0, 0}, 0x1ff6 }, // U1FF6 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI + { {0x0342, 0x03ca, 0, 0, 0, 0}, 0x1fd7 }, // U1FD7 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI + { {0x0342, 0x03cb, 0, 0, 0, 0}, 0x1fe7 }, // U1FE7 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI + { {0x0342, 0x1f00, 0, 0, 0, 0}, 0x1f06 }, // U1F06 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {0x0342, 0x1f01, 0, 0, 0, 0}, 0x1f07 }, // U1F07 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {0x0342, 0x1f08, 0, 0, 0, 0}, 0x1f0e }, // U1F0E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {0x0342, 0x1f09, 0, 0, 0, 0}, 0x1f0f }, // U1F0F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {0x0342, 0x1f20, 0, 0, 0, 0}, 0x1f26 }, // U1F26 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI + { {0x0342, 0x1f21, 0, 0, 0, 0}, 0x1f27 }, // U1F27 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI + { {0x0342, 0x1f28, 0, 0, 0, 0}, 0x1f2e }, // U1F2E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI + { {0x0342, 0x1f29, 0, 0, 0, 0}, 0x1f2f }, // U1F2F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI + { {0x0342, 0x1f30, 0, 0, 0, 0}, 0x1f36 }, // U1F36 # GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI + { {0x0342, 0x1f31, 0, 0, 0, 0}, 0x1f37 }, // U1F37 # GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI + { {0x0342, 0x1f38, 0, 0, 0, 0}, 0x1f3e }, // U1F3E # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI + { {0x0342, 0x1f39, 0, 0, 0, 0}, 0x1f3f }, // U1F3F # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI + { {0x0342, 0x1f50, 0, 0, 0, 0}, 0x1f56 }, // U1F56 # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI + { {0x0342, 0x1f51, 0, 0, 0, 0}, 0x1f57 }, // U1F57 # GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {0x0342, 0x1f59, 0, 0, 0, 0}, 0x1f5f }, // U1F5F # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {0x0342, 0x1f60, 0, 0, 0, 0}, 0x1f66 }, // U1F66 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {0x0342, 0x1f61, 0, 0, 0, 0}, 0x1f67 }, // U1F67 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {0x0342, 0x1f68, 0, 0, 0, 0}, 0x1f6e }, // U1F6E # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {0x0342, 0x1f69, 0, 0, 0, 0}, 0x1f6f }, // U1F6F # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03b9, 0, 0}, 0x1fd7 }, // U1FD7 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03c5, 0, 0}, 0x1fe7 }, // U1FE7 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0, 0}, 0x1f0f }, // U1F0F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0, 0}, 0x1f2f }, // U1F2F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0399, 0, 0}, 0x1f3f }, // U1F3F # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a5, 0, 0}, 0x1f5f }, // U1F5F # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0, 0}, 0x1f6f }, // U1F6F # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0, 0}, 0x1f07 }, // U1F07 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0, 0}, 0x1f27 }, // U1F27 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b9, 0, 0}, 0x1f37 }, // U1F37 # GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c5, 0, 0}, 0x1f57 }, // U1F57 # GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0, 0}, 0x1f67 }, // U1F67 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0, 0}, 0x1f0e }, // U1F0E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0, 0}, 0x1f2e }, // U1F2E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0399, 0, 0}, 0x1f3e }, // U1F3E # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0, 0}, 0x1f6e }, // U1F6E # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0, 0}, 0x1f06 }, // U1F06 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0, 0}, 0x1f26 }, // U1F26 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b9, 0, 0}, 0x1f36 }, // U1F36 # GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c5, 0, 0}, 0x1f56 }, // U1F56 # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0, 0}, 0x1f66 }, // U1F66 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0, 0}, 0x1fd7 }, // U1FD7 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI + { {0x0342, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0, 0}, 0x1fe7 }, // U1FE7 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0044, 0, 0, 0}, 0x0110 }, // U0110 # LATIN CAPITAL LETTER D WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0047, 0, 0, 0}, 0x01e4 }, // U01E4 # LATIN CAPITAL LETTER G WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0048, 0, 0, 0}, 0x0126 }, // U0126 # LATIN CAPITAL LETTER H WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0049, 0, 0, 0}, 0x0197 }, // U0197 # LATIN CAPITAL LETTER I WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x004c, 0, 0, 0}, 0x0141 }, // U0141 # LATIN CAPITAL LETTER L WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x004f, 0, 0, 0}, 0x00d8 }, // U00D8 # LATIN CAPITAL LETTER O WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0054, 0, 0, 0}, 0x0166 }, // U0166 # LATIN CAPITAL LETTER T WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x005a, 0, 0, 0}, 0x01b5 }, // U01B5 # LATIN CAPITAL LETTER Z WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0062, 0, 0, 0}, 0x0180 }, // U0180 # LATIN SMALL LETTER B WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0064, 0, 0, 0}, 0x0111 }, // U0111 # LATIN SMALL LETTER D WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0067, 0, 0, 0}, 0x01e5 }, // U01E5 # LATIN SMALL LETTER G WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0068, 0, 0, 0}, 0x0127 }, // U0127 # LATIN SMALL LETTER H WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0069, 0, 0, 0}, 0x0268 }, // U0268 # LATIN SMALL LETTER I WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x006c, 0, 0, 0}, 0x0142 }, // U0142 # LATIN SMALL LETTER L WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x006f, 0, 0, 0}, 0x00f8 }, // U00F8 # LATIN SMALL LETTER O WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0074, 0, 0, 0}, 0x0167 }, // U0167 # LATIN SMALL LETTER T WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x007a, 0, 0, 0}, 0x01b6 }, // U01B6 # LATIN SMALL LETTER Z WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0294, 0, 0, 0}, 0x02a1 }, // U02A1 # LATIN LETTER GLOTTAL STOP WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0338, 0, 0, 0}, 0x2260 }, // U2260 # NOT ETQUAL TO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0413, 0, 0, 0}, 0x0492 }, // U0492 # CYRILLIC CAPITAL LETTER GHE WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x041a, 0, 0, 0}, 0x049e }, // U049E # CYRILLIC CAPITAL LETTER KA WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x0433, 0, 0, 0}, 0x0493 }, // U0493 # CYRILLIC SMALL LETTER GHE WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x043a, 0, 0, 0}, 0x049f }, // U049F # CYRILLIC SMALL LETTER KA WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x04ae, 0, 0, 0}, 0x04b0 }, // U04B0 # CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x04af, 0, 0, 0}, 0x04b1 }, // U04B1 # CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x2190, 0, 0, 0}, 0x219a }, // U219A # LEFTWARDS ARROW WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x2192, 0, 0, 0}, 0x219b }, // U219B # RIGHTWARDS ARROW WITH STROKE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0000, 0x2194, 0, 0, 0}, 0x21ae }, // U21AE # LEFT RIGHT ARROW WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x0020, 0x0020, 0, 0, 0}, 0x00a0 }, // nobreakspace # NO-BREAK SPACE + { {UNITIZE(TQt::Key_Multi_key), 0x0020, 0x0027, 0, 0, 0}, 0x0027 }, // apostrophe + { {UNITIZE(TQt::Key_Multi_key), 0x0020, 0x002c, 0, 0, 0}, 0x00b8 }, // cedilla + { {UNITIZE(TQt::Key_Multi_key), 0x0020, 0x002d, 0, 0, 0}, 0x007e }, // asciitilde + { {UNITIZE(TQt::Key_Multi_key), 0x0020, 0x002e, 0, 0, 0}, 0x2008 }, // U2008 # PUNCTUATION SPACE + { {UNITIZE(TQt::Key_Multi_key), 0x0020, 0x003e, 0, 0, 0}, 0x005e }, // asciicircum + { {UNITIZE(TQt::Key_Multi_key), 0x0020, 0x005e, 0, 0, 0}, 0x005e }, // asciicircum + { {UNITIZE(TQt::Key_Multi_key), 0x0020, 0x0060, 0, 0, 0}, 0x0060 }, // grave + { {UNITIZE(TQt::Key_Multi_key), 0x0020, 0x007e, 0, 0, 0}, 0x007e }, // asciitilde +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0000, 0, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0000, 0, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0000, 0, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0000, 0, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0021, 0, 0, 0}, 0x00a1 }, // exclamdown + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x002b, 0x004f, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x002b, 0x0055, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x002b, 0x006f, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x002b, 0x0075, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0041, 0, 0, 0}, 0x1ea0 }, // U1EA0 # LATIN CAPITAL LETTER A WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0042, 0, 0, 0}, 0x1e04 }, // U1E04 # LATIN CAPITAL LETTER B WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0044, 0, 0, 0}, 0x1e0c }, // U1E0C # LATIN CAPITAL LETTER D WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0045, 0, 0, 0}, 0x1eb8 }, // U1EB8 # LATIN CAPITAL LETTER E WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0048, 0, 0, 0}, 0x1e24 }, // U1E24 # LATIN CAPITAL LETTER H WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0049, 0, 0, 0}, 0x1eca }, // U1ECA # LATIN CAPITAL LETTER I WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x004b, 0, 0, 0}, 0x1e32 }, // U1E32 # LATIN CAPITAL LETTER K WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x004c, 0, 0, 0}, 0x1e36 }, // U1E36 # LATIN CAPITAL LETTER L WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x004d, 0, 0, 0}, 0x1e42 }, // U1E42 # LATIN CAPITAL LETTER M WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x004e, 0, 0, 0}, 0x1e46 }, // U1E46 # LATIN CAPITAL LETTER N WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x004f, 0, 0, 0}, 0x1ecc }, // U1ECC # LATIN CAPITAL LETTER O WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0052, 0, 0, 0}, 0x1e5a }, // U1E5A # LATIN CAPITAL LETTER R WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0053, 0, 0, 0}, 0x1e62 }, // U1E62 # LATIN CAPITAL LETTER S WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0054, 0, 0, 0}, 0x1e6c }, // U1E6C # LATIN CAPITAL LETTER T WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0055, 0, 0, 0}, 0x1ee4 }, // U1EE4 # LATIN CAPITAL LETTER U WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0056, 0, 0, 0}, 0x1e7e }, // U1E7E # LATIN CAPITAL LETTER V WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0057, 0, 0, 0}, 0x1e88 }, // U1E88 # LATIN CAPITAL LETTER W WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0059, 0, 0, 0}, 0x1ef4 }, // U1EF4 # LATIN CAPITAL LETTER Y WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x005a, 0, 0, 0}, 0x1e92 }, // U1E92 # LATIN CAPITAL LETTER Z WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x005e, 0, 0, 0}, 0x00a6 }, // brokenbar + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0061, 0, 0, 0}, 0x1ea1 }, // U1EA1 # LATIN SMALL LETTER A WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0062, 0, 0, 0}, 0x1e05 }, // U1E05 # LATIN SMALL LETTER B WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0064, 0, 0, 0}, 0x1e0d }, // U1E0D # LATIN SMALL LETTER D WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0065, 0, 0, 0}, 0x1eb9 }, // U1EB9 # LATIN SMALL LETTER E WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0068, 0, 0, 0}, 0x1e25 }, // U1E25 # LATIN SMALL LETTER H WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0069, 0, 0, 0}, 0x1ecb }, // U1ECB # LATIN SMALL LETTER I WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x006b, 0, 0, 0}, 0x1e33 }, // U1E33 # LATIN SMALL LETTER K WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x006c, 0, 0, 0}, 0x1e37 }, // U1E37 # LATIN SMALL LETTER L WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x006d, 0, 0, 0}, 0x1e43 }, // U1E43 # LATIN SMALL LETTER M WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x006e, 0, 0, 0}, 0x1e47 }, // U1E47 # LATIN SMALL LETTER N WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x006f, 0, 0, 0}, 0x1ecd }, // U1ECD # LATIN SMALL LETTER O WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0072, 0, 0, 0}, 0x1e5b }, // U1E5B # LATIN SMALL LETTER R WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0073, 0, 0, 0}, 0x1e63 }, // U1E63 # LATIN SMALL LETTER S WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0074, 0, 0, 0}, 0x1e6d }, // U1E6D # LATIN SMALL LETTER T WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0075, 0, 0, 0}, 0x1ee5 }, // U1EE5 # LATIN SMALL LETTER U WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0076, 0, 0, 0}, 0x1e7f }, // U1E7F # LATIN SMALL LETTER V WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0077, 0, 0, 0}, 0x1e89 }, // U1E89 # LATIN SMALL LETTER W WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0079, 0, 0, 0}, 0x1ef5 }, // U1EF5 # LATIN SMALL LETTER Y WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, 0x007a, 0, 0, 0}, 0x1e93 }, // U1E93 # LATIN SMALL LETTER Z WITH DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0021, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0000, 0, 0, 0}, 0x0344 }, // U0344 # COMBINING GREEK DIALYTIKA TONOS +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0000, 0x004f, 0, 0}, 0x1e4e }, // U1E4E # LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0000, 0x006f, 0, 0}, 0x1e4f }, // U1E4F # LATIN SMALL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0027, 0, 0, 0}, 0x0344 }, // U0344 # COMBINING GREEK DIALYTIKA TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x002c, 0, 0, 0}, 0x201e }, // U201e # DOUBLE LOW-9 TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x002f, 0, 0, 0}, 0x301e }, // U301e # DOUBLE PRIME TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x003c, 0, 0, 0}, 0x201c }, // U201c # LEFT DOUBLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x003e, 0, 0, 0}, 0x201d }, // U201d # RIGHT DOUBLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0041, 0, 0, 0}, 0x00c4 }, // U00C4 # LATIN CAPITAL LETTER A WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0045, 0, 0, 0}, 0x00cb }, // U00CB # LATIN CAPITAL LETTER E WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0048, 0, 0, 0}, 0x1e26 }, // U1E26 # LATIN CAPITAL LETTER H WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0049, 0, 0, 0}, 0x00cf }, // U00CF # LATIN CAPITAL LETTER I WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x004f, 0, 0, 0}, 0x00d6 }, // U00D6 # LATIN CAPITAL LETTER O WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0055, 0, 0, 0}, 0x00dc }, // U00DC # LATIN CAPITAL LETTER U WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0057, 0, 0, 0}, 0x1e84 }, // U1E84 # LATIN CAPITAL LETTER W WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0058, 0, 0, 0}, 0x1e8c }, // U1E8C # LATIN CAPITAL LETTER X WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0059, 0, 0, 0}, 0x0178 }, // U0178 # LATIN CAPITAL LETTER Y WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x005c, 0, 0, 0}, 0x301d }, // U301d # REVERSED DOUBLE PRIME TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x005f, 0x0055, 0, 0}, 0x1e7a }, // U1E7A # LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x005f, 0x0075, 0, 0}, 0x1e7b }, // U1E7B # LATIN SMALL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0061, 0, 0, 0}, 0x00e4 }, // U00E4 # LATIN SMALL LETTER A WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0065, 0, 0, 0}, 0x00eb }, // U00EB # LATIN SMALL LETTER E WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0068, 0, 0, 0}, 0x1e27 }, // U1E27 # LATIN SMALL LETTER H WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0069, 0, 0, 0}, 0x00ef }, // U00EF # LATIN SMALL LETTER I WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x006f, 0, 0, 0}, 0x00f6 }, // U00F6 # LATIN SMALL LETTER O WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0074, 0, 0, 0}, 0x1e97 }, // U1E97 # LATIN SMALL LETTER T WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0075, 0, 0, 0}, 0x00fc }, // U00FC # LATIN SMALL LETTER U WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0077, 0, 0, 0}, 0x1e85 }, // U1E85 # LATIN SMALL LETTER W WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0078, 0, 0, 0}, 0x1e8d }, // U1E8D # LATIN SMALL LETTER X WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0079, 0, 0, 0}, 0x00ff }, // U00FF # LATIN SMALL LETTER Y WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x007e, 0x004f, 0, 0}, 0x1e4e }, // U1E4E # LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x007e, 0x006f, 0, 0}, 0x1e4f }, // U1E4F # LATIN SMALL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x00af, 0x0055, 0, 0}, 0x1e7a }, // U1E7A # LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x00af, 0x0075, 0, 0}, 0x1e7b }, // U1E7B # LATIN SMALL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x00b4, 0, 0, 0}, 0x0344 }, // U0344 # COMBINING GREEK DIALYTIKA TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x00d5, 0, 0, 0}, 0x1e4e }, // U1E4E # LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x00f5, 0, 0, 0}, 0x1e4f }, // U1E4F # LATIN SMALL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x016a, 0, 0, 0}, 0x1e7a }, // U1E7A # LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x016b, 0, 0, 0}, 0x1e7b }, // U1E7B # LATIN SMALL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0399, 0, 0, 0}, 0x03aa }, // U03AA # GREEK CAPITAL LETTER IOTA WITH DIALYTIKA + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03a5, 0, 0, 0}, 0x03ab }, // U03AB # GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03b9, 0, 0, 0}, 0x03ca }, // U03CA # GREEK SMALL LETTER IOTA WITH DIALYTIKA + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03c5, 0, 0, 0}, 0x03cb }, // U03CB # GREEK SMALL LETTER UPSILON WITH DIALYTIKA + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03d2, 0, 0, 0}, 0x03d4 }, // U03D4 # GREEK UPSILON WITH DIAERESIS AND HOOK SYMBOL + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0406, 0, 0, 0}, 0x0407 }, // U0407 # CYRILLIC CAPITAL LETTER YI + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0410, 0, 0, 0}, 0x04d2 }, // U04D2 # CYRILLIC CAPITAL LETTER A WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0415, 0, 0, 0}, 0x0401 }, // U0401 # CYRILLIC CAPITAL LETTER IO + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0416, 0, 0, 0}, 0x04dc }, // U04DC # CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0417, 0, 0, 0}, 0x04de }, // U04DE # CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0418, 0, 0, 0}, 0x04e4 }, // U04E4 # CYRILLIC CAPITAL LETTER I WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x041e, 0, 0, 0}, 0x04e6 }, // U04E6 # CYRILLIC CAPITAL LETTER O WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0423, 0, 0, 0}, 0x04f0 }, // U04F0 # CYRILLIC CAPITAL LETTER U WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0427, 0, 0, 0}, 0x04f4 }, // U04F4 # CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x042b, 0, 0, 0}, 0x04f8 }, // U04F8 # CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x042d, 0, 0, 0}, 0x04ec }, // U04EC # CYRILLIC CAPITAL LETTER E WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0430, 0, 0, 0}, 0x04d3 }, // U04D3 # CYRILLIC SMALL LETTER A WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0435, 0, 0, 0}, 0x0451 }, // U0451 # CYRILLIC SMALL LETTER IO + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0436, 0, 0, 0}, 0x04dd }, // U04DD # CYRILLIC SMALL LETTER ZHE WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0437, 0, 0, 0}, 0x04df }, // U04DF # CYRILLIC SMALL LETTER ZE WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0438, 0, 0, 0}, 0x04e5 }, // U04E5 # CYRILLIC SMALL LETTER I WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x043e, 0, 0, 0}, 0x04e7 }, // U04E7 # CYRILLIC SMALL LETTER O WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0443, 0, 0, 0}, 0x04f1 }, // U04F1 # CYRILLIC SMALL LETTER U WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0447, 0, 0, 0}, 0x04f5 }, // U04F5 # CYRILLIC SMALL LETTER CHE WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x044b, 0, 0, 0}, 0x04f9 }, // U04F9 # CYRILLIC SMALL LETTER YERU WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x044d, 0, 0, 0}, 0x04ed }, // U04ED # CYRILLIC SMALL LETTER E WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0456, 0, 0, 0}, 0x0457 }, // U0457 # CYRILLIC SMALL LETTER YI + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x04d8, 0, 0, 0}, 0x04da }, // U04DA # CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x04d9, 0, 0, 0}, 0x04db }, // U04DB # CYRILLIC SMALL LETTER SCHWA WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x04e8, 0, 0, 0}, 0x04ea }, // U04EA # CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, 0x04e9, 0, 0, 0}, 0x04eb }, // U04EB # CYRILLIC SMALL LETTER BARRED O WITH DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, UNITIZE(TQt::Key_Dead_Acute), 0, 0, 0}, 0x0344 }, // U0344 # COMBINING GREEK DIALYTIKA TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0}, 0x1e4e }, // U1E4E # LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0}, 0x1e4f }, // U1E4F # LATIN SMALL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, UNITIZE(TQt::Key_Dead_Macron), 0x0055, 0, 0}, 0x1e7a }, // U1E7A # LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0022, UNITIZE(TQt::Key_Dead_Macron), 0x0075, 0, 0}, 0x1e7b }, // U1E7B # LATIN SMALL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Multi_key), 0x0023, 0x0023, 0, 0, 0}, 0x266f }, // U266f # MUSIC SHARP SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0023, 0x0062, 0, 0, 0}, 0x266d }, // U266d # MUSIC FLAT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0023, 0x0066, 0, 0, 0}, 0x266e }, // U266e # MUSIC NATURAL SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0025, 0x006f, 0, 0, 0}, 0x2030 }, // U2030 # PER MILLE SIGN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0x004f, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0x004f, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0x0055, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0x006f, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0x006f, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0000, 0x0075, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0020, 0, 0, 0}, 0x0027 }, // apostrophe + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0022, 0x0049, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0022, 0x0055, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0022, 0x0069, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0022, 0x0075, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0022, 0x03b9, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0022, 0x03c5, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x0391, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x0395, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x0397, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x0399, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x039f, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03a5, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03a9, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03b1, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03b5, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03b7, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03b9, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03bf, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03c5, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03c9, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x0391, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x0395, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x0397, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x0399, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x039f, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03a9, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03b1, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03b5, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03b7, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03b9, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03bf, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03c5, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03c9, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x002b, 0x004f, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x002b, 0x0055, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x002b, 0x006f, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x002b, 0x0075, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x002c, 0, 0, 0}, 0x201a }, // U201a # SINGLE LOW-9 TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x002c, 0x0043, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x002c, 0x0063, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x002f, 0x004f, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x002f, 0x006f, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x003c, 0, 0, 0}, 0x2018 }, // U2018 # LEFT SINGLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x003e, 0, 0, 0}, 0x2019 }, // U2019 # RIGHT SINGLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0041, 0, 0, 0}, 0x00c1 }, // U00C1 # LATIN CAPITAL LETTER A WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0043, 0, 0, 0}, 0x0106 }, // U0106 # LATIN CAPITAL LETTER C WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0045, 0, 0, 0}, 0x00c9 }, // U00C9 # LATIN CAPITAL LETTER E WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0047, 0, 0, 0}, 0x01f4 }, // U01F4 # LATIN CAPITAL LETTER G WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0049, 0, 0, 0}, 0x00cd }, // U00CD # LATIN CAPITAL LETTER I WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x004b, 0, 0, 0}, 0x1e30 }, // U1E30 # LATIN CAPITAL LETTER K WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x004c, 0, 0, 0}, 0x0139 }, // U0139 # LATIN CAPITAL LETTER L WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x004d, 0, 0, 0}, 0x1e3e }, // U1E3E # LATIN CAPITAL LETTER M WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x004e, 0, 0, 0}, 0x0143 }, // U0143 # LATIN CAPITAL LETTER N WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x004f, 0, 0, 0}, 0x00d3 }, // U00D3 # LATIN CAPITAL LETTER O WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0050, 0, 0, 0}, 0x1e54 }, // U1E54 # LATIN CAPITAL LETTER P WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0052, 0, 0, 0}, 0x0154 }, // U0154 # LATIN CAPITAL LETTER R WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0053, 0, 0, 0}, 0x015a }, // U015A # LATIN CAPITAL LETTER S WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0055, 0, 0, 0}, 0x00da }, // U00DA # LATIN CAPITAL LETTER U WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0055, 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0055, 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0057, 0, 0, 0}, 0x1e82 }, // U1E82 # LATIN CAPITAL LETTER W WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0059, 0, 0, 0}, 0x00dd }, // U00DD # LATIN CAPITAL LETTER Y WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005a, 0, 0, 0}, 0x0179 }, // U0179 # LATIN CAPITAL LETTER Z WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005e, 0x0041, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005e, 0x0045, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005e, 0x004f, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005e, 0x0061, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005e, 0x0065, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005e, 0x006f, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005f, 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005f, 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005f, 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x005f, 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0061, 0, 0, 0}, 0x00e1 }, // U00E1 # LATIN SMALL LETTER A WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0062, 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0062, 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0063, 0, 0, 0}, 0x0107 }, // U0107 # LATIN SMALL LETTER C WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0065, 0, 0, 0}, 0x00e9 }, // U00E9 # LATIN SMALL LETTER E WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0067, 0, 0, 0}, 0x01f5 }, // U01F5 # LATIN SMALL LETTER G WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0069, 0, 0, 0}, 0x00ed }, // U00ED # LATIN SMALL LETTER I WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x006b, 0, 0, 0}, 0x1e31 }, // U1E31 # LATIN SMALL LETTER K WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x006c, 0, 0, 0}, 0x013a }, // U013A # LATIN SMALL LETTER L WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x006d, 0, 0, 0}, 0x1e3f }, // U1E3F # LATIN SMALL LETTER M WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x006e, 0, 0, 0}, 0x0144 }, // U0144 # LATIN SMALL LETTER N WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x006f, 0, 0, 0}, 0x00f3 }, // U00F3 # LATIN SMALL LETTER O WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0070, 0, 0, 0}, 0x1e55 }, // U1E55 # LATIN SMALL LETTER P WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0072, 0, 0, 0}, 0x0155 }, // U0155 # LATIN SMALL LETTER R WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0073, 0, 0, 0}, 0x015b }, // U015B # LATIN SMALL LETTER S WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0075, 0, 0, 0}, 0x00fa }, // U00FA # LATIN SMALL LETTER U WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0077, 0, 0, 0}, 0x1e83 }, // U1E83 # LATIN SMALL LETTER W WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0079, 0, 0, 0}, 0x00fd }, // U00FD # LATIN SMALL LETTER Y WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x007a, 0, 0, 0}, 0x017a }, // U017A # LATIN SMALL LETTER Z WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x007e, 0x004f, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x007e, 0x0055, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x007e, 0x006f, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x007e, 0x0075, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00af, 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00af, 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00af, 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00af, 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00c2, 0, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00c5, 0, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00c6, 0, 0, 0}, 0x01fc }, // U01FC # LATIN CAPITAL LETTER AE WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00c7, 0, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00ca, 0, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00cf, 0, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00d4, 0, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00d5, 0, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00d8, 0, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00dc, 0, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00e2, 0, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00e5, 0, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00e6, 0, 0, 0}, 0x01fd }, // U01FD # LATIN SMALL LETTER AE WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00e7, 0, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00ea, 0, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00ef, 0, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00f4, 0, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00f5, 0, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00f8, 0, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x00fc, 0, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0102, 0, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0103, 0, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0112, 0, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0113, 0, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x014c, 0, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x014d, 0, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0168, 0, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0169, 0, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x0391, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x0395, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x0397, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x0399, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x039f, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03a9, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03b1, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03b5, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03b7, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03b9, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03bf, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03c5, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03c9, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x0391, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x0395, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x0397, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x0399, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x039f, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03a5, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03a9, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03b1, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03b5, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03b7, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03b9, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03bf, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03c5, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03c9, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0391, 0, 0, 0}, 0x0386 }, // U0386 # GREEK CAPITAL LETTER ALPHA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0395, 0, 0, 0}, 0x0388 }, // U0388 # GREEK CAPITAL LETTER EPSILON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0397, 0, 0, 0}, 0x0389 }, // U0389 # GREEK CAPITAL LETTER ETA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0399, 0, 0, 0}, 0x038a }, // U038A # GREEK CAPITAL LETTER IOTA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x039f, 0, 0, 0}, 0x038c }, // U038C # GREEK CAPITAL LETTER OMICRON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03a5, 0, 0, 0}, 0x038e }, // U038E # GREEK CAPITAL LETTER UPSILON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03a9, 0, 0, 0}, 0x038f }, // U038F # GREEK CAPITAL LETTER OMEGA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03b1, 0, 0, 0}, 0x03ac }, // U03AC # GREEK SMALL LETTER ALPHA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03b5, 0, 0, 0}, 0x03ad }, // U03AD # GREEK SMALL LETTER EPSILON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03b7, 0, 0, 0}, 0x03ae }, // U03AE # GREEK SMALL LETTER ETA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03b9, 0, 0, 0}, 0x03af }, // U03AF # GREEK SMALL LETTER IOTA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03bf, 0, 0, 0}, 0x03cc }, // U03CC # GREEK SMALL LETTER OMICRON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03c5, 0, 0, 0}, 0x03cd }, // U03CD # GREEK SMALL LETTER UPSILON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03c9, 0, 0, 0}, 0x03ce }, // U03CE # GREEK SMALL LETTER OMEGA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03ca, 0, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03cb, 0, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03d2, 0, 0, 0}, 0x03d3 }, // U03D3 # GREEK UPSILON WITH ACUTE AND HOOK SYMBOL + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0413, 0, 0, 0}, 0x0403 }, // U0403 # CYRILLIC CAPITAL LETTER GJE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x041a, 0, 0, 0}, 0x040c }, // U040C # CYRILLIC CAPITAL LETTER KJE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0433, 0, 0, 0}, 0x0453 }, // U0453 # CYRILLIC SMALL LETTER GJE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x043a, 0, 0, 0}, 0x045c }, // U045C # CYRILLIC SMALL LETTER KJE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f00, 0, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f01, 0, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f08, 0, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f09, 0, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f10, 0, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f11, 0, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f18, 0, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f19, 0, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f20, 0, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f21, 0, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f28, 0, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f29, 0, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f30, 0, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f31, 0, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f38, 0, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f39, 0, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f40, 0, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f41, 0, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f48, 0, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f49, 0, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f50, 0, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f51, 0, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f59, 0, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f60, 0, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f61, 0, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f68, 0, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f69, 0, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Tilde), 0x0055, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Tilde), 0x0075, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Macron), 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Macron), 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Macron), 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Macron), 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0049, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0069, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Abovering), 0x0041, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Abovering), 0x0061, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Cedilla), 0x0043, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Cedilla), 0x0063, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x0027, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x246b }, // U246B # CIRCLED NUMBER TWELVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b7 }, // U32B7 # CIRCLED NUMBER FORTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3253 }, // U3253 # CIRCLED NUMBER TWENTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3252 }, // U3252 # CIRCLED NUMBER TWENTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3253 }, // U3253 # CIRCLED NUMBER TWENTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x2473 }, // U2473 # CIRCLED NUMBER TWENTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b2 }, // U32B2 # CIRCLED NUMBER THIRTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b7 }, // U32B7 # CIRCLED NUMBER FORTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3252 }, // U3252 # CIRCLED NUMBER TWENTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x246d }, // U246D # CIRCLED NUMBER FOURTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32be }, // U32BE # CIRCLED NUMBER FORTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3254 }, // U3254 # CIRCLED NUMBER TWENTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x2470 }, // U2470 # CIRCLED NUMBER SEVENTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3252 }, // U3252 # CIRCLED NUMBER TWENTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32bc }, // U32BC # CIRCLED NUMBER FORTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3254 }, // U3254 # CIRCLED NUMBER TWENTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x246f }, // U246F # CIRCLED NUMBER SIXTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3252 }, // U3252 # CIRCLED NUMBER TWENTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32bb }, // U32BB # CIRCLED NUMBER FORTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b3 }, // U32B3 # CIRCLED NUMBER THIRTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b6 }, // U32B6 # CIRCLED NUMBER FORTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x2469 }, // U2469 # CIRCLED NUMBER TEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3255 }, // U3255 # CIRCLED NUMBER TWENTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3251 }, // U3251 # CIRCLED NUMBER TWENTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3257 }, // U3257 # CIRCLED NUMBER TWENTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3255 }, // U3255 # CIRCLED NUMBER TWENTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x325f }, // U325F # CIRCLED NUMBER THIRTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x325e }, // U325E # CIRCLED NUMBER THIRTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3251 }, // U3251 # CIRCLED NUMBER TWENTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b8 }, // U32B8 # CIRCLED NUMBER FORTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b1 }, // U32B1 # CIRCLED NUMBER THIRTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x325d }, // U325D # CIRCLED NUMBER THIRTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x2471 }, // U2471 # CIRCLED NUMBER EIGHTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x325c }, // U325C # CIRCLED NUMBER THIRTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3256 }, // U3256 # CIRCLED NUMBER TWENTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x325c }, // U325C # CIRCLED NUMBER THIRTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3256 }, // U3256 # CIRCLED NUMBER TWENTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x325b }, // U325B # CIRCLED NUMBER THIRTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x2473 }, // U2473 # CIRCLED NUMBER TWENTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x2472 }, // U2472 # CIRCLED NUMBER NINETEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x246c }, // U246C # CIRCLED NUMBER THIRTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b9 }, // U32B9 # CIRCLED NUMBER FORTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32ba }, // U32BA # CIRCLED NUMBER FORTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x325a }, // U325A # CIRCLED NUMBER THIRTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b5 }, // U32B5 # CIRCLED NUMBER FORTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3257 }, // U3257 # CIRCLED NUMBER TWENTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3259 }, // U3259 # CIRCLED NUMBER TWENTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3259 }, // U3259 # CIRCLED NUMBER TWENTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32b4 }, // U32B4 # CIRCLED NUMBER THIRTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3258 }, // U3258 # CIRCLED NUMBER TWENTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x3258 }, // U3258 # CIRCLED NUMBER TWENTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x246b }, // U246B # CIRCLED NUMBER TWELVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x246a }, // U246A # CIRCLED NUMBER ELEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x246e }, // U246E # CIRCLED NUMBER FIFTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32bd }, // U32BD # CIRCLED NUMBER FORTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0000, 0x0029, 0}, 0x32bf }, // U32BF # CIRCLED NUMBER FIFTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2461 }, // U2461 # CIRCLED DIGIT TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2461 }, // U2461 # CIRCLED DIGIT TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2462 }, // U2462 # CIRCLED DIGIT THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2468 }, // U2468 # CIRCLED DIGIT NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2463 }, // U2463 # CIRCLED DIGIT FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2460 }, // U2460 # CIRCLED DIGIT ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2467 }, // U2467 # CIRCLED DIGIT EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x24ea }, // U24EA # CIRCLED DIGIT ZERO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2466 }, // U2466 # CIRCLED DIGIT SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2465 }, // U2465 # CIRCLED DIGIT SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0029, 0, 0}, 0x2464 }, // U2464 # CIRCLED DIGIT FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0030, 0x0029, 0}, 0x32b5 }, // U32B5 # CIRCLED NUMBER FORTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0030, 0x0029, 0}, 0x2473 }, // U2473 # CIRCLED NUMBER TWENTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0030, 0x0029, 0}, 0x2469 }, // U2469 # CIRCLED NUMBER TEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0030, 0x0029, 0}, 0x32bf }, // U32BF # CIRCLED NUMBER FIFTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0030, 0x0029, 0}, 0x325a }, // U325A # CIRCLED NUMBER THIRTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0030, 0x0029, 0}, 0x2473 }, // U2473 # CIRCLED NUMBER TWENTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0031, 0x0029, 0}, 0x32b6 }, // U32B6 # CIRCLED NUMBER FORTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0031, 0x0029, 0}, 0x246a }, // U246A # CIRCLED NUMBER ELEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0031, 0x0029, 0}, 0x3251 }, // U3251 # CIRCLED NUMBER TWENTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0031, 0x0029, 0}, 0x325b }, // U325B # CIRCLED NUMBER THIRTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0031, 0x0029, 0}, 0x3251 }, // U3251 # CIRCLED NUMBER TWENTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0032, 0x0029, 0}, 0x3252 }, // U3252 # CIRCLED NUMBER TWENTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0032, 0x0029, 0}, 0x32b7 }, // U32B7 # CIRCLED NUMBER FORTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0032, 0x0029, 0}, 0x246b }, // U246B # CIRCLED NUMBER TWELVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0032, 0x0029, 0}, 0x325c }, // U325C # CIRCLED NUMBER THIRTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0032, 0x0029, 0}, 0x3252 }, // U3252 # CIRCLED NUMBER TWENTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0033, 0x0029, 0}, 0x246c }, // U246C # CIRCLED NUMBER THIRTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0033, 0x0029, 0}, 0x3253 }, // U3253 # CIRCLED NUMBER TWENTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0033, 0x0029, 0}, 0x325d }, // U325D # CIRCLED NUMBER THIRTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0033, 0x0029, 0}, 0x32b8 }, // U32B8 # CIRCLED NUMBER FORTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0033, 0x0029, 0}, 0x3253 }, // U3253 # CIRCLED NUMBER TWENTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0034, 0x0029, 0}, 0x246d }, // U246D # CIRCLED NUMBER FOURTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0034, 0x0029, 0}, 0x3254 }, // U3254 # CIRCLED NUMBER TWENTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0034, 0x0029, 0}, 0x32b9 }, // U32B9 # CIRCLED NUMBER FORTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0034, 0x0029, 0}, 0x3254 }, // U3254 # CIRCLED NUMBER TWENTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0034, 0x0029, 0}, 0x325e }, // U325E # CIRCLED NUMBER THIRTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0035, 0x0029, 0}, 0x3255 }, // U3255 # CIRCLED NUMBER TWENTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0035, 0x0029, 0}, 0x325f }, // U325F # CIRCLED NUMBER THIRTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0035, 0x0029, 0}, 0x32ba }, // U32BA # CIRCLED NUMBER FORTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0035, 0x0029, 0}, 0x3255 }, // U3255 # CIRCLED NUMBER TWENTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0035, 0x0029, 0}, 0x246e }, // U246E # CIRCLED NUMBER FIFTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0036, 0x0029, 0}, 0x3256 }, // U3256 # CIRCLED NUMBER TWENTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0036, 0x0029, 0}, 0x32bb }, // U32BB # CIRCLED NUMBER FORTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0036, 0x0029, 0}, 0x32b1 }, // U32B1 # CIRCLED NUMBER THIRTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0036, 0x0029, 0}, 0x246f }, // U246F # CIRCLED NUMBER SIXTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0036, 0x0029, 0}, 0x3256 }, // U3256 # CIRCLED NUMBER TWENTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0037, 0x0029, 0}, 0x32bc }, // U32BC # CIRCLED NUMBER FORTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0037, 0x0029, 0}, 0x3257 }, // U3257 # CIRCLED NUMBER TWENTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0037, 0x0029, 0}, 0x32b2 }, // U32B2 # CIRCLED NUMBER THIRTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0037, 0x0029, 0}, 0x2470 }, // U2470 # CIRCLED NUMBER SEVENTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0037, 0x0029, 0}, 0x3257 }, // U3257 # CIRCLED NUMBER TWENTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0038, 0x0029, 0}, 0x2471 }, // U2471 # CIRCLED NUMBER EIGHTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0038, 0x0029, 0}, 0x32b3 }, // U32B3 # CIRCLED NUMBER THIRTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0038, 0x0029, 0}, 0x32bd }, // U32BD # CIRCLED NUMBER FORTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0038, 0x0029, 0}, 0x3258 }, // U3258 # CIRCLED NUMBER TWENTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0038, 0x0029, 0}, 0x3258 }, // U3258 # CIRCLED NUMBER TWENTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0039, 0x0029, 0}, 0x32b4 }, // U32B4 # CIRCLED NUMBER THIRTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0039, 0x0029, 0}, 0x3259 }, // U3259 # CIRCLED NUMBER TWENTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0039, 0x0029, 0}, 0x32be }, // U32BE # CIRCLED NUMBER FORTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0039, 0x0029, 0}, 0x3259 }, // U3259 # CIRCLED NUMBER TWENTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0000, 0x0039, 0x0029, 0}, 0x2472 }, // U2472 # CIRCLED NUMBER NINETEEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0028, 0, 0, 0}, 0x005b }, // bracketleft + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x002d, 0, 0, 0}, 0x007b }, // braceleft + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0030, 0x0029, 0, 0}, 0x24ea }, // U24EA # CIRCLED DIGIT ZERO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x2472 }, // U2472 # CIRCLED NUMBER NINETEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x246e }, // U246E # CIRCLED NUMBER FIFTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x2469 }, // U2469 # CIRCLED NUMBER TEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x246c }, // U246C # CIRCLED NUMBER THIRTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x246b }, // U246B # CIRCLED NUMBER TWELVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x2470 }, // U2470 # CIRCLED NUMBER SEVENTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x246a }, // U246A # CIRCLED NUMBER ELEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x246d }, // U246D # CIRCLED NUMBER FOURTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x2471 }, // U2471 # CIRCLED NUMBER EIGHTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x246f }, // U246F # CIRCLED NUMBER SIXTEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0000, 0x0029, 0}, 0x246b }, // U246B # CIRCLED NUMBER TWELVE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0029, 0, 0}, 0x2460 }, // U2460 # CIRCLED DIGIT ONE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0030, 0x0029, 0}, 0x2469 }, // U2469 # CIRCLED NUMBER TEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0031, 0x0029, 0}, 0x246a }, // U246A # CIRCLED NUMBER ELEVEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0032, 0x0029, 0}, 0x246b }, // U246B # CIRCLED NUMBER TWELVE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0033, 0x0029, 0}, 0x246c }, // U246C # CIRCLED NUMBER THIRTEEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0034, 0x0029, 0}, 0x246d }, // U246D # CIRCLED NUMBER FOURTEEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0035, 0x0029, 0}, 0x246e }, // U246E # CIRCLED NUMBER FIFTEEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0036, 0x0029, 0}, 0x246f }, // U246F # CIRCLED NUMBER SIXTEEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0037, 0x0029, 0}, 0x2470 }, // U2470 # CIRCLED NUMBER SEVENTEEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0038, 0x0029, 0}, 0x2471 }, // U2471 # CIRCLED NUMBER EIGHTEEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0031, 0x0039, 0x0029, 0}, 0x2472 }, // U2472 # CIRCLED NUMBER NINETEEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x2473 }, // U2473 # CIRCLED NUMBER TWENTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3257 }, // U3257 # CIRCLED NUMBER TWENTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3259 }, // U3259 # CIRCLED NUMBER TWENTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3258 }, // U3258 # CIRCLED NUMBER TWENTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3253 }, // U3253 # CIRCLED NUMBER TWENTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3255 }, // U3255 # CIRCLED NUMBER TWENTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3252 }, // U3252 # CIRCLED NUMBER TWENTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3256 }, // U3256 # CIRCLED NUMBER TWENTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3251 }, // U3251 # CIRCLED NUMBER TWENTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3252 }, // U3252 # CIRCLED NUMBER TWENTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0000, 0x0029, 0}, 0x3254 }, // U3254 # CIRCLED NUMBER TWENTY FOUR + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0029, 0, 0}, 0x2461 }, // U2461 # CIRCLED DIGIT TWO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0030, 0x0029, 0}, 0x2473 }, // U2473 # CIRCLED NUMBER TWENTY + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0031, 0x0029, 0}, 0x3251 }, // U3251 # CIRCLED NUMBER TWENTY ONE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0032, 0x0029, 0}, 0x3252 }, // U3252 # CIRCLED NUMBER TWENTY TWO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0033, 0x0029, 0}, 0x3253 }, // U3253 # CIRCLED NUMBER TWENTY THREE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0034, 0x0029, 0}, 0x3254 }, // U3254 # CIRCLED NUMBER TWENTY FOUR + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0035, 0x0029, 0}, 0x3255 }, // U3255 # CIRCLED NUMBER TWENTY FIVE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0036, 0x0029, 0}, 0x3256 }, // U3256 # CIRCLED NUMBER TWENTY SIX + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0037, 0x0029, 0}, 0x3257 }, // U3257 # CIRCLED NUMBER TWENTY SEVEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0038, 0x0029, 0}, 0x3258 }, // U3258 # CIRCLED NUMBER TWENTY EIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0032, 0x0039, 0x0029, 0}, 0x3259 }, // U3259 # CIRCLED NUMBER TWENTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x32b4 }, // U32B4 # CIRCLED NUMBER THIRTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x325a }, // U325A # CIRCLED NUMBER THIRTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x325b }, // U325B # CIRCLED NUMBER THIRTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x32b3 }, // U32B3 # CIRCLED NUMBER THIRTY EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x32b2 }, // U32B2 # CIRCLED NUMBER THIRTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x325c }, // U325C # CIRCLED NUMBER THIRTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x325c }, // U325C # CIRCLED NUMBER THIRTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x325f }, // U325F # CIRCLED NUMBER THIRTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x325e }, // U325E # CIRCLED NUMBER THIRTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x32b1 }, // U32B1 # CIRCLED NUMBER THIRTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0000, 0x0029, 0}, 0x325d }, // U325D # CIRCLED NUMBER THIRTY THREE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0029, 0, 0}, 0x2462 }, // U2462 # CIRCLED DIGIT THREE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0030, 0x0029, 0}, 0x325a }, // U325A # CIRCLED NUMBER THIRTY + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0031, 0x0029, 0}, 0x325b }, // U325B # CIRCLED NUMBER THIRTY ONE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0032, 0x0029, 0}, 0x325c }, // U325C # CIRCLED NUMBER THIRTY TWO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0033, 0x0029, 0}, 0x325d }, // U325D # CIRCLED NUMBER THIRTY THREE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0034, 0x0029, 0}, 0x325e }, // U325E # CIRCLED NUMBER THIRTY FOUR + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0035, 0x0029, 0}, 0x325f }, // U325F # CIRCLED NUMBER THIRTY FIVE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0036, 0x0029, 0}, 0x32b1 }, // U32B1 # CIRCLED NUMBER THIRTY SIX + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0037, 0x0029, 0}, 0x32b2 }, // U32B2 # CIRCLED NUMBER THIRTY SEVEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0038, 0x0029, 0}, 0x32b3 }, // U32B3 # CIRCLED NUMBER THIRTY EIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0033, 0x0039, 0x0029, 0}, 0x32b4 }, // U32B4 # CIRCLED NUMBER THIRTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32b7 }, // U32B7 # CIRCLED NUMBER FORTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32b5 }, // U32B5 # CIRCLED NUMBER FORTY +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32b6 }, // U32B6 # CIRCLED NUMBER FORTY ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32bc }, // U32BC # CIRCLED NUMBER FORTY SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32b7 }, // U32B7 # CIRCLED NUMBER FORTY TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32b9 }, // U32B9 # CIRCLED NUMBER FORTY FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32b8 }, // U32B8 # CIRCLED NUMBER FORTY THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32bb }, // U32BB # CIRCLED NUMBER FORTY SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32be }, // U32BE # CIRCLED NUMBER FORTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32ba }, // U32BA # CIRCLED NUMBER FORTY FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0000, 0x0029, 0}, 0x32bd }, // U32BD # CIRCLED NUMBER FORTY EIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0029, 0, 0}, 0x2463 }, // U2463 # CIRCLED DIGIT FOUR + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0030, 0x0029, 0}, 0x32b5 }, // U32B5 # CIRCLED NUMBER FORTY + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0031, 0x0029, 0}, 0x32b6 }, // U32B6 # CIRCLED NUMBER FORTY ONE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0032, 0x0029, 0}, 0x32b7 }, // U32B7 # CIRCLED NUMBER FORTY TWO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0033, 0x0029, 0}, 0x32b8 }, // U32B8 # CIRCLED NUMBER FORTY THREE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0034, 0x0029, 0}, 0x32b9 }, // U32B9 # CIRCLED NUMBER FORTY FOUR + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0035, 0x0029, 0}, 0x32ba }, // U32BA # CIRCLED NUMBER FORTY FIVE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0036, 0x0029, 0}, 0x32bb }, // U32BB # CIRCLED NUMBER FORTY SIX + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0037, 0x0029, 0}, 0x32bc }, // U32BC # CIRCLED NUMBER FORTY SEVEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0038, 0x0029, 0}, 0x32bd }, // U32BD # CIRCLED NUMBER FORTY EIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0034, 0x0039, 0x0029, 0}, 0x32be }, // U32BE # CIRCLED NUMBER FORTY NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0035, 0x0000, 0x0029, 0}, 0x32bf }, // U32BF # CIRCLED NUMBER FIFTY + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0035, 0x0029, 0, 0}, 0x2464 }, // U2464 # CIRCLED DIGIT FIVE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0035, 0x0030, 0x0029, 0}, 0x32bf }, // U32BF # CIRCLED NUMBER FIFTY + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0036, 0x0029, 0, 0}, 0x2465 }, // U2465 # CIRCLED DIGIT SIX + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0037, 0x0029, 0, 0}, 0x2466 }, // U2466 # CIRCLED DIGIT SEVEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0038, 0x0029, 0, 0}, 0x2467 }, // U2467 # CIRCLED DIGIT EIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0039, 0x0029, 0, 0}, 0x2468 }, // U2468 # CIRCLED DIGIT NINE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0041, 0x0029, 0, 0}, 0x24b6 }, // U24B6 # CIRCLED LATIN CAPITAL LETTER A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0042, 0x0029, 0, 0}, 0x24b7 }, // U24B7 # CIRCLED LATIN CAPITAL LETTER B + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0043, 0x0029, 0, 0}, 0x24b8 }, // U24B8 # CIRCLED LATIN CAPITAL LETTER C + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0044, 0x0029, 0, 0}, 0x24b9 }, // U24B9 # CIRCLED LATIN CAPITAL LETTER D + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0045, 0x0029, 0, 0}, 0x24ba }, // U24BA # CIRCLED LATIN CAPITAL LETTER E + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0046, 0x0029, 0, 0}, 0x24bb }, // U24BB # CIRCLED LATIN CAPITAL LETTER F + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0047, 0x0029, 0, 0}, 0x24bc }, // U24BC # CIRCLED LATIN CAPITAL LETTER G + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0048, 0x0029, 0, 0}, 0x24bd }, // U24BD # CIRCLED LATIN CAPITAL LETTER H + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0049, 0x0029, 0, 0}, 0x24be }, // U24BE # CIRCLED LATIN CAPITAL LETTER I + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x004a, 0x0029, 0, 0}, 0x24bf }, // U24BF # CIRCLED LATIN CAPITAL LETTER J + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x004b, 0x0029, 0, 0}, 0x24c0 }, // U24C0 # CIRCLED LATIN CAPITAL LETTER K + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x004c, 0x0029, 0, 0}, 0x24c1 }, // U24C1 # CIRCLED LATIN CAPITAL LETTER L + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x004d, 0x0029, 0, 0}, 0x24c2 }, // U24C2 # CIRCLED LATIN CAPITAL LETTER M + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x004e, 0x0029, 0, 0}, 0x24c3 }, // U24C3 # CIRCLED LATIN CAPITAL LETTER N + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x004f, 0x0029, 0, 0}, 0x24c4 }, // U24C4 # CIRCLED LATIN CAPITAL LETTER O + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0050, 0x0029, 0, 0}, 0x24c5 }, // U24C5 # CIRCLED LATIN CAPITAL LETTER P + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0051, 0x0029, 0, 0}, 0x24c6 }, // U24C6 # CIRCLED LATIN CAPITAL LETTER Q + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0052, 0x0029, 0, 0}, 0x24c7 }, // U24C7 # CIRCLED LATIN CAPITAL LETTER R + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0053, 0x0029, 0, 0}, 0x24c8 }, // U24C8 # CIRCLED LATIN CAPITAL LETTER S + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0054, 0x0029, 0, 0}, 0x24c9 }, // U24C9 # CIRCLED LATIN CAPITAL LETTER T + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0055, 0x0029, 0, 0}, 0x24ca }, // U24CA # CIRCLED LATIN CAPITAL LETTER U + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0056, 0x0029, 0, 0}, 0x24cb }, // U24CB # CIRCLED LATIN CAPITAL LETTER V + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0057, 0x0029, 0, 0}, 0x24cc }, // U24CC # CIRCLED LATIN CAPITAL LETTER W + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0058, 0x0029, 0, 0}, 0x24cd }, // U24CD # CIRCLED LATIN CAPITAL LETTER X + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0059, 0x0029, 0, 0}, 0x24ce }, // U24CE # CIRCLED LATIN CAPITAL LETTER Y + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x005a, 0x0029, 0, 0}, 0x24cf }, // U24CF # CIRCLED LATIN CAPITAL LETTER Z + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0061, 0x0029, 0, 0}, 0x24d0 }, // U24D0 # CIRCLED LATIN SMALL LETTER A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0062, 0x0029, 0, 0}, 0x24d1 }, // U24D1 # CIRCLED LATIN SMALL LETTER B + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0063, 0x0029, 0, 0}, 0x24d2 }, // U24D2 # CIRCLED LATIN SMALL LETTER C + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0064, 0x0029, 0, 0}, 0x24d3 }, // U24D3 # CIRCLED LATIN SMALL LETTER D + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0065, 0x0029, 0, 0}, 0x24d4 }, // U24D4 # CIRCLED LATIN SMALL LETTER E + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0066, 0x0029, 0, 0}, 0x24d5 }, // U24D5 # CIRCLED LATIN SMALL LETTER F + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0067, 0x0029, 0, 0}, 0x24d6 }, // U24D6 # CIRCLED LATIN SMALL LETTER G + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0068, 0x0029, 0, 0}, 0x24d7 }, // U24D7 # CIRCLED LATIN SMALL LETTER H + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0069, 0x0029, 0, 0}, 0x24d8 }, // U24D8 # CIRCLED LATIN SMALL LETTER I + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x006a, 0x0029, 0, 0}, 0x24d9 }, // U24D9 # CIRCLED LATIN SMALL LETTER J + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x006b, 0x0029, 0, 0}, 0x24da }, // U24DA # CIRCLED LATIN SMALL LETTER K + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x006c, 0x0029, 0, 0}, 0x24db }, // U24DB # CIRCLED LATIN SMALL LETTER L + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x006d, 0x0029, 0, 0}, 0x24dc }, // U24DC # CIRCLED LATIN SMALL LETTER M + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x006e, 0x0029, 0, 0}, 0x24dd }, // U24DD # CIRCLED LATIN SMALL LETTER N + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x006f, 0x0029, 0, 0}, 0x24de }, // U24DE # CIRCLED LATIN SMALL LETTER O + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0070, 0x0029, 0, 0}, 0x24df }, // U24DF # CIRCLED LATIN SMALL LETTER P + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0071, 0x0029, 0, 0}, 0x24e0 }, // U24E0 # CIRCLED LATIN SMALL LETTER Q + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0072, 0x0029, 0, 0}, 0x24e1 }, // U24E1 # CIRCLED LATIN SMALL LETTER R + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0073, 0x0029, 0, 0}, 0x24e2 }, // U24E2 # CIRCLED LATIN SMALL LETTER S + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0074, 0x0029, 0, 0}, 0x24e3 }, // U24E3 # CIRCLED LATIN SMALL LETTER T + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0075, 0x0029, 0, 0}, 0x24e4 }, // U24E4 # CIRCLED LATIN SMALL LETTER U + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0076, 0x0029, 0, 0}, 0x24e5 }, // U24E5 # CIRCLED LATIN SMALL LETTER V + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0077, 0x0029, 0, 0}, 0x24e6 }, // U24E6 # CIRCLED LATIN SMALL LETTER W + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0078, 0x0029, 0, 0}, 0x24e7 }, // U24E7 # CIRCLED LATIN SMALL LETTER X + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0079, 0x0029, 0, 0}, 0x24e8 }, // U24E8 # CIRCLED LATIN SMALL LETTER Y + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x007a, 0x0029, 0, 0}, 0x24e9 }, // U24E9 # CIRCLED LATIN SMALL LETTER Z + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0, 0, 0}, 0x1f09 }, // U1F09 # GREEK CAPITAL LETTER ALPHA WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0395, 0, 0, 0}, 0x1f19 }, // U1F19 # GREEK CAPITAL LETTER EPSILON WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0, 0, 0}, 0x1f29 }, // U1F29 # GREEK CAPITAL LETTER ETA WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0399, 0, 0, 0}, 0x1f39 }, // U1F39 # GREEK CAPITAL LETTER IOTA WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x039f, 0, 0, 0}, 0x1f49 }, // U1F49 # GREEK CAPITAL LETTER OMICRON WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a1, 0, 0, 0}, 0x1fec }, // U1FEC # GREEK CAPITAL LETTER RHO WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a5, 0, 0, 0}, 0x1f59 }, // U1F59 # GREEK CAPITAL LETTER UPSILON WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0, 0, 0}, 0x1f69 }, // U1F69 # GREEK CAPITAL LETTER OMEGA WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0, 0, 0}, 0x1f01 }, // U1F01 # GREEK SMALL LETTER ALPHA WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b5, 0, 0, 0}, 0x1f11 }, // U1F11 # GREEK SMALL LETTER EPSILON WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0, 0, 0}, 0x1f21 }, // U1F21 # GREEK SMALL LETTER ETA WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b9, 0, 0, 0}, 0x1f31 }, // U1F31 # GREEK SMALL LETTER IOTA WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03bf, 0, 0, 0}, 0x1f41 }, // U1F41 # GREEK SMALL LETTER OMICRON WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c1, 0, 0, 0}, 0x1fe5 }, // U1FE5 # GREEK SMALL LETTER RHO WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c5, 0, 0, 0}, 0x1f51 }, // U1F51 # GREEK SMALL LETTER UPSILON WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0, 0, 0}, 0x1f61 }, // U1F61 # GREEK SMALL LETTER OMEGA WITH DASIA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1100, 0x0029, 0, 0}, 0x3260 }, // U3260 # CIRCLED HANGUL KIYEOK + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1100, 0x1161, 0x0029, 0}, 0x326e }, // U326E # CIRCLED HANGUL KIYEOK A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1102, 0x0029, 0, 0}, 0x3261 }, // U3261 # CIRCLED HANGUL NIEUN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1102, 0x1161, 0x0029, 0}, 0x326f }, // U326F # CIRCLED HANGUL NIEUN A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1103, 0x0029, 0, 0}, 0x3262 }, // U3262 # CIRCLED HANGUL TIKEUT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1103, 0x1161, 0x0029, 0}, 0x3270 }, // U3270 # CIRCLED HANGUL TIKEUT A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1105, 0x0029, 0, 0}, 0x3263 }, // U3263 # CIRCLED HANGUL RIEUL + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1105, 0x1161, 0x0029, 0}, 0x3271 }, // U3271 # CIRCLED HANGUL RIEUL A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1106, 0x0029, 0, 0}, 0x3264 }, // U3264 # CIRCLED HANGUL MIEUM + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1106, 0x1161, 0x0029, 0}, 0x3272 }, // U3272 # CIRCLED HANGUL MIEUM A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1107, 0x0029, 0, 0}, 0x3265 }, // U3265 # CIRCLED HANGUL PIEUP + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1107, 0x1161, 0x0029, 0}, 0x3273 }, // U3273 # CIRCLED HANGUL PIEUP A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1109, 0x0029, 0, 0}, 0x3266 }, // U3266 # CIRCLED HANGUL SIOS + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1109, 0x1161, 0x0029, 0}, 0x3274 }, // U3274 # CIRCLED HANGUL SIOS A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x110b, 0x0029, 0, 0}, 0x3267 }, // U3267 # CIRCLED HANGUL IEUNG + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x110b, 0x1161, 0x0029, 0}, 0x3275 }, // U3275 # CIRCLED HANGUL IEUNG A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x110c, 0x0029, 0, 0}, 0x3268 }, // U3268 # CIRCLED HANGUL CIEUC + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x110c, 0x1161, 0x0029, 0}, 0x3276 }, // U3276 # CIRCLED HANGUL CIEUC A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x110e, 0x0029, 0, 0}, 0x3269 }, // U3269 # CIRCLED HANGUL CHIEUCH + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x110e, 0x1161, 0x0029, 0}, 0x3277 }, // U3277 # CIRCLED HANGUL CHIEUCH A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x110f, 0x0029, 0, 0}, 0x326a }, // U326A # CIRCLED HANGUL KHIEUKH + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x110f, 0x1161, 0x0029, 0}, 0x3278 }, // U3278 # CIRCLED HANGUL KHIEUKH A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1110, 0x0029, 0, 0}, 0x326b }, // U326B # CIRCLED HANGUL THIEUTH + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1110, 0x1161, 0x0029, 0}, 0x3279 }, // U3279 # CIRCLED HANGUL THIEUTH A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1111, 0x0029, 0, 0}, 0x326c }, // U326C # CIRCLED HANGUL PHIEUPH + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1111, 0x1161, 0x0029, 0}, 0x327a }, // U327A # CIRCLED HANGUL PHIEUPH A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1112, 0x0029, 0, 0}, 0x326d }, // U326D # CIRCLED HANGUL HIEUH + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x1112, 0x1161, 0x0029, 0}, 0x327b }, // U327B # CIRCLED HANGUL HIEUH A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30a2, 0x0029, 0, 0}, 0x32d0 }, // U32D0 # CIRCLED KATAKANA A + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30a4, 0x0029, 0, 0}, 0x32d1 }, // U32D1 # CIRCLED KATAKANA I + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30a6, 0x0029, 0, 0}, 0x32d2 }, // U32D2 # CIRCLED KATAKANA U + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30a8, 0x0029, 0, 0}, 0x32d3 }, // U32D3 # CIRCLED KATAKANA E + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30aa, 0x0029, 0, 0}, 0x32d4 }, // U32D4 # CIRCLED KATAKANA O + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30ab, 0x0029, 0, 0}, 0x32d5 }, // U32D5 # CIRCLED KATAKANA KA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30ad, 0x0029, 0, 0}, 0x32d6 }, // U32D6 # CIRCLED KATAKANA KI + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30af, 0x0029, 0, 0}, 0x32d7 }, // U32D7 # CIRCLED KATAKANA KU + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30b1, 0x0029, 0, 0}, 0x32d8 }, // U32D8 # CIRCLED KATAKANA KE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30b3, 0x0029, 0, 0}, 0x32d9 }, // U32D9 # CIRCLED KATAKANA KO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30b5, 0x0029, 0, 0}, 0x32da }, // U32DA # CIRCLED KATAKANA SA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30b7, 0x0029, 0, 0}, 0x32db }, // U32DB # CIRCLED KATAKANA SI + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30b9, 0x0029, 0, 0}, 0x32dc }, // U32DC # CIRCLED KATAKANA SU + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30bb, 0x0029, 0, 0}, 0x32dd }, // U32DD # CIRCLED KATAKANA SE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30bd, 0x0029, 0, 0}, 0x32de }, // U32DE # CIRCLED KATAKANA SO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30bf, 0x0029, 0, 0}, 0x32df }, // U32DF # CIRCLED KATAKANA TA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30c1, 0x0029, 0, 0}, 0x32e0 }, // U32E0 # CIRCLED KATAKANA TI + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30c4, 0x0029, 0, 0}, 0x32e1 }, // U32E1 # CIRCLED KATAKANA TU + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30c6, 0x0029, 0, 0}, 0x32e2 }, // U32E2 # CIRCLED KATAKANA TE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30c8, 0x0029, 0, 0}, 0x32e3 }, // U32E3 # CIRCLED KATAKANA TO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30ca, 0x0029, 0, 0}, 0x32e4 }, // U32E4 # CIRCLED KATAKANA NA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30cb, 0x0029, 0, 0}, 0x32e5 }, // U32E5 # CIRCLED KATAKANA NI + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30cc, 0x0029, 0, 0}, 0x32e6 }, // U32E6 # CIRCLED KATAKANA NU + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30cd, 0x0029, 0, 0}, 0x32e7 }, // U32E7 # CIRCLED KATAKANA NE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30ce, 0x0029, 0, 0}, 0x32e8 }, // U32E8 # CIRCLED KATAKANA NO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30cf, 0x0029, 0, 0}, 0x32e9 }, // U32E9 # CIRCLED KATAKANA HA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30d2, 0x0029, 0, 0}, 0x32ea }, // U32EA # CIRCLED KATAKANA HI + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30d5, 0x0029, 0, 0}, 0x32eb }, // U32EB # CIRCLED KATAKANA HU + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30d8, 0x0029, 0, 0}, 0x32ec }, // U32EC # CIRCLED KATAKANA HE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30db, 0x0029, 0, 0}, 0x32ed }, // U32ED # CIRCLED KATAKANA HO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30de, 0x0029, 0, 0}, 0x32ee }, // U32EE # CIRCLED KATAKANA MA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30df, 0x0029, 0, 0}, 0x32ef }, // U32EF # CIRCLED KATAKANA MI + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30e0, 0x0029, 0, 0}, 0x32f0 }, // U32F0 # CIRCLED KATAKANA MU + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30e1, 0x0029, 0, 0}, 0x32f1 }, // U32F1 # CIRCLED KATAKANA ME + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30e2, 0x0029, 0, 0}, 0x32f2 }, // U32F2 # CIRCLED KATAKANA MO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30e4, 0x0029, 0, 0}, 0x32f3 }, // U32F3 # CIRCLED KATAKANA YA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30e6, 0x0029, 0, 0}, 0x32f4 }, // U32F4 # CIRCLED KATAKANA YU + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30e8, 0x0029, 0, 0}, 0x32f5 }, // U32F5 # CIRCLED KATAKANA YO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30e9, 0x0029, 0, 0}, 0x32f6 }, // U32F6 # CIRCLED KATAKANA RA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30ea, 0x0029, 0, 0}, 0x32f7 }, // U32F7 # CIRCLED KATAKANA RI + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30eb, 0x0029, 0, 0}, 0x32f8 }, // U32F8 # CIRCLED KATAKANA RU + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30ec, 0x0029, 0, 0}, 0x32f9 }, // U32F9 # CIRCLED KATAKANA RE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30ed, 0x0029, 0, 0}, 0x32fa }, // U32FA # CIRCLED KATAKANA RO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30ef, 0x0029, 0, 0}, 0x32fb }, // U32FB # CIRCLED KATAKANA WA + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30f0, 0x0029, 0, 0}, 0x32fc }, // U32FC # CIRCLED KATAKANA WI + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30f1, 0x0029, 0, 0}, 0x32fd }, // U32FD # CIRCLED KATAKANA WE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x30f2, 0x0029, 0, 0}, 0x32fe }, // U32FE # CIRCLED KATAKANA WO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4e00, 0x0029, 0, 0}, 0x3280 }, // U3280 # CIRCLED IDEOGRAPH ONE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4e03, 0x0029, 0, 0}, 0x3286 }, // U3286 # CIRCLED IDEOGRAPH SEVEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4e09, 0x0029, 0, 0}, 0x3282 }, // U3282 # CIRCLED IDEOGRAPH THREE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4e0a, 0x0029, 0, 0}, 0x32a4 }, // U32A4 # CIRCLED IDEOGRAPH HIGH + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4e0b, 0x0029, 0, 0}, 0x32a6 }, // U32A6 # CIRCLED IDEOGRAPH LOW + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4e2d, 0x0029, 0, 0}, 0x32a5 }, // U32A5 # CIRCLED IDEOGRAPH CENTRE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4e5d, 0x0029, 0, 0}, 0x3288 }, // U3288 # CIRCLED IDEOGRAPH NINE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4e8c, 0x0029, 0, 0}, 0x3281 }, // U3281 # CIRCLED IDEOGRAPH TWO + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4e94, 0x0029, 0, 0}, 0x3284 }, // U3284 # CIRCLED IDEOGRAPH FIVE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4f01, 0x0029, 0, 0}, 0x32ad }, // U32AD # CIRCLED IDEOGRAPH ENTERPRISE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x4f11, 0x0029, 0, 0}, 0x32a1 }, // U32A1 # CIRCLED IDEOGRAPH REST + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x512a, 0x0029, 0, 0}, 0x329d }, // U329D # CIRCLED IDEOGRAPH EXCELLENT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x516b, 0x0029, 0, 0}, 0x3287 }, // U3287 # CIRCLED IDEOGRAPH EIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x516d, 0x0029, 0, 0}, 0x3285 }, // U3285 # CIRCLED IDEOGRAPH SIX + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x5199, 0x0029, 0, 0}, 0x32a2 }, // U32A2 # CIRCLED IDEOGRAPH COPY + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x52b4, 0x0029, 0, 0}, 0x3298 }, // U3298 # CIRCLED IDEOGRAPH LABOR + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x533b, 0x0029, 0, 0}, 0x32a9 }, // U32A9 # CIRCLED IDEOGRAPH MEDICINE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x5341, 0x0029, 0, 0}, 0x3289 }, // U3289 # CIRCLED IDEOGRAPH TEN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x5354, 0x0029, 0, 0}, 0x32af }, // U32AF # CIRCLED IDEOGRAPH ALLIANCE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x5370, 0x0029, 0, 0}, 0x329e }, // U329E # CIRCLED IDEOGRAPH PRINT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x53f3, 0x0029, 0, 0}, 0x32a8 }, // U32A8 # CIRCLED IDEOGRAPH RIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x540d, 0x0029, 0, 0}, 0x3294 }, // U3294 # CIRCLED IDEOGRAPH NAME + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x56db, 0x0029, 0, 0}, 0x3283 }, // U3283 # CIRCLED IDEOGRAPH FOUR + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x571f, 0x0029, 0, 0}, 0x328f }, // U328F # CIRCLED IDEOGRAPH EARTH + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x591c, 0x0029, 0, 0}, 0x32b0 }, // U32B0 # CIRCLED IDEOGRAPH NIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x5973, 0x0029, 0, 0}, 0x329b }, // U329B # CIRCLED IDEOGRAPH FEMALE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x5b66, 0x0029, 0, 0}, 0x32ab }, // U32AB # CIRCLED IDEOGRAPH STUDY + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x5b97, 0x0029, 0, 0}, 0x32aa }, // U32AA # CIRCLED IDEOGRAPH RELIGION + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x5de6, 0x0029, 0, 0}, 0x32a7 }, // U32A7 # CIRCLED IDEOGRAPH LEFT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x65e5, 0x0029, 0, 0}, 0x3290 }, // U3290 # CIRCLED IDEOGRAPH SUN + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x6708, 0x0029, 0, 0}, 0x328a }, // U328A # CIRCLED IDEOGRAPH MOON + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x6709, 0x0029, 0, 0}, 0x3292 }, // U3292 # CIRCLED IDEOGRAPH HAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x6728, 0x0029, 0, 0}, 0x328d }, // U328D # CIRCLED IDEOGRAPH WOOD + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x682a, 0x0029, 0, 0}, 0x3291 }, // U3291 # CIRCLED IDEOGRAPH STOCK + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x6b63, 0x0029, 0, 0}, 0x32a3 }, // U32A3 # CIRCLED IDEOGRAPH CORRECT + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x6c34, 0x0029, 0, 0}, 0x328c }, // U328C # CIRCLED IDEOGRAPH WATER + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x6ce8, 0x0029, 0, 0}, 0x329f }, // U329F # CIRCLED IDEOGRAPH ATTENTION + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x706b, 0x0029, 0, 0}, 0x328b }, // U328B # CIRCLED IDEOGRAPH FIRE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x7279, 0x0029, 0, 0}, 0x3295 }, // U3295 # CIRCLED IDEOGRAPH SPECIAL + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x7537, 0x0029, 0, 0}, 0x329a }, // U329A # CIRCLED IDEOGRAPH MALE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x76e3, 0x0029, 0, 0}, 0x32ac }, // U32AC # CIRCLED IDEOGRAPH SUPERVISE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x793e, 0x0029, 0, 0}, 0x3293 }, // U3293 # CIRCLED IDEOGRAPH SOCIETY + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x795d, 0x0029, 0, 0}, 0x3297 }, // U3297 # CIRCLED IDEOGRAPH CONGRATULATION + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x79d8, 0x0029, 0, 0}, 0x3299 }, // U3299 # CIRCLED IDEOGRAPH SECRET + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x8ca1, 0x0029, 0, 0}, 0x3296 }, // U3296 # CIRCLED IDEOGRAPH FINANCIAL + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x8cc7, 0x0029, 0, 0}, 0x32ae }, // U32AE # CIRCLED IDEOGRAPH RESOURCE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x9069, 0x0029, 0, 0}, 0x329c }, // U329C # CIRCLED IDEOGRAPH SUITABLE + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x91d1, 0x0029, 0, 0}, 0x328e }, // U328E # CIRCLED IDEOGRAPH METAL + { {UNITIZE(TQt::Key_Multi_key), 0x0028, 0x9805, 0x0029, 0, 0}, 0x32a0 }, // U32A0 # CIRCLED IDEOGRAPH ITEM + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0029, 0, 0, 0}, 0x005d }, // bracketright + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x002d, 0, 0, 0}, 0x007d }, // braceright + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0, 0, 0}, 0x1f08 }, // U1F08 # GREEK CAPITAL LETTER ALPHA WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0395, 0, 0, 0}, 0x1f18 }, // U1F18 # GREEK CAPITAL LETTER EPSILON WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0, 0, 0}, 0x1f28 }, // U1F28 # GREEK CAPITAL LETTER ETA WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0399, 0, 0, 0}, 0x1f38 }, // U1F38 # GREEK CAPITAL LETTER IOTA WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x039f, 0, 0, 0}, 0x1f48 }, // U1F48 # GREEK CAPITAL LETTER OMICRON WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0, 0, 0}, 0x1f68 }, // U1F68 # GREEK CAPITAL LETTER OMEGA WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0, 0, 0}, 0x1f00 }, // U1F00 # GREEK SMALL LETTER ALPHA WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b5, 0, 0, 0}, 0x1f10 }, // U1F10 # GREEK SMALL LETTER EPSILON WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0, 0, 0}, 0x1f20 }, // U1F20 # GREEK SMALL LETTER ETA WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b9, 0, 0, 0}, 0x1f30 }, // U1F30 # GREEK SMALL LETTER IOTA WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03bf, 0, 0, 0}, 0x1f40 }, // U1F40 # GREEK SMALL LETTER OMICRON WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c1, 0, 0, 0}, 0x1fe4 }, // U1FE4 # GREEK SMALL LETTER RHO WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c5, 0, 0, 0}, 0x1f50 }, // U1F50 # GREEK SMALL LETTER UPSILON WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0, 0, 0}, 0x1f60 }, // U1F60 # GREEK SMALL LETTER OMEGA WITH PSILI + { {UNITIZE(TQt::Key_Multi_key), 0x002b, 0x002b, 0, 0, 0}, 0x0023 }, // numbersign + { {UNITIZE(TQt::Key_Multi_key), 0x002b, 0x002d, 0, 0, 0}, 0x00b1 }, // plusminus + { {UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0, 0}, 0x01a0 }, // U01A0 # LATIN CAPITAL LETTER O WITH HORN + { {UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0, 0}, 0x01af }, // U01AF # LATIN CAPITAL LETTER U WITH HORN + { {UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0, 0}, 0x01a1 }, // U01A1 # LATIN SMALL LETTER O WITH HORN + { {UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0, 0}, 0x01b0 }, // U01B0 # LATIN SMALL LETTER U WITH HORN + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0020, 0, 0, 0}, 0x00b8 }, // cedilla + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0022, 0, 0, 0}, 0x201e }, // U201e # DOUBLE LOW-9 TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0027, 0, 0, 0}, 0x201a }, // U201a # SINGLE LOW-9 TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x002d, 0, 0, 0}, 0x00ac }, // U00AC # NOT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0043, 0, 0, 0}, 0x00c7 }, // U00C7 # LATIN CAPITAL LETTER C WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0044, 0, 0, 0}, 0x1e10 }, // U1E10 # LATIN CAPITAL LETTER D WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0045, 0, 0, 0}, 0x0228 }, // U0228 # LATIN CAPITAL LETTER E WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0047, 0, 0, 0}, 0x0122 }, // U0122 # LATIN CAPITAL LETTER G WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0048, 0, 0, 0}, 0x1e28 }, // U1E28 # LATIN CAPITAL LETTER H WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x004b, 0, 0, 0}, 0x0136 }, // U0136 # LATIN CAPITAL LETTER K WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x004c, 0, 0, 0}, 0x013b }, // U013B # LATIN CAPITAL LETTER L WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x004e, 0, 0, 0}, 0x0145 }, // U0145 # LATIN CAPITAL LETTER N WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0052, 0, 0, 0}, 0x0156 }, // U0156 # LATIN CAPITAL LETTER R WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0053, 0, 0, 0}, 0x015e }, // U015E # LATIN CAPITAL LETTER S WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0054, 0, 0, 0}, 0x0162 }, // U0162 # LATIN CAPITAL LETTER T WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0063, 0, 0, 0}, 0x00e7 }, // U00E7 # LATIN SMALL LETTER C WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0064, 0, 0, 0}, 0x1e11 }, // U1E11 # LATIN SMALL LETTER D WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0065, 0, 0, 0}, 0x0229 }, // U0229 # LATIN SMALL LETTER E WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0067, 0, 0, 0}, 0x0123 }, // U0123 # LATIN SMALL LETTER G WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0068, 0, 0, 0}, 0x1e29 }, // U1E29 # LATIN SMALL LETTER H WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x006b, 0, 0, 0}, 0x0137 }, // U0137 # LATIN SMALL LETTER K WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x006c, 0, 0, 0}, 0x013c }, // U013C # LATIN SMALL LETTER L WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x006e, 0, 0, 0}, 0x0146 }, // U0146 # LATIN SMALL LETTER N WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0072, 0, 0, 0}, 0x0157 }, // U0157 # LATIN SMALL LETTER R WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0073, 0, 0, 0}, 0x015f }, // U015F # LATIN SMALL LETTER S WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0074, 0, 0, 0}, 0x0163 }, // U0163 # LATIN SMALL LETTER T WITH CEDILLA + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x0020, 0, 0, 0}, 0x007e }, // asciitilde + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x0028, 0, 0, 0}, 0x007b }, // braceleft + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x0029, 0, 0, 0}, 0x007d }, // braceright + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x002c, 0, 0, 0}, 0x00ac }, // U00AC # NOT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x002d, 0x002d, 0, 0}, 0x2014 }, // U2014 # EM DASH + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x002d, 0x002e, 0, 0}, 0x2013 }, // U2013 # EN DASH + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x003a, 0, 0, 0}, 0x00f7 }, // U00F7 # DIVISION SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x0044, 0, 0, 0}, 0x0110 }, // Dstroke + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x004c, 0, 0, 0}, 0x00a3 }, // U00a3 # POUND SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x002d, 0x0064, 0, 0, 0}, 0x0111 }, // dstroke +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0000, 0x0053, 0, 0}, 0x1e68 }, // U1E68 # LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0000, 0x0053, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0000, 0x0073, 0, 0}, 0x1e69 }, // U1E69 # LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0000, 0x0073, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0021, 0x0053, 0, 0}, 0x1e68 }, // U1E68 # LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0021, 0x0073, 0, 0}, 0x1e69 }, // U1E69 # LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0027, 0x0053, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0027, 0x0073, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x002e, 0, 0, 0}, 0x00b7 }, // U00B7 + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x003c, 0, 0, 0}, 0x2039 }, // U2039 + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x003e, 0, 0, 0}, 0x203a }, // U203a + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0041, 0, 0, 0}, 0x0226 }, // U0226 # LATIN CAPITAL LETTER A WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0042, 0, 0, 0}, 0x1e02 }, // U1E02 # LATIN CAPITAL LETTER B WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0043, 0, 0, 0}, 0x010a }, // U010A # LATIN CAPITAL LETTER C WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0044, 0, 0, 0}, 0x1e0a }, // U1E0A # LATIN CAPITAL LETTER D WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0045, 0, 0, 0}, 0x0116 }, // U0116 # LATIN CAPITAL LETTER E WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0046, 0, 0, 0}, 0x1e1e }, // U1E1E # LATIN CAPITAL LETTER F WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0047, 0, 0, 0}, 0x0120 }, // U0120 # LATIN CAPITAL LETTER G WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0048, 0, 0, 0}, 0x1e22 }, // U1E22 # LATIN CAPITAL LETTER H WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0049, 0, 0, 0}, 0x0130 }, // U0130 # LATIN CAPITAL LETTER I WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x004d, 0, 0, 0}, 0x1e40 }, // U1E40 # LATIN CAPITAL LETTER M WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x004e, 0, 0, 0}, 0x1e44 }, // U1E44 # LATIN CAPITAL LETTER N WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x004f, 0, 0, 0}, 0x022e }, // U022E # LATIN CAPITAL LETTER O WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0050, 0, 0, 0}, 0x1e56 }, // U1E56 # LATIN CAPITAL LETTER P WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0052, 0, 0, 0}, 0x1e58 }, // U1E58 # LATIN CAPITAL LETTER R WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0053, 0, 0, 0}, 0x1e60 }, // U1E60 # LATIN CAPITAL LETTER S WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0054, 0, 0, 0}, 0x1e6a }, // U1E6A # LATIN CAPITAL LETTER T WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0057, 0, 0, 0}, 0x1e86 }, // U1E86 # LATIN CAPITAL LETTER W WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0058, 0, 0, 0}, 0x1e8a }, // U1E8A # LATIN CAPITAL LETTER X WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0059, 0, 0, 0}, 0x1e8e }, // U1E8E # LATIN CAPITAL LETTER Y WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x005a, 0, 0, 0}, 0x017b }, // U017B # LATIN CAPITAL LETTER Z WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0061, 0, 0, 0}, 0x0227 }, // U0227 # LATIN SMALL LETTER A WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0062, 0, 0, 0}, 0x1e03 }, // U1E03 # LATIN SMALL LETTER B WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0063, 0, 0, 0}, 0x010b }, // U010B # LATIN SMALL LETTER C WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0063, 0x0053, 0, 0}, 0x1e66 }, // U1E66 # LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0063, 0x0073, 0, 0}, 0x1e67 }, // U1E67 # LATIN SMALL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0064, 0, 0, 0}, 0x1e0b }, // U1E0B # LATIN SMALL LETTER D WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0065, 0, 0, 0}, 0x0117 }, // U0117 # LATIN SMALL LETTER E WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0066, 0, 0, 0}, 0x1e1f }, // U1E1F # LATIN SMALL LETTER F WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0067, 0, 0, 0}, 0x0121 }, // U0121 # LATIN SMALL LETTER G WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0068, 0, 0, 0}, 0x1e23 }, // U1E23 # LATIN SMALL LETTER H WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x006d, 0, 0, 0}, 0x1e41 }, // U1E41 # LATIN SMALL LETTER M WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x006e, 0, 0, 0}, 0x1e45 }, // U1E45 # LATIN SMALL LETTER N WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x006f, 0, 0, 0}, 0x022f }, // U022F # LATIN SMALL LETTER O WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0070, 0, 0, 0}, 0x1e57 }, // U1E57 # LATIN SMALL LETTER P WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0072, 0, 0, 0}, 0x1e59 }, // U1E59 # LATIN SMALL LETTER R WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0073, 0, 0, 0}, 0x1e61 }, // U1E61 # LATIN SMALL LETTER S WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0074, 0, 0, 0}, 0x1e6b }, // U1E6B # LATIN SMALL LETTER T WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0077, 0, 0, 0}, 0x1e87 }, // U1E87 # LATIN SMALL LETTER W WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0078, 0, 0, 0}, 0x1e8b }, // U1E8B # LATIN SMALL LETTER X WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0079, 0, 0, 0}, 0x1e8f }, // U1E8F # LATIN SMALL LETTER Y WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x007a, 0, 0, 0}, 0x017c }, // U017C # LATIN SMALL LETTER Z WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x00b4, 0x0053, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x00b4, 0x0073, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x015a, 0, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x015b, 0, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0160, 0, 0, 0}, 0x1e66 }, // U1E66 # LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0161, 0, 0, 0}, 0x1e67 }, // U1E67 # LATIN SMALL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x017f, 0, 0, 0}, 0x1e9b }, // U1E9B # LATIN SMALL LETTER LONG S WITH DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x1e62, 0, 0, 0}, 0x1e68 }, // U1E68 # LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, 0x1e63, 0, 0, 0}, 0x1e69 }, // U1E69 # LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, UNITIZE(TQt::Key_Dead_Acute), 0x0053, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, UNITIZE(TQt::Key_Dead_Acute), 0x0073, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, UNITIZE(TQt::Key_Dead_Caron), 0x0053, 0, 0}, 0x1e66 }, // U1E66 # LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, UNITIZE(TQt::Key_Dead_Caron), 0x0073, 0, 0}, 0x1e67 }, // U1E67 # LATIN SMALL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, UNITIZE(TQt::Key_Dead_Belowdot), 0x0053, 0, 0}, 0x1e68 }, // U1E68 # LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002e, UNITIZE(TQt::Key_Dead_Belowdot), 0x0073, 0, 0}, 0x1e69 }, // U1E69 # LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x002f, 0, 0, 0}, 0x005c }, // backslash + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x003c, 0, 0, 0}, 0x005c }, // backslash + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0043, 0, 0, 0}, 0x20a1 }, // U20a1 # COLON SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0043, 0, 0, 0}, 0x00a2 }, // U00A2 # CENT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0044, 0, 0, 0}, 0x0110 }, // U0110 # LATIN CAPITAL LETTER D WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0047, 0, 0, 0}, 0x01e4 }, // U01E4 # LATIN CAPITAL LETTER G WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0048, 0, 0, 0}, 0x0126 }, // U0126 # LATIN CAPITAL LETTER H WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0049, 0, 0, 0}, 0x0197 }, // U0197 # LATIN CAPITAL LETTER I WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x004c, 0, 0, 0}, 0x0141 }, // U0141 # LATIN CAPITAL LETTER L WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x004f, 0, 0, 0}, 0x00d8 }, // U00D8 # LATIN CAPITAL LETTER O WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0054, 0, 0, 0}, 0x0166 }, // U0166 # LATIN CAPITAL LETTER T WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x005a, 0, 0, 0}, 0x01b5 }, // U01B5 # LATIN CAPITAL LETTER Z WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x005e, 0, 0, 0}, 0x007c }, // bar + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0062, 0, 0, 0}, 0x0180 }, // U0180 # LATIN SMALL LETTER B WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0063, 0, 0, 0}, 0x00a2 }, // U00A2 # CENT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0064, 0, 0, 0}, 0x0111 }, // U0111 # LATIN SMALL LETTER D WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0067, 0, 0, 0}, 0x01e5 }, // U01E5 # LATIN SMALL LETTER G WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0068, 0, 0, 0}, 0x0127 }, // U0127 # LATIN SMALL LETTER H WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0069, 0, 0, 0}, 0x0268 }, // U0268 # LATIN SMALL LETTER I WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x006c, 0, 0, 0}, 0x0142 }, // U0142 # LATIN SMALL LETTER L WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x006d, 0, 0, 0}, 0x20a5 }, // U20a5 # MILL SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x006f, 0, 0, 0}, 0x00f8 }, // U00F8 # LATIN SMALL LETTER O WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0074, 0, 0, 0}, 0x0167 }, // U0167 # LATIN SMALL LETTER T WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x007a, 0, 0, 0}, 0x01b6 }, // U01B6 # LATIN SMALL LETTER Z WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0294, 0, 0, 0}, 0x02a1 }, // U02A1 # LATIN LETTER GLOTTAL STOP WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0413, 0, 0, 0}, 0x0492 }, // U0492 # CYRILLIC CAPITAL LETTER GHE WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x041a, 0, 0, 0}, 0x049e }, // U049E # CYRILLIC CAPITAL LETTER KA WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x0433, 0, 0, 0}, 0x0493 }, // U0493 # CYRILLIC SMALL LETTER GHE WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x043a, 0, 0, 0}, 0x049f }, // U049F # CYRILLIC SMALL LETTER KA WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x04ae, 0, 0, 0}, 0x04b0 }, // U04B0 # CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x04af, 0, 0, 0}, 0x04b1 }, // U04B1 # CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x2190, 0, 0, 0}, 0x219a }, // U219A # LEFTWARDS ARROW WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x2192, 0, 0, 0}, 0x219b }, // U219B # RIGHTWARDS ARROW WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x002f, 0x2194, 0, 0, 0}, 0x21ae }, // U21AE # LEFT RIGHT ARROW WITH STROKE + { {UNITIZE(TQt::Key_Multi_key), 0x0031, 0x0032, 0, 0, 0}, 0x00bd }, // U00BD # VULGAR FRACTION ONE HALF + { {UNITIZE(TQt::Key_Multi_key), 0x0031, 0x0034, 0, 0, 0}, 0x00bc }, // U00BC # VULGAR FRACTION ONE TQUARTER + { {UNITIZE(TQt::Key_Multi_key), 0x0033, 0x0034, 0, 0, 0}, 0x00be }, // U00BE # VULGAR FRACTION THREE TQUARTERS + { {UNITIZE(TQt::Key_Multi_key), 0x003a, 0x002d, 0, 0, 0}, 0x00f7 }, // U00F7 # DIVISION SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x0041, 0, 0, 0}, 0x0104 }, // U0104 # LATIN CAPITAL LETTER A WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x0045, 0, 0, 0}, 0x0118 }, // U0118 # LATIN CAPITAL LETTER E WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x0049, 0, 0, 0}, 0x012e }, // U012E # LATIN CAPITAL LETTER I WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x004f, 0, 0, 0}, 0x01ea }, // U01EA # LATIN CAPITAL LETTER O WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x0055, 0, 0, 0}, 0x0172 }, // U0172 # LATIN CAPITAL LETTER U WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x0061, 0, 0, 0}, 0x0105 }, // U0105 # LATIN SMALL LETTER A WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x0065, 0, 0, 0}, 0x0119 }, // U0119 # LATIN SMALL LETTER E WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x0069, 0, 0, 0}, 0x012f }, // U012F # LATIN SMALL LETTER I WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x006f, 0, 0, 0}, 0x01eb }, // U01EB # LATIN SMALL LETTER O WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003b, 0x0075, 0, 0, 0}, 0x0173 }, // U0173 # LATIN SMALL LETTER U WITH OGONEK + { {UNITIZE(TQt::Key_Multi_key), 0x003c, 0x0022, 0, 0, 0}, 0x201c }, // U201c # LEFT DOUBLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x003c, 0x0027, 0, 0, 0}, 0x2018 }, // U2018 # LEFT SINGLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x003c, 0x002f, 0, 0, 0}, 0x005c }, // backslash + { {UNITIZE(TQt::Key_Multi_key), 0x003c, 0x003c, 0, 0, 0}, 0x00ab }, // guillemotleft # LEFT-POINTING DOUBLE ANGLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x003c, 0x0338, 0, 0, 0}, 0x226e }, // U226E # NOT LESS-THAN + { {UNITIZE(TQt::Key_Multi_key), 0x003c, 0x0338, 0, 0, 0}, 0x226e }, // U226E # NOT LESS-THAN + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x0043, 0, 0, 0}, 0x20ac }, // EuroSign # EURO SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x0045, 0, 0, 0}, 0x20ac }, // EuroSign # EURO SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x004c, 0, 0, 0}, 0x20a4 }, // U20a4 # LIRA SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x004e, 0, 0, 0}, 0x20a6 }, // U20a6 # NAIRA SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x004f, 0, 0, 0}, 0x0150 }, // U0150 # LATIN CAPITAL LETTER O WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x0055, 0, 0, 0}, 0x0170 }, // U0170 # LATIN CAPITAL LETTER U WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x0057, 0, 0, 0}, 0x20a9 }, // U20a9 # WON SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x0059, 0, 0, 0}, 0x00a5 }, // yen + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x006f, 0, 0, 0}, 0x0151 }, // U0151 # LATIN SMALL LETTER O WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x0075, 0, 0, 0}, 0x0171 }, // U0171 # LATIN SMALL LETTER U WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x0338, 0, 0, 0}, 0x2260 }, // U2260 # NOT ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x0423, 0, 0, 0}, 0x04f2 }, // U04F2 # CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x003d, 0x0443, 0, 0, 0}, 0x04f3 }, // U04F3 # CYRILLIC SMALL LETTER U WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x003e, 0x0020, 0, 0, 0}, 0x005e }, // asciicircum + { {UNITIZE(TQt::Key_Multi_key), 0x003e, 0x0022, 0, 0, 0}, 0x201d }, // U201d # RIGHT DOUBLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x003e, 0x0027, 0, 0, 0}, 0x2019 }, // U2019 # RIGHT SINGLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x003e, 0x003e, 0, 0, 0}, 0x00bb }, // guillemotright # RIGHT-POINTING DOUBLE ANGLE TQUOTATION MARK + { {UNITIZE(TQt::Key_Multi_key), 0x003e, 0x0338, 0, 0, 0}, 0x226f }, // U226F # NOT GREATER-THAN + { {UNITIZE(TQt::Key_Multi_key), 0x003e, 0x0338, 0, 0, 0}, 0x226f }, // U226F # NOT GREATER-THAN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0000, 0, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0000, 0, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0000, 0, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0000, 0, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x002b, 0x004f, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x002b, 0x0055, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x002b, 0x006f, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x002b, 0x0075, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x003f, 0, 0, 0}, 0x00bf }, // questiondown + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0041, 0, 0, 0}, 0x1ea2 }, // U1EA2 # LATIN CAPITAL LETTER A WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0045, 0, 0, 0}, 0x1eba }, // U1EBA # LATIN CAPITAL LETTER E WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0049, 0, 0, 0}, 0x1ec8 }, // U1EC8 # LATIN CAPITAL LETTER I WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x004f, 0, 0, 0}, 0x1ece }, // U1ECE # LATIN CAPITAL LETTER O WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0055, 0, 0, 0}, 0x1ee6 }, // U1EE6 # LATIN CAPITAL LETTER U WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0055, 0x0041, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0055, 0x0061, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0059, 0, 0, 0}, 0x1ef6 }, // U1EF6 # LATIN CAPITAL LETTER Y WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x005e, 0x0041, 0, 0}, 0x1ea8 }, // U1EA8 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x005e, 0x0045, 0, 0}, 0x1ec2 }, // U1EC2 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x005e, 0x004f, 0, 0}, 0x1ed4 }, // U1ED4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x005e, 0x0061, 0, 0}, 0x1ea9 }, // U1EA9 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x005e, 0x0065, 0, 0}, 0x1ec3 }, // U1EC3 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x005e, 0x006f, 0, 0}, 0x1ed5 }, // U1ED5 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0061, 0, 0, 0}, 0x1ea3 }, // U1EA3 # LATIN SMALL LETTER A WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0062, 0x0041, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0062, 0x0061, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0065, 0, 0, 0}, 0x1ebb }, // U1EBB # LATIN SMALL LETTER E WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0069, 0, 0, 0}, 0x1ec9 }, // U1EC9 # LATIN SMALL LETTER I WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x006f, 0, 0, 0}, 0x1ecf }, // U1ECF # LATIN SMALL LETTER O WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0075, 0, 0, 0}, 0x1ee7 }, // U1EE7 # LATIN SMALL LETTER U WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0079, 0, 0, 0}, 0x1ef7 }, // U1EF7 # LATIN SMALL LETTER Y WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x00c2, 0, 0, 0}, 0x1ea8 }, // U1EA8 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x00ca, 0, 0, 0}, 0x1ec2 }, // U1EC2 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x00d4, 0, 0, 0}, 0x1ed4 }, // U1ED4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x00e2, 0, 0, 0}, 0x1ea9 }, // U1EA9 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x00ea, 0, 0, 0}, 0x1ec3 }, // U1EC3 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x00f4, 0, 0, 0}, 0x1ed5 }, // U1ED5 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0102, 0, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, 0x0103, 0, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0}, 0x1ea8 }, // U1EA8 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0}, 0x1ec2 }, // U1EC2 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0}, 0x1ed4 }, // U1ED4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0}, 0x1ea9 }, // U1EA9 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0}, 0x1ec3 }, // U1EC3 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0}, 0x1ed5 }, // U1ED5 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x003f, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x0041, 0x0045, 0, 0, 0}, 0x00c6 }, // AE + { {UNITIZE(TQt::Key_Multi_key), 0x0041, 0x0054, 0, 0, 0}, 0x0040 }, // at + { {UNITIZE(TQt::Key_Multi_key), 0x0043, 0x002f, 0, 0, 0}, 0x20a1 }, // U20a1 # COLON SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0043, 0x002f, 0, 0, 0}, 0x00a2 }, // U00A2 # CENT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0043, 0x003d, 0, 0, 0}, 0x20ac }, // EuroSign # EURO SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0043, 0x0045, 0, 0, 0}, 0x20a0 }, // U20a0 # EURO-CURRENCY SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0043, 0x0072, 0, 0, 0}, 0x20a2 }, // U20a2 # CRUZEIRO SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0043, 0x007c, 0, 0, 0}, 0x00a2 }, // U00A2 # CENT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0044, 0x0048, 0, 0, 0}, 0x00d0 }, // U00D0 # LATIN CAPITAL LETTER ETH + { {UNITIZE(TQt::Key_Multi_key), 0x0045, 0x003d, 0, 0, 0}, 0x20ac }, // EuroSign # EURO SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0046, 0x0072, 0, 0, 0}, 0x20a3 }, // U20a3 # FRENCH FRANC SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x004c, 0x002d, 0, 0, 0}, 0x00a3 }, // U00a3 # POUND SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x004c, 0x003d, 0, 0, 0}, 0x20a4 }, // U20a4 # LIRA SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x004c, 0x0056, 0, 0, 0}, 0x007c }, // bar + { {UNITIZE(TQt::Key_Multi_key), 0x004e, 0x003d, 0, 0, 0}, 0x20a6 }, // U20a6 # NAIRA SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x004e, 0x0047, 0, 0, 0}, 0x014a }, // U014A # LATIN CAPITAL LETTER ENG + { {UNITIZE(TQt::Key_Multi_key), 0x004f, 0x0043, 0, 0, 0}, 0x00a9 }, // copyright + { {UNITIZE(TQt::Key_Multi_key), 0x004f, 0x0045, 0, 0, 0}, 0x0152 }, // OE + { {UNITIZE(TQt::Key_Multi_key), 0x004f, 0x0052, 0, 0, 0}, 0x00ae }, // registered + { {UNITIZE(TQt::Key_Multi_key), 0x004f, 0x0063, 0, 0, 0}, 0x00a9 }, // copyright + { {UNITIZE(TQt::Key_Multi_key), 0x004f, 0x0072, 0, 0, 0}, 0x00ae }, // registered + { {UNITIZE(TQt::Key_Multi_key), 0x0050, 0x0021, 0, 0, 0}, 0x00b6 }, // paragraph + { {UNITIZE(TQt::Key_Multi_key), 0x0050, 0x0050, 0, 0, 0}, 0x00b6 }, // paragraph # PILCROW SIGN (PARAGRAPH SIGN) + { {UNITIZE(TQt::Key_Multi_key), 0x0050, 0x0074, 0, 0, 0}, 0x20a7 }, // U20a7 # PESETA SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0052, 0x0073, 0, 0, 0}, 0x20a8 }, // U20a8 # RUPEE SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0054, 0x0048, 0, 0, 0}, 0x00de }, // U00DE # LATIN CAPITAL LETTER THORN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0000, 0x0041, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0000, 0x0061, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0021, 0x0041, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0021, 0x0061, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x002c, 0x0045, 0, 0}, 0x1e1c }, // U1E1C # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x002c, 0x0065, 0, 0}, 0x1e1d }, // U1E1D # LATIN SMALL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0041, 0, 0, 0}, 0x0102 }, // U0102 # LATIN CAPITAL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0045, 0, 0, 0}, 0x0114 }, // U0114 # LATIN CAPITAL LETTER E WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0047, 0, 0, 0}, 0x011e }, // U011E # LATIN CAPITAL LETTER G WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0049, 0, 0, 0}, 0x012c }, // U012C # LATIN CAPITAL LETTER I WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x004f, 0, 0, 0}, 0x014e }, // U014E # LATIN CAPITAL LETTER O WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0055, 0, 0, 0}, 0x016c }, // U016C # LATIN CAPITAL LETTER U WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0061, 0, 0, 0}, 0x0103 }, // U0103 # LATIN SMALL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0065, 0, 0, 0}, 0x0115 }, // U0115 # LATIN SMALL LETTER E WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0067, 0, 0, 0}, 0x011f }, // U011F # LATIN SMALL LETTER G WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0069, 0, 0, 0}, 0x012d }, // U012D # LATIN SMALL LETTER I WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x006f, 0, 0, 0}, 0x014f }, // U014F # LATIN SMALL LETTER O WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0075, 0, 0, 0}, 0x016d }, // U016D # LATIN SMALL LETTER U WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0228, 0, 0, 0}, 0x1e1c }, // U1E1C # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0229, 0, 0, 0}, 0x1e1d }, // U1E1D # LATIN SMALL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0391, 0, 0, 0}, 0x1fb8 }, // U1FB8 # GREEK CAPITAL LETTER ALPHA WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0399, 0, 0, 0}, 0x1fd8 }, // U1FD8 # GREEK CAPITAL LETTER IOTA WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x03a5, 0, 0, 0}, 0x1fe8 }, // U1FE8 # GREEK CAPITAL LETTER UPSILON WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x03b1, 0, 0, 0}, 0x1fb0 }, // U1FB0 # GREEK SMALL LETTER ALPHA WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x03b9, 0, 0, 0}, 0x1fd0 }, // U1FD0 # GREEK SMALL LETTER IOTA WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x03c5, 0, 0, 0}, 0x1fe0 }, // U1FE0 # GREEK SMALL LETTER UPSILON WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0410, 0, 0, 0}, 0x04d0 }, // U04D0 # CYRILLIC CAPITAL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0415, 0, 0, 0}, 0x04d6 }, // U04D6 # CYRILLIC CAPITAL LETTER IE WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0416, 0, 0, 0}, 0x04c1 }, // U04C1 # CYRILLIC CAPITAL LETTER ZHE WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0418, 0, 0, 0}, 0x0419 }, // U0419 # CYRILLIC CAPITAL LETTER SHORT I + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0423, 0, 0, 0}, 0x040e }, // U040E # CYRILLIC CAPITAL LETTER SHORT U + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0430, 0, 0, 0}, 0x04d1 }, // U04D1 # CYRILLIC SMALL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0435, 0, 0, 0}, 0x04d7 }, // U04D7 # CYRILLIC SMALL LETTER IE WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0436, 0, 0, 0}, 0x04c2 }, // U04C2 # CYRILLIC SMALL LETTER ZHE WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0438, 0, 0, 0}, 0x0439 }, // U0439 # CYRILLIC SMALL LETTER SHORT I + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0443, 0, 0, 0}, 0x045e }, // U045E # CYRILLIC SMALL LETTER SHORT U + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x1ea0, 0, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0055, 0x1ea1, 0, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0055, UNITIZE(TQt::Key_Dead_Cedilla), 0x0045, 0, 0}, 0x1e1c }, // U1E1C # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, UNITIZE(TQt::Key_Dead_Cedilla), 0x0065, 0, 0}, 0x1e1d }, // U1E1D # LATIN SMALL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0055, UNITIZE(TQt::Key_Dead_Belowdot), 0x0041, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0055, UNITIZE(TQt::Key_Dead_Belowdot), 0x0061, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0056, 0x004c, 0, 0, 0}, 0x007c }, // bar + { {UNITIZE(TQt::Key_Multi_key), 0x0057, 0x003d, 0, 0, 0}, 0x20a9 }, // U20a9 # WON SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0059, 0x003d, 0, 0, 0}, 0x00a5 }, // yen +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x00b2 }, // U00B2 # SUPERSCRIPT TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x2076 }, // U2076 # SUPERSCRIPT SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x2070 }, // U2070 # SUPERSCRIPT ZERO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x00b9 }, // U00B9 # SUPERSCRIPT ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x2078 }, // U2078 # SUPERSCRIPT EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x2074 }, // U2074 # SUPERSCRIPT FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x00b3 }, // U00B3 # SUPERSCRIPT THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x2077 }, // U2077 # SUPERSCRIPT SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x207c }, // U207C # SUPERSCRIPT ETQUALS SIGN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x207a }, // U207A # SUPERSCRIPT PLUS SIGN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x00b2 }, // U00B2 # SUPERSCRIPT TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x2079 }, // U2079 # SUPERSCRIPT NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0, 0, 0}, 0x2075 }, // U2075 # SUPERSCRIPT FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0x0041, 0, 0}, 0x1eac }, // U1EAC # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0x0045, 0, 0}, 0x1ec6 }, // U1EC6 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0x004f, 0, 0}, 0x1ed8 }, // U1ED8 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0x0061, 0, 0}, 0x1ead }, // U1EAD # LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0x0065, 0, 0}, 0x1ec7 }, // U1EC7 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0000, 0x006f, 0, 0}, 0x1ed9 }, // U1ED9 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0020, 0, 0, 0}, 0x005e }, // asciicircum + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0021, 0x0041, 0, 0}, 0x1eac }, // U1EAC # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0021, 0x0045, 0, 0}, 0x1ec6 }, // U1EC6 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0021, 0x004f, 0, 0}, 0x1ed8 }, // U1ED8 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0021, 0x0061, 0, 0}, 0x1ead }, // U1EAD # LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0021, 0x0065, 0, 0}, 0x1ec7 }, // U1EC7 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0021, 0x006f, 0, 0}, 0x1ed9 }, // U1ED9 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0028, 0, 0, 0}, 0x207d }, // U207D # SUPERSCRIPT LEFT PARENTHESIS + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0029, 0, 0, 0}, 0x207e }, // U207E # SUPERSCRIPT RIGHT PARENTHESIS + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x002b, 0, 0, 0}, 0x207a }, // U207A # SUPERSCRIPT PLUS SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x002f, 0, 0, 0}, 0x007c }, // bar + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0030, 0, 0, 0}, 0x2070 }, // U2070 # SUPERSCRIPT ZERO + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0031, 0, 0, 0}, 0x00b9 }, // U00B9 # SUPERSCRIPT ONE + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0032, 0, 0, 0}, 0x00b2 }, // U00B2 # SUPERSCRIPT TWO + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0033, 0, 0, 0}, 0x00b3 }, // U00B3 # SUPERSCRIPT THREE + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0034, 0, 0, 0}, 0x2074 }, // U2074 # SUPERSCRIPT FOUR + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0035, 0, 0, 0}, 0x2075 }, // U2075 # SUPERSCRIPT FIVE + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0036, 0, 0, 0}, 0x2076 }, // U2076 # SUPERSCRIPT SIX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0037, 0, 0, 0}, 0x2077 }, // U2077 # SUPERSCRIPT SEVEN + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0038, 0, 0, 0}, 0x2078 }, // U2078 # SUPERSCRIPT EIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0039, 0, 0, 0}, 0x2079 }, // U2079 # SUPERSCRIPT NINE + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x003d, 0, 0, 0}, 0x207c }, // U207C # SUPERSCRIPT ETQUALS SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0041, 0, 0, 0}, 0x00c2 }, // U00C2 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0043, 0, 0, 0}, 0x0108 }, // U0108 # LATIN CAPITAL LETTER C WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0045, 0, 0, 0}, 0x00ca }, // U00CA # LATIN CAPITAL LETTER E WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0047, 0, 0, 0}, 0x011c }, // U011C # LATIN CAPITAL LETTER G WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0048, 0, 0, 0}, 0x0124 }, // U0124 # LATIN CAPITAL LETTER H WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0049, 0, 0, 0}, 0x00ce }, // U00CE # LATIN CAPITAL LETTER I WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004a, 0, 0, 0}, 0x0134 }, // U0134 # LATIN CAPITAL LETTER J WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004f, 0, 0, 0}, 0x00d4 }, // U00D4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0053, 0, 0, 0}, 0x015c }, // U015C # LATIN CAPITAL LETTER S WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0053, 0x004d, 0, 0}, 0x2120 }, // U2120 # SERVICE MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0054, 0x004d, 0, 0}, 0x2122 }, // U2122 # TRADE MARK SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0055, 0, 0, 0}, 0x00db }, // U00DB # LATIN CAPITAL LETTER U WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0057, 0, 0, 0}, 0x0174 }, // U0174 # LATIN CAPITAL LETTER W WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0059, 0, 0, 0}, 0x0176 }, // U0176 # LATIN CAPITAL LETTER Y WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005a, 0, 0, 0}, 0x1e90 }, // U1E90 # LATIN CAPITAL LETTER Z WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0061, 0, 0}, 0x00aa }, // U00AA # FEMININE ORDINAL INDICATOR + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0061, 0, 0}, 0x00aa }, // U00AA # FEMININE ORDINAL INDICATOR + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0068, 0, 0}, 0x02b0 }, // U02B0 # MODIFIER LETTER SMALL H + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0068, 0, 0}, 0x02b0 }, // U02B0 # MODIFIER LETTER SMALL H + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0069, 0, 0}, 0x2071 }, // U2071 # SUPERSCRIPT LATIN SMALL LETTER I + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0069, 0, 0}, 0x2071 }, // U2071 # SUPERSCRIPT LATIN SMALL LETTER I + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x006a, 0, 0}, 0x02b2 }, // U02B2 # MODIFIER LETTER SMALL J + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x006a, 0, 0}, 0x02b2 }, // U02B2 # MODIFIER LETTER SMALL J + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x006c, 0, 0}, 0x02e1 }, // U02E1 # MODIFIER LETTER SMALL L + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x006c, 0, 0}, 0x02e1 }, // U02E1 # MODIFIER LETTER SMALL L + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x006e, 0, 0}, 0x207f }, // U207F # SUPERSCRIPT LATIN SMALL LETTER N + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x006e, 0, 0}, 0x207f }, // U207F # SUPERSCRIPT LATIN SMALL LETTER N + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x006f, 0, 0}, 0x00ba }, // U00BA # MASCULINE ORDINAL INDICATOR + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x006f, 0, 0}, 0x00ba }, // U00BA # MASCULINE ORDINAL INDICATOR + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0072, 0, 0}, 0x02b3 }, // U02B3 # MODIFIER LETTER SMALL R + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0072, 0, 0}, 0x02b3 }, // U02B3 # MODIFIER LETTER SMALL R + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0073, 0, 0}, 0x02e2 }, // U02E2 # MODIFIER LETTER SMALL S + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0073, 0, 0}, 0x02e2 }, // U02E2 # MODIFIER LETTER SMALL S + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0077, 0, 0}, 0x02b7 }, // U02B7 # MODIFIER LETTER SMALL W + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0077, 0, 0}, 0x02b7 }, // U02B7 # MODIFIER LETTER SMALL W + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0078, 0, 0}, 0x02e3 }, // U02E3 # MODIFIER LETTER SMALL X + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0078, 0, 0}, 0x02e3 }, // U02E3 # MODIFIER LETTER SMALL X + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0079, 0, 0}, 0x02b8 }, // U02B8 # MODIFIER LETTER SMALL Y + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0079, 0, 0}, 0x02b8 }, // U02B8 # MODIFIER LETTER SMALL Y + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0263, 0, 0}, 0x02e0 }, // U02E0 # MODIFIER LETTER SMALL GAMMA + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0263, 0, 0}, 0x02e0 }, // U02E0 # MODIFIER LETTER SMALL GAMMA + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0266, 0, 0}, 0x02b1 }, // U02B1 # MODIFIER LETTER SMALL H WITH HOOK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0266, 0, 0}, 0x02b1 }, // U02B1 # MODIFIER LETTER SMALL H WITH HOOK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0279, 0, 0}, 0x02b4 }, // U02B4 # MODIFIER LETTER SMALL TURNED R + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0279, 0, 0}, 0x02b4 }, // U02B4 # MODIFIER LETTER SMALL TURNED R + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x027b, 0, 0}, 0x02b5 }, // U02B5 # MODIFIER LETTER SMALL TURNED R WITH HOOK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x027b, 0, 0}, 0x02b5 }, // U02B5 # MODIFIER LETTER SMALL TURNED R WITH HOOK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0281, 0, 0}, 0x02b6 }, // U02B6 # MODIFIER LETTER SMALL CAPITAL INVERTED R + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0281, 0, 0}, 0x02b6 }, // U02B6 # MODIFIER LETTER SMALL CAPITAL INVERTED R + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0295, 0, 0}, 0x02e4 }, // U02E4 # MODIFIER LETTER SMALL REVERSED GLOTTAL STOP + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x005f, 0x0295, 0, 0}, 0x02e4 }, // U02E4 # MODIFIER LETTER SMALL REVERSED GLOTTAL STOP + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0061, 0, 0, 0}, 0x00e2 }, // U00E2 # LATIN SMALL LETTER A WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0063, 0, 0, 0}, 0x0109 }, // U0109 # LATIN SMALL LETTER C WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0065, 0, 0, 0}, 0x00ea }, // U00EA # LATIN SMALL LETTER E WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0067, 0, 0, 0}, 0x011d }, // U011D # LATIN SMALL LETTER G WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0068, 0, 0, 0}, 0x0125 }, // U0125 # LATIN SMALL LETTER H WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0069, 0, 0, 0}, 0x00ee }, // U00EE # LATIN SMALL LETTER I WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006a, 0, 0, 0}, 0x0135 }, // U0135 # LATIN SMALL LETTER J WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006f, 0, 0, 0}, 0x00f4 }, // U00F4 # LATIN SMALL LETTER O WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0073, 0, 0, 0}, 0x015d }, // U015D # LATIN SMALL LETTER S WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0075, 0, 0, 0}, 0x00fb }, // U00FB # LATIN SMALL LETTER U WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0077, 0, 0, 0}, 0x0175 }, // U0175 # LATIN SMALL LETTER W WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0079, 0, 0, 0}, 0x0177 }, // U0177 # LATIN SMALL LETTER Y WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x007a, 0, 0, 0}, 0x1e91 }, // U1E91 # LATIN SMALL LETTER Z WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x1ea0, 0, 0, 0}, 0x1eac }, // U1EAC # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x1ea1, 0, 0, 0}, 0x1ead }, // U1EAD # LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x1eb8, 0, 0, 0}, 0x1ec6 }, // U1EC6 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x1eb9, 0, 0, 0}, 0x1ec7 }, // U1EC7 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x1ecc, 0, 0, 0}, 0x1ed8 }, // U1ED8 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x1ecd, 0, 0, 0}, 0x1ed9 }, // U1ED9 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x2212, 0, 0, 0}, 0x207b }, // U207B # SUPERSCRIPT MINUS + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4e00, 0, 0, 0}, 0x3192 }, // U3192 # IDEOGRAPHIC ANNOTATION ONE MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4e01, 0, 0, 0}, 0x319c }, // U319C # IDEOGRAPHIC ANNOTATION FOURTH MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4e09, 0, 0, 0}, 0x3194 }, // U3194 # IDEOGRAPHIC ANNOTATION THREE MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4e0a, 0, 0, 0}, 0x3196 }, // U3196 # IDEOGRAPHIC ANNOTATION TOP MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4e0b, 0, 0, 0}, 0x3198 }, // U3198 # IDEOGRAPHIC ANNOTATION BOTTOM MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4e19, 0, 0, 0}, 0x319b }, // U319B # IDEOGRAPHIC ANNOTATION THIRD MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4e2d, 0, 0, 0}, 0x3197 }, // U3197 # IDEOGRAPHIC ANNOTATION MIDDLE MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4e59, 0, 0, 0}, 0x319a }, // U319A # IDEOGRAPHIC ANNOTATION SECOND MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4e8c, 0, 0, 0}, 0x3193 }, // U3193 # IDEOGRAPHIC ANNOTATION TWO MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x4eba, 0, 0, 0}, 0x319f }, // U319F # IDEOGRAPHIC ANNOTATION MAN MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x56db, 0, 0, 0}, 0x3195 }, // U3195 # IDEOGRAPHIC ANNOTATION FOUR MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x5730, 0, 0, 0}, 0x319e }, // U319E # IDEOGRAPHIC ANNOTATION EARTH MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x5929, 0, 0, 0}, 0x319d }, // U319D # IDEOGRAPHIC ANNOTATION HEAVEN MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, 0x7532, 0, 0, 0}, 0x3199 }, // U3199 # IDEOGRAPHIC ANNOTATION FIRST MARK + { {UNITIZE(TQt::Key_Multi_key), 0x005e, UNITIZE(TQt::Key_Dead_Belowdot), 0x0041, 0, 0}, 0x1eac }, // U1EAC # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, UNITIZE(TQt::Key_Dead_Belowdot), 0x0045, 0, 0}, 0x1ec6 }, // U1EC6 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, UNITIZE(TQt::Key_Dead_Belowdot), 0x004f, 0, 0}, 0x1ed8 }, // U1ED8 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, UNITIZE(TQt::Key_Dead_Belowdot), 0x0061, 0, 0}, 0x1ead }, // U1EAD # LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, UNITIZE(TQt::Key_Dead_Belowdot), 0x0065, 0, 0}, 0x1ec7 }, // U1EC7 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x005e, UNITIZE(TQt::Key_Dead_Belowdot), 0x006f, 0, 0}, 0x1ed9 }, // U1ED9 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2085 }, // U2085 # SUBSCRIPT FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2087 }, // U2087 # SUBSCRIPT SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2082 }, // U2082 # SUBSCRIPT TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2085 }, // U2085 # SUBSCRIPT FIVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2084 }, // U2084 # SUBSCRIPT FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2084 }, // U2084 # SUBSCRIPT FOUR +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2086 }, // U2086 # SUBSCRIPT SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2081 }, // U2081 # SUBSCRIPT ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x208a }, // U208A # SUBSCRIPT PLUS SIGN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2088 }, // U2088 # SUBSCRIPT EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2087 }, // U2087 # SUBSCRIPT SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x208a }, // U208A # SUBSCRIPT PLUS SIGN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2080 }, // U2080 # SUBSCRIPT ZERO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2083 }, // U2083 # SUBSCRIPT THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2082 }, // U2082 # SUBSCRIPT TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2083 }, // U2083 # SUBSCRIPT THREE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2086 }, // U2086 # SUBSCRIPT SIX +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2088 }, // U2088 # SUBSCRIPT EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2089 }, // U2089 # SUBSCRIPT NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2089 }, // U2089 # SUBSCRIPT NINE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2080 }, // U2080 # SUBSCRIPT ZERO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2082 }, // U2082 # SUBSCRIPT TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2081 }, // U2081 # SUBSCRIPT ONE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x2082 }, // U2082 # SUBSCRIPT TWO +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x208c }, // U208C # SUBSCRIPT ETQUALS SIGN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0, 0, 0}, 0x208c }, // U208C # SUBSCRIPT ETQUALS SIGN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0x004c, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0x004f, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0x0052, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0x006c, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0x006f, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0000, 0x0072, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0021, 0x004c, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0021, 0x0052, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0021, 0x006c, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0021, 0x0072, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0022, 0x0041, 0, 0}, 0x01de }, // U01DE # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0022, 0x004f, 0, 0}, 0x022a }, // U022A # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0022, 0x0055, 0, 0}, 0x01d5 }, // U01D5 # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0022, 0x0061, 0, 0}, 0x01df }, // U01DF # LATIN SMALL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0022, 0x006f, 0, 0}, 0x022b }, // U022B # LATIN SMALL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0022, 0x0075, 0, 0}, 0x01d6 }, // U01D6 # LATIN SMALL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0028, 0, 0, 0}, 0x208d }, // U208D # SUBSCRIPT LEFT PARENTHESIS + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0028, 0, 0, 0}, 0x208d }, // U208D # SUBSCRIPT LEFT PARENTHESIS + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0029, 0, 0, 0}, 0x208e }, // U208E # SUBSCRIPT RIGHT PARENTHESIS + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0029, 0, 0, 0}, 0x208e }, // U208E # SUBSCRIPT RIGHT PARENTHESIS + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x002b, 0, 0, 0}, 0x208a }, // U208A # SUBSCRIPT PLUS SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x002b, 0, 0, 0}, 0x208a }, // U208A # SUBSCRIPT PLUS SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x002e, 0x0041, 0, 0}, 0x01e0 }, // U01E0 # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x002e, 0x004f, 0, 0}, 0x0230 }, // U0230 # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x002e, 0x0061, 0, 0}, 0x01e1 }, // U01E1 # LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x002e, 0x006f, 0, 0}, 0x0231 }, // U0231 # LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0030, 0, 0, 0}, 0x2080 }, // U2080 # SUBSCRIPT ZERO + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0030, 0, 0, 0}, 0x2080 }, // U2080 # SUBSCRIPT ZERO + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0031, 0, 0, 0}, 0x2081 }, // U2081 # SUBSCRIPT ONE + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0031, 0, 0, 0}, 0x2081 }, // U2081 # SUBSCRIPT ONE + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0032, 0, 0, 0}, 0x2082 }, // U2082 # SUBSCRIPT TWO + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0032, 0, 0, 0}, 0x2082 }, // U2082 # SUBSCRIPT TWO + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0033, 0, 0, 0}, 0x2083 }, // U2083 # SUBSCRIPT THREE + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0033, 0, 0, 0}, 0x2083 }, // U2083 # SUBSCRIPT THREE + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0034, 0, 0, 0}, 0x2084 }, // U2084 # SUBSCRIPT FOUR + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0034, 0, 0, 0}, 0x2084 }, // U2084 # SUBSCRIPT FOUR + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0035, 0, 0, 0}, 0x2085 }, // U2085 # SUBSCRIPT FIVE + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0035, 0, 0, 0}, 0x2085 }, // U2085 # SUBSCRIPT FIVE + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0036, 0, 0, 0}, 0x2086 }, // U2086 # SUBSCRIPT SIX + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0036, 0, 0, 0}, 0x2086 }, // U2086 # SUBSCRIPT SIX + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0037, 0, 0, 0}, 0x2087 }, // U2087 # SUBSCRIPT SEVEN + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0037, 0, 0, 0}, 0x2087 }, // U2087 # SUBSCRIPT SEVEN + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0038, 0, 0, 0}, 0x2088 }, // U2088 # SUBSCRIPT EIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0038, 0, 0, 0}, 0x2088 }, // U2088 # SUBSCRIPT EIGHT + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0039, 0, 0, 0}, 0x2089 }, // U2089 # SUBSCRIPT NINE + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0039, 0, 0, 0}, 0x2089 }, // U2089 # SUBSCRIPT NINE + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x003b, 0x004f, 0, 0}, 0x01ec }, // U01EC # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x003b, 0x006f, 0, 0}, 0x01ed }, // U01ED # LATIN SMALL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x003d, 0, 0, 0}, 0x208c }, // U208C # SUBSCRIPT ETQUALS SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x003d, 0, 0, 0}, 0x208c }, // U208C # SUBSCRIPT ETQUALS SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0041, 0, 0, 0}, 0x0100 }, // U0100 # LATIN CAPITAL LETTER A WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0045, 0, 0, 0}, 0x0112 }, // U0112 # LATIN CAPITAL LETTER E WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0047, 0, 0, 0}, 0x1e20 }, // U1E20 # LATIN CAPITAL LETTER G WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0049, 0, 0, 0}, 0x012a }, // U012A # LATIN CAPITAL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x004f, 0, 0, 0}, 0x014c }, // U014C # LATIN CAPITAL LETTER O WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0055, 0, 0, 0}, 0x016a }, // U016A # LATIN CAPITAL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0059, 0, 0, 0}, 0x0232 }, // U0232 # LATIN CAPITAL LETTER Y WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0061, 0, 0, 0}, 0x0101 }, // U0101 # LATIN SMALL LETTER A WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0065, 0, 0, 0}, 0x0113 }, // U0113 # LATIN SMALL LETTER E WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0067, 0, 0, 0}, 0x1e21 }, // U1E21 # LATIN SMALL LETTER G WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0069, 0, 0, 0}, 0x012b }, // U012B # LATIN SMALL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006f, 0, 0, 0}, 0x014d }, // U014D # LATIN SMALL LETTER O WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0075, 0, 0, 0}, 0x016b }, // U016B # LATIN SMALL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0079, 0, 0, 0}, 0x0233 }, // U0233 # LATIN SMALL LETTER Y WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x007e, 0x004f, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x007e, 0x006f, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00c4, 0, 0, 0}, 0x01de }, // U01DE # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00c6, 0, 0, 0}, 0x01e2 }, // U01E2 # LATIN CAPITAL LETTER AE WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00d5, 0, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00d6, 0, 0, 0}, 0x022a }, // U022A # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00dc, 0, 0, 0}, 0x01d5 }, // U01D5 # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00e4, 0, 0, 0}, 0x01df }, // U01DF # LATIN SMALL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00e6, 0, 0, 0}, 0x01e3 }, // U01E3 # LATIN SMALL LETTER AE WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00f5, 0, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00f6, 0, 0, 0}, 0x022b }, // U022B # LATIN SMALL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x00fc, 0, 0, 0}, 0x01d6 }, // U01D6 # LATIN SMALL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x01ea, 0, 0, 0}, 0x01ec }, // U01EC # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x01eb, 0, 0, 0}, 0x01ed }, // U01ED # LATIN SMALL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0226, 0, 0, 0}, 0x01e0 }, // U01E0 # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0227, 0, 0, 0}, 0x01e1 }, // U01E1 # LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x022e, 0, 0, 0}, 0x0230 }, // U0230 # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x022f, 0, 0, 0}, 0x0231 }, // U0231 # LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0391, 0, 0, 0}, 0x1fb9 }, // U1FB9 # GREEK CAPITAL LETTER ALPHA WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0399, 0, 0, 0}, 0x1fd9 }, // U1FD9 # GREEK CAPITAL LETTER IOTA WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x03a5, 0, 0, 0}, 0x1fe9 }, // U1FE9 # GREEK CAPITAL LETTER UPSILON WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x03b1, 0, 0, 0}, 0x1fb1 }, // U1FB1 # GREEK SMALL LETTER ALPHA WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x03b9, 0, 0, 0}, 0x1fd1 }, // U1FD1 # GREEK SMALL LETTER IOTA WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x03c5, 0, 0, 0}, 0x1fe1 }, // U1FE1 # GREEK SMALL LETTER UPSILON WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0418, 0, 0, 0}, 0x04e2 }, // U04E2 # CYRILLIC CAPITAL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0423, 0, 0, 0}, 0x04ee }, // U04EE # CYRILLIC CAPITAL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0438, 0, 0, 0}, 0x04e3 }, // U04E3 # CYRILLIC SMALL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0443, 0, 0, 0}, 0x04ef }, // U04EF # CYRILLIC SMALL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x1e36, 0, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x1e37, 0, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x1e5a, 0, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x1e5b, 0, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x2212, 0, 0, 0}, 0x208b }, // U208B # SUBSCRIPT MINUS + { {UNITIZE(TQt::Key_Multi_key), 0x005f, 0x2212, 0, 0, 0}, 0x208b }, // U208B # SUBSCRIPT MINUS + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Abovedot), 0x0041, 0, 0}, 0x01e0 }, // U01E0 # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Abovedot), 0x004f, 0, 0}, 0x0230 }, // U0230 # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Abovedot), 0x0061, 0, 0}, 0x01e1 }, // U01E1 # LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Abovedot), 0x006f, 0, 0}, 0x0231 }, // U0231 # LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0041, 0, 0}, 0x01de }, // U01DE # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Diaeresis), 0x004f, 0, 0}, 0x022a }, // U022A # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0}, 0x01d5 }, // U01D5 # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0061, 0, 0}, 0x01df }, // U01DF # LATIN SMALL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Diaeresis), 0x006f, 0, 0}, 0x022b }, // U022B # LATIN SMALL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0}, 0x01d6 }, // U01D6 # LATIN SMALL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Ogonek), 0x004f, 0, 0}, 0x01ec }, // U01EC # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Ogonek), 0x006f, 0, 0}, 0x01ed }, // U01ED # LATIN SMALL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Belowdot), 0x004c, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Belowdot), 0x0052, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Belowdot), 0x006c, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x005f, UNITIZE(TQt::Key_Dead_Belowdot), 0x0072, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0000, 0, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0000, 0, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0000, 0, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0000, 0, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0020, 0, 0, 0}, 0x0060 }, // grave + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0022, 0x0055, 0, 0}, 0x01db }, // U01DB # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0022, 0x0075, 0, 0}, 0x01dc }, // U01DC # LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0022, 0x03b9, 0, 0}, 0x1fd2 }, // U1FD2 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0022, 0x03c5, 0, 0}, 0x1fe2 }, // U1FE2 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x0391, 0, 0}, 0x1f0b }, // U1F0B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x0395, 0, 0}, 0x1f1b }, // U1F1B # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x0397, 0, 0}, 0x1f2b }, // U1F2B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x0399, 0, 0}, 0x1f3b }, // U1F3B # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x039f, 0, 0}, 0x1f4b }, // U1F4B # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03a5, 0, 0}, 0x1f5b }, // U1F5B # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03a9, 0, 0}, 0x1f6b }, // U1F6B # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03b1, 0, 0}, 0x1f03 }, // U1F03 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03b5, 0, 0}, 0x1f13 }, // U1F13 # GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03b7, 0, 0}, 0x1f23 }, // U1F23 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03b9, 0, 0}, 0x1f33 }, // U1F33 # GREEK SMALL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03bf, 0, 0}, 0x1f43 }, // U1F43 # GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03c5, 0, 0}, 0x1f53 }, // U1F53 # GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03c9, 0, 0}, 0x1f63 }, // U1F63 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x0391, 0, 0}, 0x1f0a }, // U1F0A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x0395, 0, 0}, 0x1f1a }, // U1F1A # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x0397, 0, 0}, 0x1f2a }, // U1F2A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x0399, 0, 0}, 0x1f3a }, // U1F3A # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x039f, 0, 0}, 0x1f4a }, // U1F4A # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03a9, 0, 0}, 0x1f6a }, // U1F6A # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03b1, 0, 0}, 0x1f02 }, // U1F02 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03b5, 0, 0}, 0x1f12 }, // U1F12 # GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03b7, 0, 0}, 0x1f22 }, // U1F22 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03b9, 0, 0}, 0x1f32 }, // U1F32 # GREEK SMALL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03bf, 0, 0}, 0x1f42 }, // U1F42 # GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03c5, 0, 0}, 0x1f52 }, // U1F52 # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03c9, 0, 0}, 0x1f62 }, // U1F62 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x002b, 0x004f, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x002b, 0x0055, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x002b, 0x006f, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x002b, 0x0075, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0041, 0, 0, 0}, 0x00c0 }, // U00C0 # LATIN CAPITAL LETTER A WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0045, 0, 0, 0}, 0x00c8 }, // U00C8 # LATIN CAPITAL LETTER E WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0049, 0, 0, 0}, 0x00cc }, // U00CC # LATIN CAPITAL LETTER I WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x004e, 0, 0, 0}, 0x01f8 }, // U01F8 # LATIN CAPITAL LETTER N WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x004f, 0, 0, 0}, 0x00d2 }, // U00D2 # LATIN CAPITAL LETTER O WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0055, 0, 0, 0}, 0x00d9 }, // U00D9 # LATIN CAPITAL LETTER U WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0055, 0x0041, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0055, 0x0061, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0057, 0, 0, 0}, 0x1e80 }, // U1E80 # LATIN CAPITAL LETTER W WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0059, 0, 0, 0}, 0x1ef2 }, // U1EF2 # LATIN CAPITAL LETTER Y WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005e, 0x0041, 0, 0}, 0x1ea6 }, // U1EA6 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005e, 0x0045, 0, 0}, 0x1ec0 }, // U1EC0 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005e, 0x004f, 0, 0}, 0x1ed2 }, // U1ED2 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005e, 0x0061, 0, 0}, 0x1ea7 }, // U1EA7 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005e, 0x0065, 0, 0}, 0x1ec1 }, // U1EC1 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005e, 0x006f, 0, 0}, 0x1ed3 }, // U1ED3 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005f, 0x0045, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005f, 0x004f, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005f, 0x0065, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x005f, 0x006f, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0061, 0, 0, 0}, 0x00e0 }, // U00E0 # LATIN SMALL LETTER A WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0062, 0x0041, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0062, 0x0061, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0065, 0, 0, 0}, 0x00e8 }, // U00E8 # LATIN SMALL LETTER E WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0069, 0, 0, 0}, 0x00ec }, // U00EC # LATIN SMALL LETTER I WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x006e, 0, 0, 0}, 0x01f9 }, // U01F9 # LATIN SMALL LETTER N WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x006f, 0, 0, 0}, 0x00f2 }, // U00F2 # LATIN SMALL LETTER O WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0075, 0, 0, 0}, 0x00f9 }, // U00F9 # LATIN SMALL LETTER U WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0077, 0, 0, 0}, 0x1e81 }, // U1E81 # LATIN SMALL LETTER W WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0079, 0, 0, 0}, 0x1ef3 }, // U1EF3 # LATIN SMALL LETTER Y WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00af, 0x0045, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00af, 0x004f, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00af, 0x0065, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00af, 0x006f, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00c2, 0, 0, 0}, 0x1ea6 }, // U1EA6 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00ca, 0, 0, 0}, 0x1ec0 }, // U1EC0 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00d4, 0, 0, 0}, 0x1ed2 }, // U1ED2 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00dc, 0, 0, 0}, 0x01db }, // U01DB # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00e2, 0, 0, 0}, 0x1ea7 }, // U1EA7 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00ea, 0, 0, 0}, 0x1ec1 }, // U1EC1 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00f4, 0, 0, 0}, 0x1ed3 }, // U1ED3 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x00fc, 0, 0, 0}, 0x01dc }, // U01DC # LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0102, 0, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0103, 0, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0112, 0, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0113, 0, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x014c, 0, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x014d, 0, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x0391, 0, 0}, 0x1f0a }, // U1F0A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x0395, 0, 0}, 0x1f1a }, // U1F1A # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x0397, 0, 0}, 0x1f2a }, // U1F2A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x0399, 0, 0}, 0x1f3a }, // U1F3A # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x039f, 0, 0}, 0x1f4a }, // U1F4A # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03a9, 0, 0}, 0x1f6a }, // U1F6A # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03b1, 0, 0}, 0x1f02 }, // U1F02 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03b5, 0, 0}, 0x1f12 }, // U1F12 # GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03b7, 0, 0}, 0x1f22 }, // U1F22 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03b9, 0, 0}, 0x1f32 }, // U1F32 # GREEK SMALL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03bf, 0, 0}, 0x1f42 }, // U1F42 # GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03c5, 0, 0}, 0x1f52 }, // U1F52 # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03c9, 0, 0}, 0x1f62 }, // U1F62 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x0391, 0, 0}, 0x1f0b }, // U1F0B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x0395, 0, 0}, 0x1f1b }, // U1F1B # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x0397, 0, 0}, 0x1f2b }, // U1F2B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x0399, 0, 0}, 0x1f3b }, // U1F3B # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x039f, 0, 0}, 0x1f4b }, // U1F4B # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03a5, 0, 0}, 0x1f5b }, // U1F5B # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03a9, 0, 0}, 0x1f6b }, // U1F6B # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03b1, 0, 0}, 0x1f03 }, // U1F03 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03b5, 0, 0}, 0x1f13 }, // U1F13 # GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03b7, 0, 0}, 0x1f23 }, // U1F23 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03b9, 0, 0}, 0x1f33 }, // U1F33 # GREEK SMALL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03bf, 0, 0}, 0x1f43 }, // U1F43 # GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03c5, 0, 0}, 0x1f53 }, // U1F53 # GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03c9, 0, 0}, 0x1f63 }, // U1F63 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0391, 0, 0, 0}, 0x1fba }, // U1FBA # GREEK CAPITAL LETTER ALPHA WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0395, 0, 0, 0}, 0x1fc8 }, // U1FC8 # GREEK CAPITAL LETTER EPSILON WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0397, 0, 0, 0}, 0x1fca }, // U1FCA # GREEK CAPITAL LETTER ETA WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0399, 0, 0, 0}, 0x1fda }, // U1FDA # GREEK CAPITAL LETTER IOTA WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x039f, 0, 0, 0}, 0x1ff8 }, // U1FF8 # GREEK CAPITAL LETTER OMICRON WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03a5, 0, 0, 0}, 0x1fea }, // U1FEA # GREEK CAPITAL LETTER UPSILON WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03a9, 0, 0, 0}, 0x1ffa }, // U1FFA # GREEK CAPITAL LETTER OMEGA WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03b1, 0, 0, 0}, 0x1f70 }, // U1F70 # GREEK SMALL LETTER ALPHA WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03b5, 0, 0, 0}, 0x1f72 }, // U1F72 # GREEK SMALL LETTER EPSILON WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03b7, 0, 0, 0}, 0x1f74 }, // U1F74 # GREEK SMALL LETTER ETA WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03b9, 0, 0, 0}, 0x1f76 }, // U1F76 # GREEK SMALL LETTER IOTA WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03bf, 0, 0, 0}, 0x1f78 }, // U1F78 # GREEK SMALL LETTER OMICRON WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03c5, 0, 0, 0}, 0x1f7a }, // U1F7A # GREEK SMALL LETTER UPSILON WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03c9, 0, 0, 0}, 0x1f7c }, // U1F7C # GREEK SMALL LETTER OMEGA WITH VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03ca, 0, 0, 0}, 0x1fd2 }, // U1FD2 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03cb, 0, 0, 0}, 0x1fe2 }, // U1FE2 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0415, 0, 0, 0}, 0x0400 }, // U0400 # CYRILLIC CAPITAL LETTER IE WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0418, 0, 0, 0}, 0x040d }, // U040D # CYRILLIC CAPITAL LETTER I WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0435, 0, 0, 0}, 0x0450 }, // U0450 # CYRILLIC SMALL LETTER IE WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0438, 0, 0, 0}, 0x045d }, // U045D # CYRILLIC SMALL LETTER I WITH GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f00, 0, 0, 0}, 0x1f02 }, // U1F02 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f01, 0, 0, 0}, 0x1f03 }, // U1F03 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f08, 0, 0, 0}, 0x1f0a }, // U1F0A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f09, 0, 0, 0}, 0x1f0b }, // U1F0B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f10, 0, 0, 0}, 0x1f12 }, // U1F12 # GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f11, 0, 0, 0}, 0x1f13 }, // U1F13 # GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f18, 0, 0, 0}, 0x1f1a }, // U1F1A # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f19, 0, 0, 0}, 0x1f1b }, // U1F1B # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f20, 0, 0, 0}, 0x1f22 }, // U1F22 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f21, 0, 0, 0}, 0x1f23 }, // U1F23 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f28, 0, 0, 0}, 0x1f2a }, // U1F2A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f29, 0, 0, 0}, 0x1f2b }, // U1F2B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f30, 0, 0, 0}, 0x1f32 }, // U1F32 # GREEK SMALL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f31, 0, 0, 0}, 0x1f33 }, // U1F33 # GREEK SMALL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f38, 0, 0, 0}, 0x1f3a }, // U1F3A # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f39, 0, 0, 0}, 0x1f3b }, // U1F3B # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f40, 0, 0, 0}, 0x1f42 }, // U1F42 # GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f41, 0, 0, 0}, 0x1f43 }, // U1F43 # GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f48, 0, 0, 0}, 0x1f4a }, // U1F4A # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f49, 0, 0, 0}, 0x1f4b }, // U1F4B # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f50, 0, 0, 0}, 0x1f52 }, // U1F52 # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f51, 0, 0, 0}, 0x1f53 }, // U1F53 # GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f59, 0, 0, 0}, 0x1f5b }, // U1F5B # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f60, 0, 0, 0}, 0x1f62 }, // U1F62 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f61, 0, 0, 0}, 0x1f63 }, // U1F63 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f68, 0, 0, 0}, 0x1f6a }, // U1F6A # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f69, 0, 0, 0}, 0x1f6b }, // U1F6B # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0}, 0x1ea6 }, // U1EA6 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0}, 0x1ec0 }, // U1EC0 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0}, 0x1ed2 }, // U1ED2 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0}, 0x1ea7 }, // U1EA7 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0}, 0x1ec1 }, // U1EC1 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0}, 0x1ed3 }, // U1ED3 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Macron), 0x0045, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Macron), 0x004f, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Macron), 0x0065, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Macron), 0x006f, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0}, 0x01db }, // U01DB # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0}, 0x01dc }, // U01DC # LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0}, 0x1fd2 }, // U1FD2 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0}, 0x1fe2 }, // U1FE2 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0060, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Multi_key), 0x0061, 0x0065, 0, 0, 0}, 0x00e6 }, // ae +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0000, 0x0041, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0000, 0x0061, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0021, 0x0041, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0021, 0x0061, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x002c, 0x0045, 0, 0}, 0x1e1c }, // U1E1C # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x002c, 0x0065, 0, 0}, 0x1e1d }, // U1E1D # LATIN SMALL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0041, 0, 0, 0}, 0x0102 }, // U0102 # LATIN CAPITAL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0045, 0, 0, 0}, 0x0114 }, // U0114 # LATIN CAPITAL LETTER E WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0047, 0, 0, 0}, 0x011e }, // U011E # LATIN CAPITAL LETTER G WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0049, 0, 0, 0}, 0x012c }, // U012C # LATIN CAPITAL LETTER I WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x004f, 0, 0, 0}, 0x014e }, // U014E # LATIN CAPITAL LETTER O WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0055, 0, 0, 0}, 0x016c }, // U016C # LATIN CAPITAL LETTER U WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0061, 0, 0, 0}, 0x0103 }, // U0103 # LATIN SMALL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0065, 0, 0, 0}, 0x0115 }, // U0115 # LATIN SMALL LETTER E WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0067, 0, 0, 0}, 0x011f }, // U011F # LATIN SMALL LETTER G WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0069, 0, 0, 0}, 0x012d }, // U012D # LATIN SMALL LETTER I WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x006f, 0, 0, 0}, 0x014f }, // U014F # LATIN SMALL LETTER O WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0075, 0, 0, 0}, 0x016d }, // U016D # LATIN SMALL LETTER U WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0228, 0, 0, 0}, 0x1e1c }, // U1E1C # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0229, 0, 0, 0}, 0x1e1d }, // U1E1D # LATIN SMALL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0391, 0, 0, 0}, 0x1fb8 }, // U1FB8 # GREEK CAPITAL LETTER ALPHA WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0399, 0, 0, 0}, 0x1fd8 }, // U1FD8 # GREEK CAPITAL LETTER IOTA WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x03a5, 0, 0, 0}, 0x1fe8 }, // U1FE8 # GREEK CAPITAL LETTER UPSILON WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x03b1, 0, 0, 0}, 0x1fb0 }, // U1FB0 # GREEK SMALL LETTER ALPHA WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x03b9, 0, 0, 0}, 0x1fd0 }, // U1FD0 # GREEK SMALL LETTER IOTA WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x03c5, 0, 0, 0}, 0x1fe0 }, // U1FE0 # GREEK SMALL LETTER UPSILON WITH VRACHY + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0410, 0, 0, 0}, 0x04d0 }, // U04D0 # CYRILLIC CAPITAL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0415, 0, 0, 0}, 0x04d6 }, // U04D6 # CYRILLIC CAPITAL LETTER IE WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0416, 0, 0, 0}, 0x04c1 }, // U04C1 # CYRILLIC CAPITAL LETTER ZHE WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0418, 0, 0, 0}, 0x0419 }, // U0419 # CYRILLIC CAPITAL LETTER SHORT I + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0423, 0, 0, 0}, 0x040e }, // U040E # CYRILLIC CAPITAL LETTER SHORT U + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0430, 0, 0, 0}, 0x04d1 }, // U04D1 # CYRILLIC SMALL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0435, 0, 0, 0}, 0x04d7 }, // U04D7 # CYRILLIC SMALL LETTER IE WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0436, 0, 0, 0}, 0x04c2 }, // U04C2 # CYRILLIC SMALL LETTER ZHE WITH BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0438, 0, 0, 0}, 0x0439 }, // U0439 # CYRILLIC SMALL LETTER SHORT I + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0443, 0, 0, 0}, 0x045e }, // U045E # CYRILLIC SMALL LETTER SHORT U + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x1ea0, 0, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0062, 0x1ea1, 0, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0062, UNITIZE(TQt::Key_Dead_Cedilla), 0x0045, 0, 0}, 0x1e1c }, // U1E1C # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, UNITIZE(TQt::Key_Dead_Cedilla), 0x0065, 0, 0}, 0x1e1d }, // U1E1D # LATIN SMALL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Multi_key), 0x0062, UNITIZE(TQt::Key_Dead_Belowdot), 0x0041, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0062, UNITIZE(TQt::Key_Dead_Belowdot), 0x0061, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0022, 0x0055, 0, 0}, 0x01d9 }, // U01D9 # LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0022, 0x0075, 0, 0}, 0x01da }, // U01DA # LATIN SMALL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x002f, 0, 0, 0}, 0x00a2 }, // U00A2 # CENT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0041, 0, 0, 0}, 0x01cd }, // U01CD # LATIN CAPITAL LETTER A WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0043, 0, 0, 0}, 0x010c }, // U010C # LATIN CAPITAL LETTER C WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0044, 0, 0, 0}, 0x010e }, // U010E # LATIN CAPITAL LETTER D WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0045, 0, 0, 0}, 0x011a }, // U011A # LATIN CAPITAL LETTER E WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0047, 0, 0, 0}, 0x01e6 }, // U01E6 # LATIN CAPITAL LETTER G WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0048, 0, 0, 0}, 0x021e }, // U021E # LATIN CAPITAL LETTER H WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0049, 0, 0, 0}, 0x01cf }, // U01CF # LATIN CAPITAL LETTER I WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x004b, 0, 0, 0}, 0x01e8 }, // U01E8 # LATIN CAPITAL LETTER K WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x004c, 0, 0, 0}, 0x013d }, // U013D # LATIN CAPITAL LETTER L WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x004e, 0, 0, 0}, 0x0147 }, // U0147 # LATIN CAPITAL LETTER N WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x004f, 0, 0, 0}, 0x01d1 }, // U01D1 # LATIN CAPITAL LETTER O WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0052, 0, 0, 0}, 0x0158 }, // U0158 # LATIN CAPITAL LETTER R WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0053, 0, 0, 0}, 0x0160 }, // U0160 # LATIN CAPITAL LETTER S WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0054, 0, 0, 0}, 0x0164 }, // U0164 # LATIN CAPITAL LETTER T WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0055, 0, 0, 0}, 0x01d3 }, // U01D3 # LATIN CAPITAL LETTER U WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x005a, 0, 0, 0}, 0x017d }, // U017D # LATIN CAPITAL LETTER Z WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0061, 0, 0, 0}, 0x01ce }, // U01CE # LATIN SMALL LETTER A WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0063, 0, 0, 0}, 0x010d }, // U010D # LATIN SMALL LETTER C WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0064, 0, 0, 0}, 0x010f }, // U010F # LATIN SMALL LETTER D WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0065, 0, 0, 0}, 0x011b }, // U011B # LATIN SMALL LETTER E WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0067, 0, 0, 0}, 0x01e7 }, // U01E7 # LATIN SMALL LETTER G WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0068, 0, 0, 0}, 0x021f }, // U021F # LATIN SMALL LETTER H WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0069, 0, 0, 0}, 0x01d0 }, // U01D0 # LATIN SMALL LETTER I WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x006a, 0, 0, 0}, 0x01f0 }, // U01F0 # LATIN SMALL LETTER J WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x006b, 0, 0, 0}, 0x01e9 }, // U01E9 # LATIN SMALL LETTER K WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x006c, 0, 0, 0}, 0x013e }, // U013E # LATIN SMALL LETTER L WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x006e, 0, 0, 0}, 0x0148 }, // U0148 # LATIN SMALL LETTER N WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x006f, 0, 0, 0}, 0x01d2 }, // U01D2 # LATIN SMALL LETTER O WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0072, 0, 0, 0}, 0x0159 }, // U0159 # LATIN SMALL LETTER R WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0073, 0, 0, 0}, 0x0161 }, // U0161 # LATIN SMALL LETTER S WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0074, 0, 0, 0}, 0x0165 }, // U0165 # LATIN SMALL LETTER T WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0075, 0, 0, 0}, 0x01d4 }, // U01D4 # LATIN SMALL LETTER U WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x007a, 0, 0, 0}, 0x017e }, // U017E # LATIN SMALL LETTER Z WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x007c, 0, 0, 0}, 0x00a2 }, // U00A2 # CENT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x00dc, 0, 0, 0}, 0x01d9 }, // U01D9 # LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x00fc, 0, 0, 0}, 0x01da }, // U01DA # LATIN SMALL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x01b7, 0, 0, 0}, 0x01ee }, // U01EE # LATIN CAPITAL LETTER EZH WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0292, 0, 0, 0}, 0x01ef }, // U01EF # LATIN SMALL LETTER EZH WITH CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0}, 0x01d9 }, // U01D9 # LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0063, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0}, 0x01da }, // U01DA # LATIN SMALL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Multi_key), 0x0064, 0x002d, 0, 0, 0}, 0x20ab }, // U20ab # DONG SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0064, 0x0068, 0, 0, 0}, 0x00f0 }, // U00F0 # LATIN SMALL LETTER ETH + { {UNITIZE(TQt::Key_Multi_key), 0x0065, 0x0065, 0, 0, 0}, 0x0259 }, // U0259 # LATIN SMALL LETTER SCHWA + { {UNITIZE(TQt::Key_Multi_key), 0x0066, 0x0053, 0, 0, 0}, 0x017f }, // U017f # LONG S + { {UNITIZE(TQt::Key_Multi_key), 0x0066, 0x0073, 0, 0, 0}, 0x017f }, // U017f # LONG S + { {UNITIZE(TQt::Key_Multi_key), 0x0069, 0x002e, 0, 0, 0}, 0x0131 }, // U0131 # LATIN SMALL LETTER DOTLESS I + { {UNITIZE(TQt::Key_Multi_key), 0x006b, 0x006b, 0, 0, 0}, 0x0138 }, // U0138 # LATIN SMALL LETTER KRA + { {UNITIZE(TQt::Key_Multi_key), 0x006c, 0x0076, 0, 0, 0}, 0x007c }, // bar + { {UNITIZE(TQt::Key_Multi_key), 0x006d, 0x002f, 0, 0, 0}, 0x20a5 }, // U20a5 # MILL SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x006d, 0x0075, 0, 0, 0}, 0x00b5 }, // U00B5 # MICRO SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x006e, 0x0067, 0, 0, 0}, 0x014b }, // U014B # LATIN SMALL LETTER ENG + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0027, 0x0041, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0027, 0x0061, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0041, 0, 0, 0}, 0x00c5 }, // U00C5 # LATIN CAPITAL LETTER A WITH RING ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0043, 0, 0, 0}, 0x00a9 }, // copyright + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0052, 0, 0, 0}, 0x00ae }, // registered + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0055, 0, 0, 0}, 0x016e }, // U016E # LATIN CAPITAL LETTER U WITH RING ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0061, 0, 0, 0}, 0x00e5 }, // U00E5 # LATIN SMALL LETTER A WITH RING ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0063, 0, 0, 0}, 0x00a9 }, // copyright + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0065, 0, 0, 0}, 0x0153 }, // oe + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x006f, 0, 0, 0}, 0x00b0 }, // degree # ^0 already taken + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0072, 0, 0, 0}, 0x00ae }, // registered + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0073, 0, 0, 0}, 0x00a7 }, // section # SECTION SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0075, 0, 0, 0}, 0x016f }, // U016F # LATIN SMALL LETTER U WITH RING ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0077, 0, 0, 0}, 0x1e98 }, // U1E98 # LATIN SMALL LETTER W WITH RING ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0078, 0, 0, 0}, 0x00a4 }, // currency + { {UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0079, 0, 0, 0}, 0x1e99 }, // U1E99 # LATIN SMALL LETTER Y WITH RING ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x0070, 0x0021, 0, 0, 0}, 0x00b6 }, // paragraph + { {UNITIZE(TQt::Key_Multi_key), 0x0073, 0x006f, 0, 0, 0}, 0x00a7 }, // section # SECTION SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x0073, 0x0073, 0, 0, 0}, 0x00df }, // ssharp + { {UNITIZE(TQt::Key_Multi_key), 0x0074, 0x0068, 0, 0, 0}, 0x00fe }, // U00FE # LATIN SMALL LETTER THORN + { {UNITIZE(TQt::Key_Multi_key), 0x0076, 0x006c, 0, 0, 0}, 0x007c }, // bar + { {UNITIZE(TQt::Key_Multi_key), 0x0078, 0x006f, 0, 0, 0}, 0x00a4 }, // currency + { {UNITIZE(TQt::Key_Multi_key), 0x0078, 0x0078, 0, 0, 0}, 0x00d7 }, // U00D7 # MULTIPLICATION SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x007c, 0x0043, 0, 0, 0}, 0x00a2 }, // U00A2 # CENT SIGN + { {UNITIZE(TQt::Key_Multi_key), 0x007c, 0x0063, 0, 0, 0}, 0x00a2 }, // U00A2 # CENT SIGN +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0000, 0, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0000, 0, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0000, 0, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0000, 0, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0020, 0, 0, 0}, 0x007e }, // asciitilde + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0022, 0x03b9, 0, 0}, 0x1fd7 }, // U1FD7 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0022, 0x03c5, 0, 0}, 0x1fe7 }, // U1FE7 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x0391, 0, 0}, 0x1f0f }, // U1F0F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x0397, 0, 0}, 0x1f2f }, // U1F2F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x0399, 0, 0}, 0x1f3f }, // U1F3F # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03a5, 0, 0}, 0x1f5f }, // U1F5F # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03a9, 0, 0}, 0x1f6f }, // U1F6F # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03b1, 0, 0}, 0x1f07 }, // U1F07 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03b7, 0, 0}, 0x1f27 }, // U1F27 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03b9, 0, 0}, 0x1f37 }, // U1F37 # GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03c5, 0, 0}, 0x1f57 }, // U1F57 # GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03c9, 0, 0}, 0x1f67 }, // U1F67 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x0391, 0, 0}, 0x1f0e }, // U1F0E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x0397, 0, 0}, 0x1f2e }, // U1F2E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x0399, 0, 0}, 0x1f3e }, // U1F3E # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03a9, 0, 0}, 0x1f6e }, // U1F6E # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03b1, 0, 0}, 0x1f06 }, // U1F06 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03b7, 0, 0}, 0x1f26 }, // U1F26 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03b9, 0, 0}, 0x1f36 }, // U1F36 # GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03c5, 0, 0}, 0x1f56 }, // U1F56 # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03c9, 0, 0}, 0x1f66 }, // U1F66 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x002b, 0x004f, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x002b, 0x0055, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x002b, 0x006f, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x002b, 0x0075, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0041, 0, 0, 0}, 0x00c3 }, // U00C3 # LATIN CAPITAL LETTER A WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0045, 0, 0, 0}, 0x1ebc }, // U1EBC # LATIN CAPITAL LETTER E WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0049, 0, 0, 0}, 0x0128 }, // U0128 # LATIN CAPITAL LETTER I WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x004e, 0, 0, 0}, 0x00d1 }, // U00D1 # LATIN CAPITAL LETTER N WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x004f, 0, 0, 0}, 0x00d5 }, // U00D5 # LATIN CAPITAL LETTER O WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0055, 0, 0, 0}, 0x0168 }, // U0168 # LATIN CAPITAL LETTER U WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0055, 0x0041, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0055, 0x0061, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0056, 0, 0, 0}, 0x1e7c }, // U1E7C # LATIN CAPITAL LETTER V WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0059, 0, 0, 0}, 0x1ef8 }, // U1EF8 # LATIN CAPITAL LETTER Y WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x005e, 0x0041, 0, 0}, 0x1eaa }, // U1EAA # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x005e, 0x0045, 0, 0}, 0x1ec4 }, // U1EC4 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x005e, 0x004f, 0, 0}, 0x1ed6 }, // U1ED6 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x005e, 0x0061, 0, 0}, 0x1eab }, // U1EAB # LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x005e, 0x0065, 0, 0}, 0x1ec5 }, // U1EC5 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x005e, 0x006f, 0, 0}, 0x1ed7 }, // U1ED7 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0061, 0, 0, 0}, 0x00e3 }, // U00E3 # LATIN SMALL LETTER A WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0062, 0x0041, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0062, 0x0061, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0065, 0, 0, 0}, 0x1ebd }, // U1EBD # LATIN SMALL LETTER E WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0069, 0, 0, 0}, 0x0129 }, // U0129 # LATIN SMALL LETTER I WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x006e, 0, 0, 0}, 0x00f1 }, // U00F1 # LATIN SMALL LETTER N WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x006f, 0, 0, 0}, 0x00f5 }, // U00F5 # LATIN SMALL LETTER O WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0075, 0, 0, 0}, 0x0169 }, // U0169 # LATIN SMALL LETTER U WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0076, 0, 0, 0}, 0x1e7d }, // U1E7D # LATIN SMALL LETTER V WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0079, 0, 0, 0}, 0x1ef9 }, // U1EF9 # LATIN SMALL LETTER Y WITH TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x00c2, 0, 0, 0}, 0x1eaa }, // U1EAA # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x00ca, 0, 0, 0}, 0x1ec4 }, // U1EC4 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x00d4, 0, 0, 0}, 0x1ed6 }, // U1ED6 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x00e2, 0, 0, 0}, 0x1eab }, // U1EAB # LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x00ea, 0, 0, 0}, 0x1ec5 }, // U1EC5 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x00f4, 0, 0, 0}, 0x1ed7 }, // U1ED7 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0102, 0, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0103, 0, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x0391, 0, 0}, 0x1f0e }, // U1F0E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x0397, 0, 0}, 0x1f2e }, // U1F2E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x0399, 0, 0}, 0x1f3e }, // U1F3E # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03a9, 0, 0}, 0x1f6e }, // U1F6E # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03b1, 0, 0}, 0x1f06 }, // U1F06 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03b7, 0, 0}, 0x1f26 }, // U1F26 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03b9, 0, 0}, 0x1f36 }, // U1F36 # GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03c5, 0, 0}, 0x1f56 }, // U1F56 # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03c9, 0, 0}, 0x1f66 }, // U1F66 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x0391, 0, 0}, 0x1f0f }, // U1F0F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x0397, 0, 0}, 0x1f2f }, // U1F2F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x0399, 0, 0}, 0x1f3f }, // U1F3F # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03a5, 0, 0}, 0x1f5f }, // U1F5F # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03a9, 0, 0}, 0x1f6f }, // U1F6F # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03b1, 0, 0}, 0x1f07 }, // U1F07 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03b7, 0, 0}, 0x1f27 }, // U1F27 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03b9, 0, 0}, 0x1f37 }, // U1F37 # GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03c5, 0, 0}, 0x1f57 }, // U1F57 # GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03c9, 0, 0}, 0x1f67 }, // U1F67 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03b1, 0, 0, 0}, 0x1fb6 }, // U1FB6 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03b7, 0, 0, 0}, 0x1fc6 }, // U1FC6 # GREEK SMALL LETTER ETA WITH PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03b9, 0, 0, 0}, 0x1fd6 }, // U1FD6 # GREEK SMALL LETTER IOTA WITH PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03c5, 0, 0, 0}, 0x1fe6 }, // U1FE6 # GREEK SMALL LETTER UPSILON WITH PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03c9, 0, 0, 0}, 0x1ff6 }, // U1FF6 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03ca, 0, 0, 0}, 0x1fd7 }, // U1FD7 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03cb, 0, 0, 0}, 0x1fe7 }, // U1FE7 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f00, 0, 0, 0}, 0x1f06 }, // U1F06 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f01, 0, 0, 0}, 0x1f07 }, // U1F07 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f08, 0, 0, 0}, 0x1f0e }, // U1F0E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f09, 0, 0, 0}, 0x1f0f }, // U1F0F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f20, 0, 0, 0}, 0x1f26 }, // U1F26 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f21, 0, 0, 0}, 0x1f27 }, // U1F27 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f28, 0, 0, 0}, 0x1f2e }, // U1F2E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f29, 0, 0, 0}, 0x1f2f }, // U1F2F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f30, 0, 0, 0}, 0x1f36 }, // U1F36 # GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f31, 0, 0, 0}, 0x1f37 }, // U1F37 # GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f38, 0, 0, 0}, 0x1f3e }, // U1F3E # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f39, 0, 0, 0}, 0x1f3f }, // U1F3F # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f50, 0, 0, 0}, 0x1f56 }, // U1F56 # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f51, 0, 0, 0}, 0x1f57 }, // U1F57 # GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f59, 0, 0, 0}, 0x1f5f }, // U1F5F # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f60, 0, 0, 0}, 0x1f66 }, // U1F66 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f61, 0, 0, 0}, 0x1f67 }, // U1F67 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f68, 0, 0, 0}, 0x1f6e }, // U1F6E # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f69, 0, 0, 0}, 0x1f6f }, // U1F6F # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0}, 0x1eaa }, // U1EAA # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0}, 0x1ec4 }, // U1EC4 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0}, 0x1ed6 }, // U1ED6 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0}, 0x1eab }, // U1EAB # LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0}, 0x1ec5 }, // U1EC5 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0}, 0x1ed7 }, // U1ED7 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0}, 0x1fd7 }, // U1FD7 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0}, 0x1fe7 }, // U1FE7 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x007e, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00a8, 0x0000, 0, 0, 0}, 0x0385 }, // U0385 # GREEK DIALYTIKA TONOS +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00a8, 0x0000, 0, 0, 0}, 0x1fed }, // U1FED # GREEK DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x00a8, 0x0027, 0, 0, 0}, 0x0385 }, // U0385 # GREEK DIALYTIKA TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00a8, 0x0060, 0, 0, 0}, 0x1fed }, // U1FED # GREEK DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x00a8, 0x007e, 0, 0, 0}, 0x1fc1 }, // U1FC1 # GREEK DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x00a8, 0x00b4, 0, 0, 0}, 0x0385 }, // U0385 # GREEK DIALYTIKA TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00a8, 0x0342, 0, 0, 0}, 0x1fc1 }, // U1FC1 # GREEK DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x00a8, UNITIZE(TQt::Key_Dead_Grave), 0, 0, 0}, 0x1fed }, // U1FED # GREEK DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x00a8, UNITIZE(TQt::Key_Dead_Acute), 0, 0, 0}, 0x0385 }, // U0385 # GREEK DIALYTIKA TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00a8, UNITIZE(TQt::Key_Dead_Tilde), 0, 0, 0}, 0x1fc1 }, // U1FC1 # GREEK DIALYTIKA AND PERISPOMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0000, 0x004c, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0000, 0x004f, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0000, 0x0052, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0000, 0x006c, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0000, 0x006f, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0000, 0x0072, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0021, 0x004c, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0021, 0x0052, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0021, 0x006c, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0021, 0x0072, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0022, 0x0041, 0, 0}, 0x01de }, // U01DE # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0022, 0x004f, 0, 0}, 0x022a }, // U022A # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0022, 0x0055, 0, 0}, 0x01d5 }, // U01D5 # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0022, 0x0061, 0, 0}, 0x01df }, // U01DF # LATIN SMALL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0022, 0x006f, 0, 0}, 0x022b }, // U022B # LATIN SMALL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0022, 0x0075, 0, 0}, 0x01d6 }, // U01D6 # LATIN SMALL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x002e, 0x0041, 0, 0}, 0x01e0 }, // U01E0 # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x002e, 0x004f, 0, 0}, 0x0230 }, // U0230 # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x002e, 0x0061, 0, 0}, 0x01e1 }, // U01E1 # LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x002e, 0x006f, 0, 0}, 0x0231 }, // U0231 # LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x003b, 0x004f, 0, 0}, 0x01ec }, // U01EC # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x003b, 0x006f, 0, 0}, 0x01ed }, // U01ED # LATIN SMALL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0041, 0, 0, 0}, 0x0100 }, // U0100 # LATIN CAPITAL LETTER A WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0045, 0, 0, 0}, 0x0112 }, // U0112 # LATIN CAPITAL LETTER E WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0047, 0, 0, 0}, 0x1e20 }, // U1E20 # LATIN CAPITAL LETTER G WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0049, 0, 0, 0}, 0x012a }, // U012A # LATIN CAPITAL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x004f, 0, 0, 0}, 0x014c }, // U014C # LATIN CAPITAL LETTER O WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0055, 0, 0, 0}, 0x016a }, // U016A # LATIN CAPITAL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0059, 0, 0, 0}, 0x0232 }, // U0232 # LATIN CAPITAL LETTER Y WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0061, 0, 0, 0}, 0x0101 }, // U0101 # LATIN SMALL LETTER A WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0065, 0, 0, 0}, 0x0113 }, // U0113 # LATIN SMALL LETTER E WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0067, 0, 0, 0}, 0x1e21 }, // U1E21 # LATIN SMALL LETTER G WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0069, 0, 0, 0}, 0x012b }, // U012B # LATIN SMALL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x006f, 0, 0, 0}, 0x014d }, // U014D # LATIN SMALL LETTER O WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0075, 0, 0, 0}, 0x016b }, // U016B # LATIN SMALL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0079, 0, 0, 0}, 0x0233 }, // U0233 # LATIN SMALL LETTER Y WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x007e, 0x004f, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x007e, 0x006f, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00c4, 0, 0, 0}, 0x01de }, // U01DE # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00c6, 0, 0, 0}, 0x01e2 }, // U01E2 # LATIN CAPITAL LETTER AE WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00d5, 0, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00d6, 0, 0, 0}, 0x022a }, // U022A # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00dc, 0, 0, 0}, 0x01d5 }, // U01D5 # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00e4, 0, 0, 0}, 0x01df }, // U01DF # LATIN SMALL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00e6, 0, 0, 0}, 0x01e3 }, // U01E3 # LATIN SMALL LETTER AE WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00f5, 0, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00f6, 0, 0, 0}, 0x022b }, // U022B # LATIN SMALL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x00fc, 0, 0, 0}, 0x01d6 }, // U01D6 # LATIN SMALL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x01ea, 0, 0, 0}, 0x01ec }, // U01EC # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x01eb, 0, 0, 0}, 0x01ed }, // U01ED # LATIN SMALL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0226, 0, 0, 0}, 0x01e0 }, // U01E0 # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0227, 0, 0, 0}, 0x01e1 }, // U01E1 # LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x022e, 0, 0, 0}, 0x0230 }, // U0230 # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x022f, 0, 0, 0}, 0x0231 }, // U0231 # LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0391, 0, 0, 0}, 0x1fb9 }, // U1FB9 # GREEK CAPITAL LETTER ALPHA WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0399, 0, 0, 0}, 0x1fd9 }, // U1FD9 # GREEK CAPITAL LETTER IOTA WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x03a5, 0, 0, 0}, 0x1fe9 }, // U1FE9 # GREEK CAPITAL LETTER UPSILON WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x03b1, 0, 0, 0}, 0x1fb1 }, // U1FB1 # GREEK SMALL LETTER ALPHA WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x03b9, 0, 0, 0}, 0x1fd1 }, // U1FD1 # GREEK SMALL LETTER IOTA WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x03c5, 0, 0, 0}, 0x1fe1 }, // U1FE1 # GREEK SMALL LETTER UPSILON WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0418, 0, 0, 0}, 0x04e2 }, // U04E2 # CYRILLIC CAPITAL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0423, 0, 0, 0}, 0x04ee }, // U04EE # CYRILLIC CAPITAL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0438, 0, 0, 0}, 0x04e3 }, // U04E3 # CYRILLIC SMALL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0443, 0, 0, 0}, 0x04ef }, // U04EF # CYRILLIC SMALL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x1e36, 0, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x1e37, 0, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x1e5a, 0, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, 0x1e5b, 0, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Abovedot), 0x0041, 0, 0}, 0x01e0 }, // U01E0 # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Abovedot), 0x004f, 0, 0}, 0x0230 }, // U0230 # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Abovedot), 0x0061, 0, 0}, 0x01e1 }, // U01E1 # LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Abovedot), 0x006f, 0, 0}, 0x0231 }, // U0231 # LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0041, 0, 0}, 0x01de }, // U01DE # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Diaeresis), 0x004f, 0, 0}, 0x022a }, // U022A # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0}, 0x01d5 }, // U01D5 # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0061, 0, 0}, 0x01df }, // U01DF # LATIN SMALL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Diaeresis), 0x006f, 0, 0}, 0x022b }, // U022B # LATIN SMALL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0}, 0x01d6 }, // U01D6 # LATIN SMALL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Ogonek), 0x004f, 0, 0}, 0x01ec }, // U01EC # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Ogonek), 0x006f, 0, 0}, 0x01ed }, // U01ED # LATIN SMALL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Belowdot), 0x004c, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Belowdot), 0x0052, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Belowdot), 0x006c, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Multi_key), 0x00af, UNITIZE(TQt::Key_Dead_Belowdot), 0x0072, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0x004f, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0x004f, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0x0055, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0x006f, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0x006f, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0000, 0x0075, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0022, 0x0049, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0022, 0x0055, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0022, 0x0069, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0022, 0x0075, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0022, 0x03b9, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0022, 0x03c5, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x0391, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x0395, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x0397, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x0399, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x039f, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03a5, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03a9, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03b1, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03b5, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03b7, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03b9, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03bf, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03c5, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03c9, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x0391, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x0395, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x0397, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x0399, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x039f, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03a9, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03b1, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03b5, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03b7, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03b9, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03bf, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03c5, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03c9, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x002b, 0x004f, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x002b, 0x0055, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x002b, 0x006f, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x002b, 0x0075, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x002c, 0x0043, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x002c, 0x0063, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x002f, 0x004f, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x002f, 0x006f, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0041, 0, 0, 0}, 0x00c1 }, // U00C1 # LATIN CAPITAL LETTER A WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0043, 0, 0, 0}, 0x0106 }, // U0106 # LATIN CAPITAL LETTER C WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0045, 0, 0, 0}, 0x00c9 }, // U00C9 # LATIN CAPITAL LETTER E WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0047, 0, 0, 0}, 0x01f4 }, // U01F4 # LATIN CAPITAL LETTER G WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0049, 0, 0, 0}, 0x00cd }, // U00CD # LATIN CAPITAL LETTER I WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x004b, 0, 0, 0}, 0x1e30 }, // U1E30 # LATIN CAPITAL LETTER K WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x004c, 0, 0, 0}, 0x0139 }, // U0139 # LATIN CAPITAL LETTER L WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x004d, 0, 0, 0}, 0x1e3e }, // U1E3E # LATIN CAPITAL LETTER M WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x004e, 0, 0, 0}, 0x0143 }, // U0143 # LATIN CAPITAL LETTER N WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x004f, 0, 0, 0}, 0x00d3 }, // U00D3 # LATIN CAPITAL LETTER O WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0050, 0, 0, 0}, 0x1e54 }, // U1E54 # LATIN CAPITAL LETTER P WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0052, 0, 0, 0}, 0x0154 }, // U0154 # LATIN CAPITAL LETTER R WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0053, 0, 0, 0}, 0x015a }, // U015A # LATIN CAPITAL LETTER S WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0055, 0, 0, 0}, 0x00da }, // U00DA # LATIN CAPITAL LETTER U WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0055, 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0055, 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0057, 0, 0, 0}, 0x1e82 }, // U1E82 # LATIN CAPITAL LETTER W WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0059, 0, 0, 0}, 0x00dd }, // U00DD # LATIN CAPITAL LETTER Y WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005a, 0, 0, 0}, 0x0179 }, // U0179 # LATIN CAPITAL LETTER Z WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005e, 0x0041, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005e, 0x0045, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005e, 0x004f, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005e, 0x0061, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005e, 0x0065, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005e, 0x006f, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005f, 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005f, 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005f, 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x005f, 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0061, 0, 0, 0}, 0x00e1 }, // U00E1 # LATIN SMALL LETTER A WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0062, 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0062, 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0063, 0, 0, 0}, 0x0107 }, // U0107 # LATIN SMALL LETTER C WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0065, 0, 0, 0}, 0x00e9 }, // U00E9 # LATIN SMALL LETTER E WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0067, 0, 0, 0}, 0x01f5 }, // U01F5 # LATIN SMALL LETTER G WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0069, 0, 0, 0}, 0x00ed }, // U00ED # LATIN SMALL LETTER I WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x006b, 0, 0, 0}, 0x1e31 }, // U1E31 # LATIN SMALL LETTER K WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x006c, 0, 0, 0}, 0x013a }, // U013A # LATIN SMALL LETTER L WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x006d, 0, 0, 0}, 0x1e3f }, // U1E3F # LATIN SMALL LETTER M WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x006e, 0, 0, 0}, 0x0144 }, // U0144 # LATIN SMALL LETTER N WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x006f, 0, 0, 0}, 0x00f3 }, // U00F3 # LATIN SMALL LETTER O WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x006f, 0x0041, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x006f, 0x0061, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0070, 0, 0, 0}, 0x1e55 }, // U1E55 # LATIN SMALL LETTER P WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0072, 0, 0, 0}, 0x0155 }, // U0155 # LATIN SMALL LETTER R WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0073, 0, 0, 0}, 0x015b }, // U015B # LATIN SMALL LETTER S WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0075, 0, 0, 0}, 0x00fa }, // U00FA # LATIN SMALL LETTER U WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0077, 0, 0, 0}, 0x1e83 }, // U1E83 # LATIN SMALL LETTER W WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0079, 0, 0, 0}, 0x00fd }, // U00FD # LATIN SMALL LETTER Y WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x007a, 0, 0, 0}, 0x017a }, // U017A # LATIN SMALL LETTER Z WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x007e, 0x004f, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x007e, 0x0055, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x007e, 0x006f, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x007e, 0x0075, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00af, 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00af, 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00af, 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00af, 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00c2, 0, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00c5, 0, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00c6, 0, 0, 0}, 0x01fc }, // U01FC # LATIN CAPITAL LETTER AE WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00c7, 0, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00ca, 0, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00cf, 0, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00d4, 0, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00d5, 0, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00d8, 0, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00dc, 0, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00e2, 0, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00e5, 0, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00e6, 0, 0, 0}, 0x01fd }, // U01FD # LATIN SMALL LETTER AE WITH ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00e7, 0, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00ea, 0, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00ef, 0, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00f4, 0, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00f5, 0, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00f8, 0, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x00fc, 0, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0102, 0, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0103, 0, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0112, 0, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0113, 0, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x014c, 0, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x014d, 0, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0168, 0, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0169, 0, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x0391, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x0395, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x0397, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x0399, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x039f, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03a9, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03b1, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03b5, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03b7, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03b9, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03bf, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03c5, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03c9, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x0391, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x0395, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x0397, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x0399, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x039f, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03a5, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03a9, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03b1, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03b5, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03b7, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03b9, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03bf, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03c5, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03c9, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0391, 0, 0, 0}, 0x0386 }, // U0386 # GREEK CAPITAL LETTER ALPHA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0395, 0, 0, 0}, 0x0388 }, // U0388 # GREEK CAPITAL LETTER EPSILON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0397, 0, 0, 0}, 0x0389 }, // U0389 # GREEK CAPITAL LETTER ETA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0399, 0, 0, 0}, 0x038a }, // U038A # GREEK CAPITAL LETTER IOTA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x039f, 0, 0, 0}, 0x038c }, // U038C # GREEK CAPITAL LETTER OMICRON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03a5, 0, 0, 0}, 0x038e }, // U038E # GREEK CAPITAL LETTER UPSILON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03a9, 0, 0, 0}, 0x038f }, // U038F # GREEK CAPITAL LETTER OMEGA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03b1, 0, 0, 0}, 0x03ac }, // U03AC # GREEK SMALL LETTER ALPHA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03b5, 0, 0, 0}, 0x03ad }, // U03AD # GREEK SMALL LETTER EPSILON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03b7, 0, 0, 0}, 0x03ae }, // U03AE # GREEK SMALL LETTER ETA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03b9, 0, 0, 0}, 0x03af }, // U03AF # GREEK SMALL LETTER IOTA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03bf, 0, 0, 0}, 0x03cc }, // U03CC # GREEK SMALL LETTER OMICRON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03c5, 0, 0, 0}, 0x03cd }, // U03CD # GREEK SMALL LETTER UPSILON WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03c9, 0, 0, 0}, 0x03ce }, // U03CE # GREEK SMALL LETTER OMEGA WITH TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03ca, 0, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03cb, 0, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03d2, 0, 0, 0}, 0x03d3 }, // U03D3 # GREEK UPSILON WITH ACUTE AND HOOK SYMBOL + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0413, 0, 0, 0}, 0x0403 }, // U0403 # CYRILLIC CAPITAL LETTER GJE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x041a, 0, 0, 0}, 0x040c }, // U040C # CYRILLIC CAPITAL LETTER KJE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0433, 0, 0, 0}, 0x0453 }, // U0453 # CYRILLIC SMALL LETTER GJE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x043a, 0, 0, 0}, 0x045c }, // U045C # CYRILLIC SMALL LETTER KJE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f00, 0, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f01, 0, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f08, 0, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f09, 0, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f10, 0, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f11, 0, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f18, 0, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f19, 0, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f20, 0, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f21, 0, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f28, 0, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f29, 0, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f30, 0, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f31, 0, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f38, 0, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f39, 0, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f40, 0, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f41, 0, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f48, 0, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f49, 0, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f50, 0, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f51, 0, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f59, 0, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f60, 0, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f61, 0, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f68, 0, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f69, 0, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Tilde), 0x0055, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Tilde), 0x0075, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Macron), 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Macron), 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Macron), 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Macron), 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0049, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0069, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Abovering), 0x0041, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Abovering), 0x0061, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Cedilla), 0x0043, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Cedilla), 0x0063, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Multi_key), 0x00b4, UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0028, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0029, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0313, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x0314, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x03b1, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x03b1, 0, 0}, 0x1fb2 }, // U1FB2 # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x03b7, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x03b7, 0, 0}, 0x1fc2 }, // U1FC2 # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x03c9, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x03c9, 0, 0}, 0x1ff2 }, // U1FF2 # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f00, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f00, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f01, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f01, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f08, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f08, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f09, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f09, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f20, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f20, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f21, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f21, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f28, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f28, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f29, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f29, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f60, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f60, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f61, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f61, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f68, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f68, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f69, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0000, 0x1f69, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0028, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0028, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0028, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0028, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0028, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0028, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0029, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0029, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0029, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0029, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0029, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0029, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0313, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0313, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0313, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0313, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0313, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0313, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0314, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0314, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0314, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0314, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0314, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x0314, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x03b1, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x03b7, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x03c9, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f00, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f01, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f08, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f09, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f20, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f21, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f28, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f29, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f60, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f61, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f68, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0027, 0x1f69, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0028, 0x0391, 0, 0}, 0x1f89 }, // U1F89 # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0028, 0x0397, 0, 0}, 0x1f99 }, // U1F99 # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0028, 0x03a9, 0, 0}, 0x1fa9 }, // U1FA9 # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0028, 0x03b1, 0, 0}, 0x1f81 }, // U1F81 # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0028, 0x03b7, 0, 0}, 0x1f91 }, // U1F91 # GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0028, 0x03c9, 0, 0}, 0x1fa1 }, // U1FA1 # GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0029, 0x0391, 0, 0}, 0x1f88 }, // U1F88 # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0029, 0x0397, 0, 0}, 0x1f98 }, // U1F98 # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0029, 0x03a9, 0, 0}, 0x1fa8 }, // U1FA8 # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0029, 0x03b1, 0, 0}, 0x1f80 }, // U1F80 # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0029, 0x03b7, 0, 0}, 0x1f90 }, // U1F90 # GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0029, 0x03c9, 0, 0}, 0x1fa0 }, // U1FA0 # GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0028, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0028, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0028, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0028, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0028, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0028, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0029, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0029, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0029, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0029, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0029, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0029, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0313, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0313, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0313, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0313, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0313, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0313, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0314, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0314, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0314, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0314, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0314, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x0314, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x03b1, 0, 0}, 0x1fb2 }, // U1FB2 # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x03b7, 0, 0}, 0x1fc2 }, // U1FC2 # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x03c9, 0, 0}, 0x1ff2 }, // U1FF2 # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f00, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f01, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f08, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f09, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f20, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f21, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f28, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f29, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f60, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f61, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f68, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0060, 0x1f69, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0028, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0028, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0028, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0028, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0028, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0028, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0029, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0029, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0029, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0029, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0029, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0029, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0313, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0313, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0313, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0313, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0313, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0313, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0314, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0314, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0314, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0314, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0314, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x0314, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x03b1, 0, 0}, 0x1fb7 }, // U1FB7 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x03b7, 0, 0}, 0x1fc7 }, // U1FC7 # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x03c9, 0, 0}, 0x1ff7 }, // U1FF7 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f00, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f01, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f08, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f09, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f20, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f21, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f28, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f29, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f60, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f61, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f68, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x007e, 0x1f69, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0028, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0028, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0028, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0028, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0028, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0028, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0029, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0029, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0029, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0029, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0029, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0029, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0313, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0313, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0313, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0313, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0313, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0313, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0314, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0314, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0314, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0314, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0314, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x0314, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x03b1, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x03b7, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x03c9, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f00, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f01, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f08, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f09, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f20, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f21, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f28, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f29, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f60, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f61, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f68, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x00b4, 0x1f69, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0313, 0x0391, 0, 0}, 0x1f88 }, // U1F88 # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0313, 0x0397, 0, 0}, 0x1f98 }, // U1F98 # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0313, 0x03a9, 0, 0}, 0x1fa8 }, // U1FA8 # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0313, 0x03b1, 0, 0}, 0x1f80 }, // U1F80 # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0313, 0x03b7, 0, 0}, 0x1f90 }, // U1F90 # GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0313, 0x03c9, 0, 0}, 0x1fa0 }, // U1FA0 # GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0314, 0x0391, 0, 0}, 0x1f89 }, // U1F89 # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0314, 0x0397, 0, 0}, 0x1f99 }, // U1F99 # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0314, 0x03a9, 0, 0}, 0x1fa9 }, // U1FA9 # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0314, 0x03b1, 0, 0}, 0x1f81 }, // U1F81 # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0314, 0x03b7, 0, 0}, 0x1f91 }, // U1F91 # GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0314, 0x03c9, 0, 0}, 0x1fa1 }, // U1FA1 # GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0028, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0028, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0028, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0028, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0028, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0028, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0029, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0029, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0029, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0029, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0029, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0029, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0313, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0313, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0313, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0313, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0313, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0313, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0314, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0314, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0314, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0314, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0314, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x0314, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x03b1, 0, 0}, 0x1fb7 }, // U1FB7 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x03b7, 0, 0}, 0x1fc7 }, // U1FC7 # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x03c9, 0, 0}, 0x1ff7 }, // U1FF7 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f00, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f01, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f08, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f09, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f20, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f21, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f28, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f29, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f60, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f61, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f68, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0342, 0x1f69, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0391, 0, 0, 0}, 0x1fbc }, // U1FBC # GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x0397, 0, 0, 0}, 0x1fcc }, // U1FCC # GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x03a9, 0, 0, 0}, 0x1ffc }, // U1FFC # GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x03ac, 0, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x03ae, 0, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x03b1, 0, 0, 0}, 0x1fb3 }, // U1FB3 # GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x03b7, 0, 0, 0}, 0x1fc3 }, // U1FC3 # GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x03c9, 0, 0, 0}, 0x1ff3 }, // U1FF3 # GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x03ce, 0, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f00, 0, 0, 0}, 0x1f80 }, // U1F80 # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f01, 0, 0, 0}, 0x1f81 }, // U1F81 # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f02, 0, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f03, 0, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f04, 0, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f05, 0, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f06, 0, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f07, 0, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f08, 0, 0, 0}, 0x1f88 }, // U1F88 # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f09, 0, 0, 0}, 0x1f89 }, // U1F89 # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f0a, 0, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f0b, 0, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f0c, 0, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f0d, 0, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f0e, 0, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f0f, 0, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f20, 0, 0, 0}, 0x1f90 }, // U1F90 # GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f21, 0, 0, 0}, 0x1f91 }, // U1F91 # GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f22, 0, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f23, 0, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f24, 0, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f25, 0, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f26, 0, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f27, 0, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f28, 0, 0, 0}, 0x1f98 }, // U1F98 # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f29, 0, 0, 0}, 0x1f99 }, // U1F99 # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f2a, 0, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f2b, 0, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f2c, 0, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f2d, 0, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f2e, 0, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f2f, 0, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f60, 0, 0, 0}, 0x1fa0 }, // U1FA0 # GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f61, 0, 0, 0}, 0x1fa1 }, // U1FA1 # GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f62, 0, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f63, 0, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f64, 0, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f65, 0, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f66, 0, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f67, 0, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f68, 0, 0, 0}, 0x1fa8 }, // U1FA8 # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f69, 0, 0, 0}, 0x1fa9 }, // U1FA9 # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f6a, 0, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f6b, 0, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f6c, 0, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f6d, 0, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f6e, 0, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f6f, 0, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f70, 0, 0, 0}, 0x1fb2 }, // U1FB2 # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f74, 0, 0, 0}, 0x1fc2 }, // U1FC2 # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1f7c, 0, 0, 0}, 0x1ff2 }, // U1FF2 # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1fb6, 0, 0, 0}, 0x1fb7 }, // U1FB7 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1fc6, 0, 0, 0}, 0x1fc7 }, // U1FC7 # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, 0x1ff6, 0, 0, 0}, 0x1ff7 }, // U1FF7 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0028, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0028, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0028, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0028, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0028, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0028, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0029, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0029, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0029, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0029, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0029, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0029, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x03b1, 0, 0}, 0x1fb2 }, // U1FB2 # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x03b7, 0, 0}, 0x1fc2 }, // U1FC2 # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x03c9, 0, 0}, 0x1ff2 }, // U1FF2 # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f00, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f01, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f08, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f09, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f20, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f21, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f28, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f29, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f60, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f61, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f68, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Grave), 0x1f69, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0028, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0028, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0028, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0028, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0028, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0028, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0029, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0029, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0029, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0029, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0029, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0029, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x03b1, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x03b7, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x03c9, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f00, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f01, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f08, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f09, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f20, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f21, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f28, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f29, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f60, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f61, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f68, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Acute), 0x1f69, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0028, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0028, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0028, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0028, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0028, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0028, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0029, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0029, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0029, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0029, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0029, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0029, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x03b1, 0, 0}, 0x1fb7 }, // U1FB7 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x03b7, 0, 0}, 0x1fc7 }, // U1FC7 # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x03c9, 0, 0}, 0x1ff7 }, // U1FF7 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f00, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f01, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f08, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f09, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f20, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f21, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f28, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f29, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f60, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f61, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f68, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x03b9, UNITIZE(TQt::Key_Dead_Tilde), 0x1f69, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Multi_key), 0x05b4, 0x05d9, 0, 0, 0}, 0xfb1d }, // UFB1D # HEBREW LETTER YOD WITH HIRIQ + { {UNITIZE(TQt::Key_Multi_key), 0x05b7, 0x05d0, 0, 0, 0}, 0xfb2e }, // UFB2E # HEBREW LETTER ALEF WITH PATAH + { {UNITIZE(TQt::Key_Multi_key), 0x05b7, 0x05f2, 0, 0, 0}, 0xfb1f }, // UFB1F # HEBREW LIGATURE YIDDISH YOD YOD PATAH + { {UNITIZE(TQt::Key_Multi_key), 0x05b8, 0x05d0, 0, 0, 0}, 0xfb2f }, // UFB2F # HEBREW LETTER ALEF WITH TQAMATS + { {UNITIZE(TQt::Key_Multi_key), 0x05b9, 0x05d5, 0, 0, 0}, 0xfb4b }, // UFB4B # HEBREW LETTER VAV WITH HOLAM + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d0, 0, 0, 0}, 0xfb30 }, // UFB30 # HEBREW LETTER ALEF WITH MAPIQ + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d1, 0, 0, 0}, 0xfb31 }, // UFB31 # HEBREW LETTER BET WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d1, 0, 0, 0}, 0xfb31 }, // UFB31 # HEBREW LETTER BET WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d2, 0, 0, 0}, 0xfb32 }, // UFB32 # HEBREW LETTER GIMEL WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d2, 0, 0, 0}, 0xfb32 }, // UFB32 # HEBREW LETTER GIMEL WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d3, 0, 0, 0}, 0xfb33 }, // UFB33 # HEBREW LETTER DALET WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d3, 0, 0, 0}, 0xfb33 }, // UFB33 # HEBREW LETTER DALET WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d4, 0, 0, 0}, 0xfb34 }, // UFB34 # HEBREW LETTER HE WITH MAPIQ + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d5, 0, 0, 0}, 0xfb35 }, // UFB35 # HEBREW LETTER VAV WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d6, 0, 0, 0}, 0xfb36 }, // UFB36 # HEBREW LETTER ZAYIN WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d6, 0, 0, 0}, 0xfb36 }, // UFB36 # HEBREW LETTER ZAYIN WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d8, 0, 0, 0}, 0xfb38 }, // UFB38 # HEBREW LETTER TET WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d8, 0, 0, 0}, 0xfb38 }, // UFB38 # HEBREW LETTER TET WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05d9, 0, 0, 0}, 0xfb39 }, // UFB39 # HEBREW LETTER YOD WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05da, 0, 0, 0}, 0xfb3a }, // UFB3A # HEBREW LETTER FINAL KAF WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05db, 0, 0, 0}, 0xfb3b }, // UFB3B # HEBREW LETTER KAF WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05dc, 0, 0, 0}, 0xfb3c }, // UFB3C # HEBREW LETTER LAMED WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05de, 0, 0, 0}, 0xfb3e }, // UFB3E # HEBREW LETTER MEM WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e0, 0, 0, 0}, 0xfb40 }, // UFB40 # HEBREW LETTER NUN WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e1, 0, 0, 0}, 0xfb41 }, // UFB41 # HEBREW LETTER SAMEKH WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e1, 0, 0, 0}, 0xfb41 }, // UFB41 # HEBREW LETTER SAMEKH WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e3, 0, 0, 0}, 0xfb43 }, // UFB43 # HEBREW LETTER FINAL PE WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e4, 0, 0, 0}, 0xfb44 }, // UFB44 # HEBREW LETTER PE WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e6, 0, 0, 0}, 0xfb46 }, // UFB46 # HEBREW LETTER TSADI WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e6, 0, 0, 0}, 0xfb46 }, // UFB46 # HEBREW LETTER TSADI WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e7, 0, 0, 0}, 0xfb47 }, // UFB47 # HEBREW LETTER TQOF WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e7, 0, 0, 0}, 0xfb47 }, // UFB47 # HEBREW LETTER TQOF WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e8, 0, 0, 0}, 0xfb48 }, // UFB48 # HEBREW LETTER RESH WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05e9, 0, 0, 0}, 0xfb49 }, // UFB49 # HEBREW LETTER SHIN WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05ea, 0, 0, 0}, 0xfb4a }, // UFB4A # HEBREW LETTER TAV WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bc, 0x05ea, 0, 0, 0}, 0xfb4a }, // UFB4A # HEBREW LETTER TAV WITH DAGESH + { {UNITIZE(TQt::Key_Multi_key), 0x05bf, 0x05d1, 0, 0, 0}, 0xfb4c }, // UFB4C # HEBREW LETTER BET WITH RAFE + { {UNITIZE(TQt::Key_Multi_key), 0x05bf, 0x05d1, 0, 0, 0}, 0xfb4c }, // UFB4C # HEBREW LETTER BET WITH RAFE + { {UNITIZE(TQt::Key_Multi_key), 0x05bf, 0x05db, 0, 0, 0}, 0xfb4d }, // UFB4D # HEBREW LETTER KAF WITH RAFE + { {UNITIZE(TQt::Key_Multi_key), 0x05bf, 0x05e4, 0, 0, 0}, 0xfb4e }, // UFB4E # HEBREW LETTER PE WITH RAFE + { {UNITIZE(TQt::Key_Multi_key), 0x05c1, 0x05bc, 0x05e9, 0, 0}, 0xfb2c }, // UFB2C # HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT + { {UNITIZE(TQt::Key_Multi_key), 0x05c1, 0x05e9, 0, 0, 0}, 0xfb2a }, // UFB2A # HEBREW LETTER SHIN WITH SHIN DOT + { {UNITIZE(TQt::Key_Multi_key), 0x05c1, 0xfb49, 0, 0, 0}, 0xfb2c }, // UFB2C # HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT + { {UNITIZE(TQt::Key_Multi_key), 0x05c2, 0x05bc, 0x05e9, 0, 0}, 0xfb2d }, // UFB2D # HEBREW LETTER SHIN WITH DAGESH AND SIN DOT + { {UNITIZE(TQt::Key_Multi_key), 0x05c2, 0x05e9, 0, 0, 0}, 0xfb2b }, // UFB2B # HEBREW LETTER SHIN WITH SIN DOT + { {UNITIZE(TQt::Key_Multi_key), 0x05c2, 0xfb49, 0, 0, 0}, 0xfb2d }, // UFB2D # HEBREW LETTER SHIN WITH DAGESH AND SIN DOT + { {UNITIZE(TQt::Key_Multi_key), 0x0653, 0x0627, 0, 0, 0}, 0x0622 }, // U0622 # ARABIC LETTER ALEF WITH MADDA ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x0654, 0x0627, 0, 0, 0}, 0x0623 }, // U0623 # ARABIC LETTER ALEF WITH HAMZA ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x0654, 0x0648, 0, 0, 0}, 0x0624 }, // U0624 # ARABIC LETTER WAW WITH HAMZA ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x0654, 0x064a, 0, 0, 0}, 0x0626 }, // U0626 # ARABIC LETTER YEH WITH HAMZA ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x0654, 0x06c1, 0, 0, 0}, 0x06c2 }, // U06C2 # ARABIC LETTER HEH GOAL WITH HAMZA ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x0654, 0x06d2, 0, 0, 0}, 0x06d3 }, // U06D3 # ARABIC LETTER YEH BARREE WITH HAMZA ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x0654, 0x06d5, 0, 0, 0}, 0x06c0 }, // U06C0 # ARABIC LETTER HEH WITH YEH ABOVE + { {UNITIZE(TQt::Key_Multi_key), 0x0655, 0x0627, 0, 0, 0}, 0x0625 }, // U0625 # ARABIC LETTER ALEF WITH HAMZA BELOW + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x0915, 0, 0, 0}, 0x0958 }, // U0958 # DEVANAGARI LETTER QA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x0916, 0, 0, 0}, 0x0959 }, // U0959 # DEVANAGARI LETTER KHHA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x0917, 0, 0, 0}, 0x095a }, // U095A # DEVANAGARI LETTER GHHA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x091c, 0, 0, 0}, 0x095b }, // U095B # DEVANAGARI LETTER ZA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x0921, 0, 0, 0}, 0x095c }, // U095C # DEVANAGARI LETTER DDDHA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x0922, 0, 0, 0}, 0x095d }, // U095D # DEVANAGARI LETTER RHA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x0928, 0, 0, 0}, 0x0929 }, // U0929 # DEVANAGARI LETTER NNNA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x092b, 0, 0, 0}, 0x095e }, // U095E # DEVANAGARI LETTER FA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x092f, 0, 0, 0}, 0x095f }, // U095F # DEVANAGARI LETTER YYA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x0930, 0, 0, 0}, 0x0931 }, // U0931 # DEVANAGARI LETTER RRA + { {UNITIZE(TQt::Key_Multi_key), 0x093c, 0x0933, 0, 0, 0}, 0x0934 }, // U0934 # DEVANAGARI LETTER LLLA + { {UNITIZE(TQt::Key_Multi_key), 0x09bc, 0x09a1, 0, 0, 0}, 0x09dc }, // U09DC # BENGALI LETTER RRA + { {UNITIZE(TQt::Key_Multi_key), 0x09bc, 0x09a2, 0, 0, 0}, 0x09dd }, // U09DD # BENGALI LETTER RHA + { {UNITIZE(TQt::Key_Multi_key), 0x09bc, 0x09af, 0, 0, 0}, 0x09df }, // U09DF # BENGALI LETTER YYA + { {UNITIZE(TQt::Key_Multi_key), 0x09c7, 0x09be, 0, 0, 0}, 0x09cb }, // U09CB # BENGALI VOWEL SIGN O + { {UNITIZE(TQt::Key_Multi_key), 0x09c7, 0x09d7, 0, 0, 0}, 0x09cc }, // U09CC # BENGALI VOWEL SIGN AU + { {UNITIZE(TQt::Key_Multi_key), 0x0a3c, 0x0a16, 0, 0, 0}, 0x0a59 }, // U0A59 # GURMUKHI LETTER KHHA + { {UNITIZE(TQt::Key_Multi_key), 0x0a3c, 0x0a17, 0, 0, 0}, 0x0a5a }, // U0A5A # GURMUKHI LETTER GHHA + { {UNITIZE(TQt::Key_Multi_key), 0x0a3c, 0x0a1c, 0, 0, 0}, 0x0a5b }, // U0A5B # GURMUKHI LETTER ZA + { {UNITIZE(TQt::Key_Multi_key), 0x0a3c, 0x0a2b, 0, 0, 0}, 0x0a5e }, // U0A5E # GURMUKHI LETTER FA + { {UNITIZE(TQt::Key_Multi_key), 0x0a3c, 0x0a32, 0, 0, 0}, 0x0a33 }, // U0A33 # GURMUKHI LETTER LLA + { {UNITIZE(TQt::Key_Multi_key), 0x0a3c, 0x0a38, 0, 0, 0}, 0x0a36 }, // U0A36 # GURMUKHI LETTER SHA + { {UNITIZE(TQt::Key_Multi_key), 0x0b3c, 0x0b21, 0, 0, 0}, 0x0b5c }, // U0B5C # ORIYA LETTER RRA + { {UNITIZE(TQt::Key_Multi_key), 0x0b3c, 0x0b22, 0, 0, 0}, 0x0b5d }, // U0B5D # ORIYA LETTER RHA + { {UNITIZE(TQt::Key_Multi_key), 0x0b47, 0x0b3e, 0, 0, 0}, 0x0b4b }, // U0B4B # ORIYA VOWEL SIGN O + { {UNITIZE(TQt::Key_Multi_key), 0x0b47, 0x0b56, 0, 0, 0}, 0x0b48 }, // U0B48 # ORIYA VOWEL SIGN AI + { {UNITIZE(TQt::Key_Multi_key), 0x0b47, 0x0b57, 0, 0, 0}, 0x0b4c }, // U0B4C # ORIYA VOWEL SIGN AU + { {UNITIZE(TQt::Key_Multi_key), 0x0bc6, 0x0bbe, 0, 0, 0}, 0x0bca }, // U0BCA # TAMIL VOWEL SIGN O + { {UNITIZE(TQt::Key_Multi_key), 0x0bc6, 0x0bd7, 0, 0, 0}, 0x0bcc }, // U0BCC # TAMIL VOWEL SIGN AU + { {UNITIZE(TQt::Key_Multi_key), 0x0bc7, 0x0bbe, 0, 0, 0}, 0x0bcb }, // U0BCB # TAMIL VOWEL SIGN OO + { {UNITIZE(TQt::Key_Multi_key), 0x0bd7, 0x0b92, 0, 0, 0}, 0x0b94 }, // U0B94 # TAMIL LETTER AU + { {UNITIZE(TQt::Key_Multi_key), 0x0c46, 0x0c56, 0, 0, 0}, 0x0c48 }, // U0C48 # TELUGU VOWEL SIGN AI + { {UNITIZE(TQt::Key_Multi_key), 0x0cbf, 0x0cd5, 0, 0, 0}, 0x0cc0 }, // U0CC0 # KANNADA VOWEL SIGN II + { {UNITIZE(TQt::Key_Multi_key), 0x0cc6, 0x0cc2, 0, 0, 0}, 0x0cca }, // U0CCA # KANNADA VOWEL SIGN O + { {UNITIZE(TQt::Key_Multi_key), 0x0cc6, 0x0cc2, 0x0cd5, 0, 0}, 0x0ccb }, // U0CCB # KANNADA VOWEL SIGN OO + { {UNITIZE(TQt::Key_Multi_key), 0x0cc6, 0x0cd5, 0, 0, 0}, 0x0cc7 }, // U0CC7 # KANNADA VOWEL SIGN EE + { {UNITIZE(TQt::Key_Multi_key), 0x0cc6, 0x0cd6, 0, 0, 0}, 0x0cc8 }, // U0CC8 # KANNADA VOWEL SIGN AI + { {UNITIZE(TQt::Key_Multi_key), 0x0cca, 0x0cd5, 0, 0, 0}, 0x0ccb }, // U0CCB # KANNADA VOWEL SIGN OO + { {UNITIZE(TQt::Key_Multi_key), 0x0d46, 0x0d3e, 0, 0, 0}, 0x0d4a }, // U0D4A # MALAYALAM VOWEL SIGN O + { {UNITIZE(TQt::Key_Multi_key), 0x0d46, 0x0d57, 0, 0, 0}, 0x0d4c }, // U0D4C # MALAYALAM VOWEL SIGN AU + { {UNITIZE(TQt::Key_Multi_key), 0x0d47, 0x0d3e, 0, 0, 0}, 0x0d4b }, // U0D4B # MALAYALAM VOWEL SIGN OO + { {UNITIZE(TQt::Key_Multi_key), 0x0dd9, 0x0dca, 0, 0, 0}, 0x0dda }, // U0DDA # SINHALA VOWEL SIGN DIGA KOMBUVA + { {UNITIZE(TQt::Key_Multi_key), 0x0dd9, 0x0dcf, 0, 0, 0}, 0x0ddc }, // U0DDC # SINHALA VOWEL SIGN KOMBUVA HAA AELA-PILLA + { {UNITIZE(TQt::Key_Multi_key), 0x0dd9, 0x0dcf, 0x0dca, 0, 0}, 0x0ddd }, // U0DDD # SINHALA VOWEL SIGN KOMBUVA HAA DIGA AELA-PILLA + { {UNITIZE(TQt::Key_Multi_key), 0x0dd9, 0x0ddf, 0, 0, 0}, 0x0dde }, // U0DDE # SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA + { {UNITIZE(TQt::Key_Multi_key), 0x0ddc, 0x0dca, 0, 0, 0}, 0x0ddd }, // U0DDD # SINHALA VOWEL SIGN KOMBUVA HAA DIGA AELA-PILLA + { {UNITIZE(TQt::Key_Multi_key), 0x0f71, 0x0f72, 0, 0, 0}, 0x0f73 }, // U0F73 # TIBETAN VOWEL SIGN II + { {UNITIZE(TQt::Key_Multi_key), 0x0f71, 0x0f74, 0, 0, 0}, 0x0f75 }, // U0F75 # TIBETAN VOWEL SIGN UU + { {UNITIZE(TQt::Key_Multi_key), 0x0f71, 0x0f80, 0, 0, 0}, 0x0f81 }, // U0F81 # TIBETAN VOWEL SIGN REVERSED II + { {UNITIZE(TQt::Key_Multi_key), 0x0f90, 0x0fb5, 0, 0, 0}, 0x0fb9 }, // U0FB9 # TIBETAN SUBJOINED LETTER KSSA + { {UNITIZE(TQt::Key_Multi_key), 0x0f92, 0x0fb7, 0, 0, 0}, 0x0f93 }, // U0F93 # TIBETAN SUBJOINED LETTER GHA + { {UNITIZE(TQt::Key_Multi_key), 0x0f9c, 0x0fb7, 0, 0, 0}, 0x0f9d }, // U0F9D # TIBETAN SUBJOINED LETTER DDHA + { {UNITIZE(TQt::Key_Multi_key), 0x0fa1, 0x0fb7, 0, 0, 0}, 0x0fa2 }, // U0FA2 # TIBETAN SUBJOINED LETTER DHA + { {UNITIZE(TQt::Key_Multi_key), 0x0fa6, 0x0fb7, 0, 0, 0}, 0x0fa7 }, // U0FA7 # TIBETAN SUBJOINED LETTER BHA + { {UNITIZE(TQt::Key_Multi_key), 0x0fab, 0x0fb7, 0, 0, 0}, 0x0fac }, // U0FAC # TIBETAN SUBJOINED LETTER DZHA + { {UNITIZE(TQt::Key_Multi_key), 0x0fb2, 0x0f80, 0, 0, 0}, 0x0f76 }, // U0F76 # TIBETAN VOWEL SIGN VOCALIC R + { {UNITIZE(TQt::Key_Multi_key), 0x0fb3, 0x0f80, 0, 0, 0}, 0x0f78 }, // U0F78 # TIBETAN VOWEL SIGN VOCALIC L + { {UNITIZE(TQt::Key_Multi_key), 0x0fb5, 0x0f40, 0, 0, 0}, 0x0f69 }, // U0F69 # TIBETAN LETTER KSSA + { {UNITIZE(TQt::Key_Multi_key), 0x0fb7, 0x0f42, 0, 0, 0}, 0x0f43 }, // U0F43 # TIBETAN LETTER GHA + { {UNITIZE(TQt::Key_Multi_key), 0x0fb7, 0x0f4c, 0, 0, 0}, 0x0f4d }, // U0F4D # TIBETAN LETTER DDHA + { {UNITIZE(TQt::Key_Multi_key), 0x0fb7, 0x0f51, 0, 0, 0}, 0x0f52 }, // U0F52 # TIBETAN LETTER DHA + { {UNITIZE(TQt::Key_Multi_key), 0x0fb7, 0x0f56, 0, 0, 0}, 0x0f57 }, // U0F57 # TIBETAN LETTER BHA + { {UNITIZE(TQt::Key_Multi_key), 0x0fb7, 0x0f5b, 0, 0, 0}, 0x0f5c }, // U0F5C # TIBETAN LETTER DZHA + { {UNITIZE(TQt::Key_Multi_key), 0x102e, 0x1025, 0, 0, 0}, 0x1026 }, // U1026 # MYANMAR LETTER UU + { {UNITIZE(TQt::Key_Multi_key), 0x1100, 0x1100, 0, 0, 0}, 0x1101 }, // U1101 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1102, 0x1100, 0, 0, 0}, 0x1113 }, // U1113 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1102, 0x1102, 0, 0, 0}, 0x1114 }, // U1114 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1102, 0x1103, 0, 0, 0}, 0x1115 }, // U1115 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1102, 0x1107, 0, 0, 0}, 0x1116 }, // U1116 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1103, 0x1100, 0, 0, 0}, 0x1117 }, // U1117 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1103, 0x1103, 0, 0, 0}, 0x1104 }, // U1104 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1105, 0x1102, 0, 0, 0}, 0x1118 }, // U1118 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1105, 0x1105, 0, 0, 0}, 0x1119 }, // U1119 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1105, 0x110b, 0, 0, 0}, 0x111b }, // U111b # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1105, 0x1112, 0, 0, 0}, 0x111a }, // U111a # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1106, 0x1107, 0, 0, 0}, 0x111c }, // U111c # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1106, 0x110b, 0, 0, 0}, 0x111d }, // U111d # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1100, 0, 0, 0}, 0x111e }, // U111e # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1102, 0, 0, 0}, 0x111f }, // U111f # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1103, 0, 0, 0}, 0x1120 }, // U1120 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1107, 0, 0, 0}, 0x1108 }, // U1108 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1107, 0x110b, 0, 0}, 0x112c }, // U112c # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1109, 0, 0, 0}, 0x1121 }, // U1121 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1109, 0x1100, 0, 0}, 0x1122 }, // U1122 # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1109, 0x1103, 0, 0}, 0x1123 }, // U1123 # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1109, 0x1107, 0, 0}, 0x1124 }, // U1124 # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1109, 0x1109, 0, 0}, 0x1125 }, // U1125 # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1109, 0x110c, 0, 0}, 0x1126 }, // U1126 # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x110a, 0, 0, 0}, 0x1125 }, // U1125 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x110b, 0, 0, 0}, 0x112b }, // U112b # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x110c, 0, 0, 0}, 0x1127 }, // U1127 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x110e, 0, 0, 0}, 0x1128 }, // U1128 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1110, 0, 0, 0}, 0x1129 }, // U1129 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1111, 0, 0, 0}, 0x112a }, // U112a # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x112b, 0, 0, 0}, 0x112c }, // U112c # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x112d, 0, 0, 0}, 0x1122 }, // U1122 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x112f, 0, 0, 0}, 0x1123 }, // U1123 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1132, 0, 0, 0}, 0x1124 }, // U1124 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1107, 0x1136, 0, 0, 0}, 0x1126 }, // U1126 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1108, 0x110b, 0, 0, 0}, 0x112c }, // U112c # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1100, 0, 0, 0}, 0x112d }, // U112d # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1102, 0, 0, 0}, 0x112e }, // U112e # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1103, 0, 0, 0}, 0x112f }, // U112f # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1105, 0, 0, 0}, 0x1130 }, // U1130 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1106, 0, 0, 0}, 0x1131 }, // U1131 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1107, 0, 0, 0}, 0x1132 }, // U1132 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1107, 0x1100, 0, 0}, 0x1133 }, // U1133 # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1109, 0, 0, 0}, 0x110a }, // U110a # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1109, 0x1109, 0, 0}, 0x1134 }, // U1134 # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x110a, 0, 0, 0}, 0x1134 }, // U1134 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x110b, 0, 0, 0}, 0x1135 }, // U1135 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x110c, 0, 0, 0}, 0x1136 }, // U1136 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x110e, 0, 0, 0}, 0x1137 }, // U1137 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x110f, 0, 0, 0}, 0x1138 }, // U1138 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1110, 0, 0, 0}, 0x1139 }, // U1139 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1111, 0, 0, 0}, 0x113a }, // U113a # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x1112, 0, 0, 0}, 0x113b }, // U113b # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1109, 0x111e, 0, 0, 0}, 0x1133 }, // U1133 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110a, 0x1109, 0, 0, 0}, 0x1134 }, // U1134 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x1100, 0, 0, 0}, 0x1141 }, // U1141 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x1103, 0, 0, 0}, 0x1142 }, // U1142 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x1106, 0, 0, 0}, 0x1143 }, // U1143 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x1107, 0, 0, 0}, 0x1144 }, // U1144 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x1109, 0, 0, 0}, 0x1145 }, // U1145 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x110b, 0, 0, 0}, 0x1147 }, // U1147 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x110c, 0, 0, 0}, 0x1148 }, // U1148 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x110e, 0, 0, 0}, 0x1149 }, // U1149 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x1110, 0, 0, 0}, 0x114a }, // U114a # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x1111, 0, 0, 0}, 0x114b }, // U114b # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110b, 0x1140, 0, 0, 0}, 0x1146 }, // U1146 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110c, 0x110b, 0, 0, 0}, 0x114d }, // U114d # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110c, 0x110c, 0, 0, 0}, 0x110d }, // U110d # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110e, 0x110f, 0, 0, 0}, 0x1152 }, // U1152 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x110e, 0x1112, 0, 0, 0}, 0x1153 }, // U1153 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1111, 0x1107, 0, 0, 0}, 0x1156 }, // U1156 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1111, 0x110b, 0, 0, 0}, 0x1157 }, // U1157 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1112, 0x1112, 0, 0, 0}, 0x1158 }, // U1158 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1121, 0x1100, 0, 0, 0}, 0x1122 }, // U1122 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1121, 0x1103, 0, 0, 0}, 0x1123 }, // U1123 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1121, 0x1107, 0, 0, 0}, 0x1124 }, // U1124 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1121, 0x1109, 0, 0, 0}, 0x1125 }, // U1125 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1121, 0x110c, 0, 0, 0}, 0x1126 }, // U1126 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1132, 0x1100, 0, 0, 0}, 0x1133 }, // U1133 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x113c, 0x113c, 0, 0, 0}, 0x113d }, // U113d # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x113e, 0x113e, 0, 0, 0}, 0x113f }, // U113f # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x114e, 0x114e, 0, 0, 0}, 0x114f }, // U114f # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1150, 0x1150, 0, 0, 0}, 0x1151 }, // U1151 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1161, 0x1169, 0, 0, 0}, 0x1176 }, // U1176 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1161, 0x116e, 0, 0, 0}, 0x1177 }, // U1177 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1161, 0x1175, 0, 0, 0}, 0x1162 }, // U1162 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1163, 0x1169, 0, 0, 0}, 0x1178 }, // U1178 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1163, 0x116d, 0, 0, 0}, 0x1179 }, // U1179 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1163, 0x1175, 0, 0, 0}, 0x1164 }, // U1164 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1165, 0x1169, 0, 0, 0}, 0x117a }, // U117a # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1165, 0x116e, 0, 0, 0}, 0x117b }, // U117b # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1165, 0x1173, 0, 0, 0}, 0x117c }, // U117c # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1165, 0x1175, 0, 0, 0}, 0x1166 }, // U1166 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1167, 0x1169, 0, 0, 0}, 0x117d }, // U117d # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1167, 0x116e, 0, 0, 0}, 0x117e }, // U117e # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1167, 0x1175, 0, 0, 0}, 0x1168 }, // U1168 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1169, 0x1161, 0, 0, 0}, 0x116a }, // U116a # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1169, 0x1161, 0x1175, 0, 0}, 0x116b }, // U116b # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1169, 0x1162, 0, 0, 0}, 0x116b }, // U116b # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1169, 0x1165, 0, 0, 0}, 0x117f }, // U117f # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1169, 0x1166, 0, 0, 0}, 0x1180 }, // U1180 # �� �� = ߠ + { {UNITIZE(TQt::Key_Multi_key), 0x1169, 0x1168, 0, 0, 0}, 0x1181 }, // U1181 # �� �� = ߡ + { {UNITIZE(TQt::Key_Multi_key), 0x1169, 0x1169, 0, 0, 0}, 0x1182 }, // U1182 # �� �� = ߢ + { {UNITIZE(TQt::Key_Multi_key), 0x1169, 0x116e, 0, 0, 0}, 0x1183 }, // U1183 # �� �� = ߣ + { {UNITIZE(TQt::Key_Multi_key), 0x1169, 0x1175, 0, 0, 0}, 0x116c }, // U116c # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x116a, 0x1175, 0, 0, 0}, 0x116b }, // U116b # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x116d, 0x1163, 0, 0, 0}, 0x1184 }, // U1184 # �� �� = ߤ + { {UNITIZE(TQt::Key_Multi_key), 0x116d, 0x1164, 0, 0, 0}, 0x1185 }, // U1185 # �� �� = ߥ + { {UNITIZE(TQt::Key_Multi_key), 0x116d, 0x1167, 0, 0, 0}, 0x1186 }, // U1186 # �� �� = ߦ + { {UNITIZE(TQt::Key_Multi_key), 0x116d, 0x1169, 0, 0, 0}, 0x1187 }, // U1187 # �� �� = ߧ + { {UNITIZE(TQt::Key_Multi_key), 0x116d, 0x1175, 0, 0, 0}, 0x1188 }, // U1188 # �� �� = ߨ + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x1161, 0, 0, 0}, 0x1189 }, // U1189 # �� �� = ߩ + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x1162, 0, 0, 0}, 0x118a }, // U118a # �� �� = ߪ + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x1165, 0, 0, 0}, 0x116f }, // U116f # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x1165, 0x1173, 0, 0}, 0x118b }, // U118b # �� �� �� = ߫ + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x1165, 0x1175, 0, 0}, 0x1170 }, // U1170 # �� �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x1166, 0, 0, 0}, 0x1170 }, // U1170 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x1168, 0, 0, 0}, 0x118c }, // U118c # �� �� = ߬ + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x116e, 0, 0, 0}, 0x118d }, // U118d # �� �� = ߭ + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x1175, 0, 0, 0}, 0x1171 }, // U1171 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x116e, 0x117c, 0, 0, 0}, 0x118b }, // U118b # �� �� = ߫ + { {UNITIZE(TQt::Key_Multi_key), 0x116f, 0x1173, 0, 0, 0}, 0x118b }, // U118b # �� �� = ߫ + { {UNITIZE(TQt::Key_Multi_key), 0x116f, 0x1175, 0, 0, 0}, 0x1170 }, // U1170 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1172, 0x1161, 0, 0, 0}, 0x118e }, // U118e # �� �� = ߮ + { {UNITIZE(TQt::Key_Multi_key), 0x1172, 0x1165, 0, 0, 0}, 0x118f }, // U118f # �� �� = ߯ + { {UNITIZE(TQt::Key_Multi_key), 0x1172, 0x1166, 0, 0, 0}, 0x1190 }, // U1190 # �� �� = ߰ + { {UNITIZE(TQt::Key_Multi_key), 0x1172, 0x1167, 0, 0, 0}, 0x1191 }, // U1191 # �� �� = ߱ + { {UNITIZE(TQt::Key_Multi_key), 0x1172, 0x1168, 0, 0, 0}, 0x1192 }, // U1192 # �� �� = ߲ + { {UNITIZE(TQt::Key_Multi_key), 0x1172, 0x116e, 0, 0, 0}, 0x1193 }, // U1193 # �� �� = ߳ + { {UNITIZE(TQt::Key_Multi_key), 0x1172, 0x1175, 0, 0, 0}, 0x1194 }, // U1194 # �� �� = ߴ + { {UNITIZE(TQt::Key_Multi_key), 0x1173, 0x116e, 0, 0, 0}, 0x1195 }, // U1195 # �� �� = ߵ + { {UNITIZE(TQt::Key_Multi_key), 0x1173, 0x1173, 0, 0, 0}, 0x1196 }, // U1196 # �� �� = ߶ + { {UNITIZE(TQt::Key_Multi_key), 0x1173, 0x1175, 0, 0, 0}, 0x1174 }, // U1174 # �� �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x1174, 0x116e, 0, 0, 0}, 0x1197 }, // U1197 # �� �� = ߷ + { {UNITIZE(TQt::Key_Multi_key), 0x1175, 0x1161, 0, 0, 0}, 0x1198 }, // U1198 # �� �� = ߸ + { {UNITIZE(TQt::Key_Multi_key), 0x1175, 0x1163, 0, 0, 0}, 0x1199 }, // U1199 # �� �� = ߹ + { {UNITIZE(TQt::Key_Multi_key), 0x1175, 0x1169, 0, 0, 0}, 0x119a }, // U119a # �� �� = ߺ + { {UNITIZE(TQt::Key_Multi_key), 0x1175, 0x116e, 0, 0, 0}, 0x119b }, // U119b # �� �� = ߻ + { {UNITIZE(TQt::Key_Multi_key), 0x1175, 0x1173, 0, 0, 0}, 0x119c }, // U119c # �� �� = ߼ + { {UNITIZE(TQt::Key_Multi_key), 0x1175, 0x119e, 0, 0, 0}, 0x119d }, // U119d # �� ߾ = ߽ + { {UNITIZE(TQt::Key_Multi_key), 0x119e, 0x1165, 0, 0, 0}, 0x119f }, // U119f # ߾ �� = ߿ + { {UNITIZE(TQt::Key_Multi_key), 0x119e, 0x116e, 0, 0, 0}, 0x11a0 }, // U11a0 # ߾ �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x119e, 0x1175, 0, 0, 0}, 0x11a1 }, // U11a1 # ߾ �� = �� + { {UNITIZE(TQt::Key_Multi_key), 0x119e, 0x119e, 0, 0, 0}, 0x11a2 }, // U11a2 # ߾ ߾ = �� + { {UNITIZE(TQt::Key_Multi_key), 0x11a8, 0x11a8, 0, 0, 0}, 0x11a9 }, // U11a9 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11a8, 0x11af, 0, 0, 0}, 0x11c3 }, // U11c3 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11a8, 0x11ba, 0, 0, 0}, 0x11aa }, // U11aa # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11a8, 0x11ba, 0x11a8, 0, 0}, 0x11c4 }, // U11c4 # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11a8, 0x11e7, 0, 0, 0}, 0x11c4 }, // U11c4 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11aa, 0x11a8, 0, 0, 0}, 0x11c4 }, // U11c4 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ab, 0x11a8, 0, 0, 0}, 0x11c5 }, // U11c5 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ab, 0x11ae, 0, 0, 0}, 0x11c6 }, // U11c6 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ab, 0x11ba, 0, 0, 0}, 0x11c7 }, // U11c7 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ab, 0x11bd, 0, 0, 0}, 0x11ac }, // U11ac # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ab, 0x11c0, 0, 0, 0}, 0x11c9 }, // U11c9 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ab, 0x11c2, 0, 0, 0}, 0x11ad }, // U11ad # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ab, 0x11eb, 0, 0, 0}, 0x11c8 }, // U11c8 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ae, 0x11a8, 0, 0, 0}, 0x11ca }, // U11ca # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ae, 0x11af, 0, 0, 0}, 0x11cb }, // U11cb # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11a8, 0, 0, 0}, 0x11b0 }, // U11b0 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11a8, 0x11ba, 0, 0}, 0x11cc }, // U11cc # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11aa, 0, 0, 0}, 0x11cc }, // U11cc # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11ab, 0, 0, 0}, 0x11cd }, // U11cd # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11ae, 0, 0, 0}, 0x11ce }, // U11ce # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11ae, 0x11c2, 0, 0}, 0x11cf }, // U11cf # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11af, 0, 0, 0}, 0x11d0 }, // U11d0 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11b7, 0, 0, 0}, 0x11b1 }, // U11b1 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11b7, 0x11a8, 0, 0}, 0x11d1 }, // U11d1 # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11b7, 0x11ba, 0, 0}, 0x11d2 }, // U11d2 # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11b8, 0, 0, 0}, 0x11b2 }, // U11b2 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11b8, 0x11ba, 0, 0}, 0x11d3 }, // U11d3 # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11b8, 0x11bc, 0, 0}, 0x11d5 }, // U11d5 # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11b8, 0x11c2, 0, 0}, 0x11d4 }, // U11d4 # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11b9, 0, 0, 0}, 0x11d3 }, // U11d3 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11ba, 0, 0, 0}, 0x11b3 }, // U11b3 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11ba, 0x11ba, 0, 0}, 0x11d6 }, // U11d6 # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11bb, 0, 0, 0}, 0x11d6 }, // U11d6 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11bf, 0, 0, 0}, 0x11d8 }, // U11d8 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11c0, 0, 0, 0}, 0x11b4 }, // U11b4 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11c1, 0, 0, 0}, 0x11b5 }, // U11b5 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11c2, 0, 0, 0}, 0x11b6 }, // U11b6 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11da, 0, 0, 0}, 0x11d1 }, // U11d1 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11dd, 0, 0, 0}, 0x11d2 }, // U11d2 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11e5, 0, 0, 0}, 0x11d4 }, // U11d4 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11e6, 0, 0, 0}, 0x11d5 }, // U11d5 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11eb, 0, 0, 0}, 0x11d7 }, // U11d7 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11af, 0x11f9, 0, 0, 0}, 0x11d9 }, // U11d9 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b0, 0x11ba, 0, 0, 0}, 0x11cc }, // U11cc # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b1, 0x11a8, 0, 0, 0}, 0x11d1 }, // U11d1 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b1, 0x11ba, 0, 0, 0}, 0x11d2 }, // U11d2 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b2, 0x11ba, 0, 0, 0}, 0x11d3 }, // U11d3 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b2, 0x11bc, 0, 0, 0}, 0x11d5 }, // U11d5 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b2, 0x11c2, 0, 0, 0}, 0x11d4 }, // U11d4 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b3, 0x11ba, 0, 0, 0}, 0x11d6 }, // U11d6 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11a8, 0, 0, 0}, 0x11da }, // U11da # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11af, 0, 0, 0}, 0x11db }, // U11db # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11b8, 0, 0, 0}, 0x11dc }, // U11dc # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11ba, 0, 0, 0}, 0x11dd }, // U11dd # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11ba, 0x11ba, 0, 0}, 0x11de }, // U11de # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11bb, 0, 0, 0}, 0x11de }, // U11de # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11bc, 0, 0, 0}, 0x11e2 }, // U11e2 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11be, 0, 0, 0}, 0x11e0 }, // U11e0 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11c2, 0, 0, 0}, 0x11e1 }, // U11e1 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b7, 0x11eb, 0, 0, 0}, 0x11df }, // U11df # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b8, 0x11af, 0, 0, 0}, 0x11e3 }, // U11e3 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b8, 0x11ba, 0, 0, 0}, 0x11b9 }, // U11b9 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b8, 0x11bc, 0, 0, 0}, 0x11e6 }, // U11e6 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b8, 0x11c1, 0, 0, 0}, 0x11e4 }, // U11e4 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11b8, 0x11c2, 0, 0, 0}, 0x11e5 }, // U11e5 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ba, 0x11a8, 0, 0, 0}, 0x11e7 }, // U11e7 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ba, 0x11ae, 0, 0, 0}, 0x11e8 }, // U11e8 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ba, 0x11af, 0, 0, 0}, 0x11e9 }, // U11e9 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ba, 0x11b8, 0, 0, 0}, 0x11ea }, // U11ea # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ba, 0x11ba, 0, 0, 0}, 0x11bb }, // U11bb # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11bc, 0x11a8, 0, 0, 0}, 0x11ec }, // U11ec # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11bc, 0x11a8, 0x11a8, 0, 0}, 0x11ed }, // U11ed # ��� ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11bc, 0x11a9, 0, 0, 0}, 0x11ed }, // U11ed # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11bc, 0x11bc, 0, 0, 0}, 0x11ee }, // U11ee # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11bc, 0x11bf, 0, 0, 0}, 0x11ef }, // U11ef # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11c1, 0x11b8, 0, 0, 0}, 0x11f3 }, // U11f3 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11c1, 0x11bc, 0, 0, 0}, 0x11f4 }, // U11f4 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11c2, 0x11ab, 0, 0, 0}, 0x11f5 }, // U11f5 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11c2, 0x11af, 0, 0, 0}, 0x11f6 }, // U11f6 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11c2, 0x11b7, 0, 0, 0}, 0x11f7 }, // U11f7 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11c2, 0x11b8, 0, 0, 0}, 0x11f8 }, // U11f8 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ce, 0x11c2, 0, 0, 0}, 0x11cf }, // U11cf # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11dd, 0x11ba, 0, 0, 0}, 0x11de }, // U11de # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11ec, 0x11a8, 0, 0, 0}, 0x11ed }, // U11ed # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11f0, 0x11ba, 0, 0, 0}, 0x11f1 }, // U11f1 # ��� ��� = ��� + { {UNITIZE(TQt::Key_Multi_key), 0x11f0, 0x11eb, 0, 0, 0}, 0x11f2 }, // U11f2 # ��� ��� = ��� +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d157, 0x1d165, 0, 0, 0}, 0xd15e }, // U1D15E # MUSICAL SYMBOL HALF NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d158, 0x1d165, 0, 0, 0}, 0xd15f }, // U1D15F # MUSICAL SYMBOL TQUARTER NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d158, 0x1d165, 0x1d16e, 0, 0}, 0xd160 }, // U1D160 # MUSICAL SYMBOL EIGHTH NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d158, 0x1d165, 0x1d16f, 0, 0}, 0xd161 }, // U1D161 # MUSICAL SYMBOL SIXTEENTH NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d158, 0x1d165, 0x1d170, 0, 0}, 0xd162 }, // U1D162 # MUSICAL SYMBOL THIRTY-SECOND NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d158, 0x1d165, 0x1d171, 0, 0}, 0xd163 }, // U1D163 # MUSICAL SYMBOL SIXTY-FOURTH NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d158, 0x1d165, 0x1d172, 0, 0}, 0xd164 }, // U1D164 # MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d15f, 0x1d16e, 0, 0, 0}, 0xd160 }, // U1D160 # MUSICAL SYMBOL EIGHTH NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d15f, 0x1d16f, 0, 0, 0}, 0xd161 }, // U1D161 # MUSICAL SYMBOL SIXTEENTH NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d15f, 0x1d170, 0, 0, 0}, 0xd162 }, // U1D162 # MUSICAL SYMBOL THIRTY-SECOND NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d15f, 0x1d171, 0, 0, 0}, 0xd163 }, // U1D163 # MUSICAL SYMBOL SIXTY-FOURTH NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d15f, 0x1d172, 0, 0, 0}, 0xd164 }, // U1D164 # MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1b9, 0x1d165, 0, 0, 0}, 0xd1bb }, // U1D1BB # MUSICAL SYMBOL MINIMA +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1b9, 0x1d165, 0x1d16e, 0, 0}, 0xd1bd }, // U1D1BD # MUSICAL SYMBOL SEMIMINIMA WHITE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1b9, 0x1d165, 0x1d16f, 0, 0}, 0xd1bf }, // U1D1BF # MUSICAL SYMBOL FUSA WHITE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1ba, 0x1d165, 0, 0, 0}, 0xd1bc }, // U1D1BC # MUSICAL SYMBOL MINIMA BLACK +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1ba, 0x1d165, 0x1d16e, 0, 0}, 0xd1be }, // U1D1BE # MUSICAL SYMBOL SEMIMINIMA BLACK +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1ba, 0x1d165, 0x1d16f, 0, 0}, 0xd1c0 }, // U1D1C0 # MUSICAL SYMBOL FUSA BLACK +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1bb, 0x1d16e, 0, 0, 0}, 0xd1bd }, // U1D1BD # MUSICAL SYMBOL SEMIMINIMA WHITE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1bb, 0x1d16f, 0, 0, 0}, 0xd1bf }, // U1D1BF # MUSICAL SYMBOL FUSA WHITE +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1bc, 0x1d16e, 0, 0, 0}, 0xd1be }, // U1D1BE # MUSICAL SYMBOL SEMIMINIMA BLACK +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1d1bc, 0x1d16f, 0, 0, 0}, 0xd1c0 }, // U1D1C0 # MUSICAL SYMBOL FUSA BLACK +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, 0x0000, 0, 0, 0}, 0x1fcd }, // U1FCD # GREEK PSILI AND VARIA +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, 0x0000, 0, 0, 0}, 0x1fce }, // U1FCE # GREEK PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, 0x0027, 0, 0, 0}, 0x1fce }, // U1FCE # GREEK PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, 0x0060, 0, 0, 0}, 0x1fcd }, // U1FCD # GREEK PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, 0x007e, 0, 0, 0}, 0x1fcf }, // U1FCF # GREEK PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, 0x00b4, 0, 0, 0}, 0x1fce }, // U1FCE # GREEK PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, 0x0342, 0, 0, 0}, 0x1fcf }, // U1FCF # GREEK PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, UNITIZE(TQt::Key_Dead_Grave), 0, 0, 0}, 0x1fcd }, // U1FCD # GREEK PSILI AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, UNITIZE(TQt::Key_Dead_Acute), 0, 0, 0}, 0x1fce }, // U1FCE # GREEK PSILI AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x1fbf, UNITIZE(TQt::Key_Dead_Tilde), 0, 0, 0}, 0x1fcf }, // U1FCF # GREEK PSILI AND PERISPOMENI +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, 0x0000, 0, 0, 0}, 0x1fdd }, // U1FDD # GREEK DASIA AND VARIA +// /* broken */ { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, 0x0000, 0, 0, 0}, 0x1fde }, // U1FDE # GREEK DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, 0x0027, 0, 0, 0}, 0x1fde }, // U1FDE # GREEK DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, 0x0060, 0, 0, 0}, 0x1fdd }, // U1FDD # GREEK DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, 0x007e, 0, 0, 0}, 0x1fdf }, // U1FDF # GREEK DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, 0x00b4, 0, 0, 0}, 0x1fde }, // U1FDE # GREEK DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, 0x0342, 0, 0, 0}, 0x1fdf }, // U1FDF # GREEK DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, UNITIZE(TQt::Key_Dead_Grave), 0, 0, 0}, 0x1fdd }, // U1FDD # GREEK DASIA AND VARIA + { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, UNITIZE(TQt::Key_Dead_Acute), 0, 0, 0}, 0x1fde }, // U1FDE # GREEK DASIA AND OXIA + { {UNITIZE(TQt::Key_Multi_key), 0x1ffe, UNITIZE(TQt::Key_Dead_Tilde), 0, 0, 0}, 0x1fdf }, // U1FDF # GREEK DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Multi_key), 0x2203, 0x0338, 0, 0, 0}, 0x2204 }, // U2204 # THERE DOES NOT EXIST + { {UNITIZE(TQt::Key_Multi_key), 0x2208, 0x0338, 0, 0, 0}, 0x2209 }, // U2209 # NOT AN ELEMENT OF + { {UNITIZE(TQt::Key_Multi_key), 0x220b, 0x0338, 0, 0, 0}, 0x220c }, // U220C # DOES NOT CONTAIN AS MEMBER + { {UNITIZE(TQt::Key_Multi_key), 0x2223, 0x0338, 0, 0, 0}, 0x2224 }, // U2224 # DOES NOT DIVIDE + { {UNITIZE(TQt::Key_Multi_key), 0x2225, 0x0338, 0, 0, 0}, 0x2226 }, // U2226 # NOT PARALLEL TO + { {UNITIZE(TQt::Key_Multi_key), 0x223c, 0x0338, 0, 0, 0}, 0x2241 }, // U2241 # NOT TILDE + { {UNITIZE(TQt::Key_Multi_key), 0x223c, 0x0338, 0, 0, 0}, 0x2247 }, // U2247 # NEITHER APPROXIMATELY NOR ACTUALLY ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x2243, 0x0338, 0, 0, 0}, 0x2244 }, // U2244 # NOT ASYMPTOTICALLY ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x2248, 0x0338, 0, 0, 0}, 0x2249 }, // U2249 # NOT ALMOST ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x224d, 0x0338, 0, 0, 0}, 0x226d }, // U226D # NOT ETQUIVALENT TO + { {UNITIZE(TQt::Key_Multi_key), 0x2261, 0x0338, 0, 0, 0}, 0x2262 }, // U2262 # NOT IDENTICAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x2264, 0x0338, 0, 0, 0}, 0x2270 }, // U2270 # NEITHER LESS-THAN NOR ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x2265, 0x0338, 0, 0, 0}, 0x2271 }, // U2271 # NEITHER GREATER-THAN NOR ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x2272, 0x0338, 0, 0, 0}, 0x2274 }, // U2274 # NEITHER LESS-THAN NOR ETQUIVALENT TO + { {UNITIZE(TQt::Key_Multi_key), 0x2273, 0x0338, 0, 0, 0}, 0x2275 }, // U2275 # NEITHER GREATER-THAN NOR ETQUIVALENT TO + { {UNITIZE(TQt::Key_Multi_key), 0x2276, 0x0338, 0, 0, 0}, 0x2278 }, // U2278 # NEITHER LESS-THAN NOR GREATER-THAN + { {UNITIZE(TQt::Key_Multi_key), 0x2277, 0x0338, 0, 0, 0}, 0x2279 }, // U2279 # NEITHER GREATER-THAN NOR LESS-THAN + { {UNITIZE(TQt::Key_Multi_key), 0x227a, 0x0338, 0, 0, 0}, 0x2280 }, // U2280 # DOES NOT PRECEDE + { {UNITIZE(TQt::Key_Multi_key), 0x227b, 0x0338, 0, 0, 0}, 0x2281 }, // U2281 # DOES NOT SUCCEED + { {UNITIZE(TQt::Key_Multi_key), 0x227c, 0x0338, 0, 0, 0}, 0x22e0 }, // U22E0 # DOES NOT PRECEDE OR ETQUAL + { {UNITIZE(TQt::Key_Multi_key), 0x227d, 0x0338, 0, 0, 0}, 0x22e1 }, // U22E1 # DOES NOT SUCCEED OR ETQUAL + { {UNITIZE(TQt::Key_Multi_key), 0x2282, 0x0338, 0, 0, 0}, 0x2284 }, // U2284 # NOT A SUBSET OF + { {UNITIZE(TQt::Key_Multi_key), 0x2282, 0x0338, 0, 0, 0}, 0x2284 }, // U2284 # NOT A SUBSET OF + { {UNITIZE(TQt::Key_Multi_key), 0x2283, 0x0338, 0, 0, 0}, 0x2285 }, // U2285 # NOT A SUPERSET OF + { {UNITIZE(TQt::Key_Multi_key), 0x2283, 0x0338, 0, 0, 0}, 0x2285 }, // U2285 # NOT A SUPERSET OF + { {UNITIZE(TQt::Key_Multi_key), 0x2286, 0x0338, 0, 0, 0}, 0x2288 }, // U2288 # NEITHER A SUBSET OF NOR ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x2287, 0x0338, 0, 0, 0}, 0x2289 }, // U2289 # NEITHER A SUPERSET OF NOR ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x2291, 0x0338, 0, 0, 0}, 0x22e2 }, // U22E2 # NOT SQUARE IMAGE OF OR ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x2292, 0x0338, 0, 0, 0}, 0x22e3 }, // U22E3 # NOT SQUARE ORIGINAL OF OR ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x22a3, 0x0338, 0, 0, 0}, 0x22ac }, // U22AC # DOES NOT PROVE + { {UNITIZE(TQt::Key_Multi_key), 0x22a8, 0x0338, 0, 0, 0}, 0x22ad }, // U22AD # NOT TRUE + { {UNITIZE(TQt::Key_Multi_key), 0x22a9, 0x0338, 0, 0, 0}, 0x22ae }, // U22AE # DOES NOT FORCE + { {UNITIZE(TQt::Key_Multi_key), 0x22ab, 0x0338, 0, 0, 0}, 0x22af }, // U22AF # NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE + { {UNITIZE(TQt::Key_Multi_key), 0x22b2, 0x0338, 0, 0, 0}, 0x22ea }, // U22EA # NOT NORMAL SUBGROUP OF + { {UNITIZE(TQt::Key_Multi_key), 0x22b3, 0x0338, 0, 0, 0}, 0x22eb }, // U22EB # DOES NOT CONTAIN AS NORMAL SUBGROUP + { {UNITIZE(TQt::Key_Multi_key), 0x22b4, 0x0338, 0, 0, 0}, 0x22ec }, // U22EC # NOT NORMAL SUBGROUP OF OR ETQUAL TO + { {UNITIZE(TQt::Key_Multi_key), 0x22b5, 0x0338, 0, 0, 0}, 0x22ed }, // U22ED # DOES NOT CONTAIN AS NORMAL SUBGROUP OR ETQUAL + { {UNITIZE(TQt::Key_Multi_key), 0x2add, 0x0338, 0, 0, 0}, 0x2adc }, // U2ADC # FORKING +// /* broken */ { {UNITIZE(TQt::Key_Dead_Grave), 0x0000, 0, 0, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Grave), 0x0000, 0, 0, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Grave), 0x0000, 0, 0, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Grave), 0x0000, 0, 0, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0020, 0, 0, 0, 0}, 0x0060 }, // grave + { {UNITIZE(TQt::Key_Dead_Grave), 0x0041, 0, 0, 0, 0}, 0x00c0 }, // U00C0 # LATIN CAPITAL LETTER A WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0045, 0, 0, 0, 0}, 0x00c8 }, // U00C8 # LATIN CAPITAL LETTER E WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0049, 0, 0, 0, 0}, 0x00cc }, // U00CC # LATIN CAPITAL LETTER I WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x004e, 0, 0, 0, 0}, 0x01f8 }, // U01F8 # LATIN CAPITAL LETTER N WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x004f, 0, 0, 0, 0}, 0x00d2 }, // U00D2 # LATIN CAPITAL LETTER O WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0055, 0, 0, 0, 0}, 0x00d9 }, // U00D9 # LATIN CAPITAL LETTER U WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0057, 0, 0, 0, 0}, 0x1e80 }, // U1E80 # LATIN CAPITAL LETTER W WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0059, 0, 0, 0, 0}, 0x1ef2 }, // U1EF2 # LATIN CAPITAL LETTER Y WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0061, 0, 0, 0, 0}, 0x00e0 }, // U00E0 # LATIN SMALL LETTER A WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0065, 0, 0, 0, 0}, 0x00e8 }, // U00E8 # LATIN SMALL LETTER E WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0069, 0, 0, 0, 0}, 0x00ec }, // U00EC # LATIN SMALL LETTER I WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x006e, 0, 0, 0, 0}, 0x01f9 }, // U01F9 # LATIN SMALL LETTER N WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x006f, 0, 0, 0, 0}, 0x00f2 }, // U00F2 # LATIN SMALL LETTER O WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0075, 0, 0, 0, 0}, 0x00f9 }, // U00F9 # LATIN SMALL LETTER U WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0077, 0, 0, 0, 0}, 0x1e81 }, // U1E81 # LATIN SMALL LETTER W WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0079, 0, 0, 0, 0}, 0x1ef3 }, // U1EF3 # LATIN SMALL LETTER Y WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x00c2, 0, 0, 0, 0}, 0x1ea6 }, // U1EA6 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x00ca, 0, 0, 0, 0}, 0x1ec0 }, // U1EC0 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x00d4, 0, 0, 0, 0}, 0x1ed2 }, // U1ED2 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x00dc, 0, 0, 0, 0}, 0x01db }, // U01DB # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x00e2, 0, 0, 0, 0}, 0x1ea7 }, // U1EA7 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x00ea, 0, 0, 0, 0}, 0x1ec1 }, // U1EC1 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x00f4, 0, 0, 0, 0}, 0x1ed3 }, // U1ED3 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x00fc, 0, 0, 0, 0}, 0x01dc }, // U01DC # LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0102, 0, 0, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0103, 0, 0, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0112, 0, 0, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0113, 0, 0, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x014c, 0, 0, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x014d, 0, 0, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x01A0, 0, 0, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x01A1, 0, 0, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x01AF, 0, 0, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x01B0, 0, 0, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x0391, 0, 0, 0}, 0x1f0a }, // U1F0A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x0395, 0, 0, 0}, 0x1f1a }, // U1F1A # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x0397, 0, 0, 0}, 0x1f2a }, // U1F2A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x0399, 0, 0, 0}, 0x1f3a }, // U1F3A # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x039f, 0, 0, 0}, 0x1f4a }, // U1F4A # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03a9, 0, 0, 0}, 0x1f6a }, // U1F6A # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03b1, 0, 0, 0}, 0x1f02 }, // U1F02 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03b5, 0, 0, 0}, 0x1f12 }, // U1F12 # GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03b7, 0, 0, 0}, 0x1f22 }, // U1F22 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03b9, 0, 0, 0}, 0x1f32 }, // U1F32 # GREEK SMALL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03bf, 0, 0, 0}, 0x1f42 }, // U1F42 # GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03c5, 0, 0, 0}, 0x1f52 }, // U1F52 # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03c9, 0, 0, 0}, 0x1f62 }, // U1F62 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x0391, 0, 0, 0}, 0x1f0b }, // U1F0B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x0395, 0, 0, 0}, 0x1f1b }, // U1F1B # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x0397, 0, 0, 0}, 0x1f2b }, // U1F2B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x0399, 0, 0, 0}, 0x1f3b }, // U1F3B # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x039f, 0, 0, 0}, 0x1f4b }, // U1F4B # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03a5, 0, 0, 0}, 0x1f5b }, // U1F5B # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03a9, 0, 0, 0}, 0x1f6b }, // U1F6B # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03b1, 0, 0, 0}, 0x1f03 }, // U1F03 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03b5, 0, 0, 0}, 0x1f13 }, // U1F13 # GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03b7, 0, 0, 0}, 0x1f23 }, // U1F23 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03b9, 0, 0, 0}, 0x1f33 }, // U1F33 # GREEK SMALL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03bf, 0, 0, 0}, 0x1f43 }, // U1F43 # GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03c5, 0, 0, 0}, 0x1f53 }, // U1F53 # GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03c9, 0, 0, 0}, 0x1f63 }, // U1F63 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0391, 0, 0, 0, 0}, 0x1fba }, // U1FBA # GREEK CAPITAL LETTER ALPHA WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0395, 0, 0, 0, 0}, 0x1fc8 }, // U1FC8 # GREEK CAPITAL LETTER EPSILON WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0397, 0, 0, 0, 0}, 0x1fca }, // U1FCA # GREEK CAPITAL LETTER ETA WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0399, 0, 0, 0, 0}, 0x1fda }, // U1FDA # GREEK CAPITAL LETTER IOTA WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x039f, 0, 0, 0, 0}, 0x1ff8 }, // U1FF8 # GREEK CAPITAL LETTER OMICRON WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03a5, 0, 0, 0, 0}, 0x1fea }, // U1FEA # GREEK CAPITAL LETTER UPSILON WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03a9, 0, 0, 0, 0}, 0x1ffa }, // U1FFA # GREEK CAPITAL LETTER OMEGA WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03b1, 0, 0, 0, 0}, 0x1f70 }, // U1F70 # GREEK SMALL LETTER ALPHA WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03b5, 0, 0, 0, 0}, 0x1f72 }, // U1F72 # GREEK SMALL LETTER EPSILON WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03b7, 0, 0, 0, 0}, 0x1f74 }, // U1F74 # GREEK SMALL LETTER ETA WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03b9, 0, 0, 0, 0}, 0x1f76 }, // U1F76 # GREEK SMALL LETTER IOTA WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03bf, 0, 0, 0, 0}, 0x1f78 }, // U1F78 # GREEK SMALL LETTER OMICRON WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03c5, 0, 0, 0, 0}, 0x1f7a }, // U1F7A # GREEK SMALL LETTER UPSILON WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03c9, 0, 0, 0, 0}, 0x1f7c }, // U1F7C # GREEK SMALL LETTER OMEGA WITH VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03ca, 0, 0, 0, 0}, 0x1fd2 }, // U1FD2 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x03cb, 0, 0, 0, 0}, 0x1fe2 }, // U1FE2 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x0415, 0, 0, 0, 0}, 0x0400 }, // U0400 # CYRILLIC CAPITAL LETTER IE WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0418, 0, 0, 0, 0}, 0x040d }, // U040D # CYRILLIC CAPITAL LETTER I WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0435, 0, 0, 0, 0}, 0x0450 }, // U0450 # CYRILLIC SMALL LETTER IE WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x0438, 0, 0, 0, 0}, 0x045d }, // U045D # CYRILLIC SMALL LETTER I WITH GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f00, 0, 0, 0, 0}, 0x1f02 }, // U1F02 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f01, 0, 0, 0, 0}, 0x1f03 }, // U1F03 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f08, 0, 0, 0, 0}, 0x1f0a }, // U1F0A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f09, 0, 0, 0, 0}, 0x1f0b }, // U1F0B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f10, 0, 0, 0, 0}, 0x1f12 }, // U1F12 # GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f11, 0, 0, 0, 0}, 0x1f13 }, // U1F13 # GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f18, 0, 0, 0, 0}, 0x1f1a }, // U1F1A # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f19, 0, 0, 0, 0}, 0x1f1b }, // U1F1B # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f20, 0, 0, 0, 0}, 0x1f22 }, // U1F22 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f21, 0, 0, 0, 0}, 0x1f23 }, // U1F23 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f28, 0, 0, 0, 0}, 0x1f2a }, // U1F2A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f29, 0, 0, 0, 0}, 0x1f2b }, // U1F2B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f30, 0, 0, 0, 0}, 0x1f32 }, // U1F32 # GREEK SMALL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f31, 0, 0, 0, 0}, 0x1f33 }, // U1F33 # GREEK SMALL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f38, 0, 0, 0, 0}, 0x1f3a }, // U1F3A # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f39, 0, 0, 0, 0}, 0x1f3b }, // U1F3B # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f40, 0, 0, 0, 0}, 0x1f42 }, // U1F42 # GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f41, 0, 0, 0, 0}, 0x1f43 }, // U1F43 # GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f48, 0, 0, 0, 0}, 0x1f4a }, // U1F4A # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f49, 0, 0, 0, 0}, 0x1f4b }, // U1F4B # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f50, 0, 0, 0, 0}, 0x1f52 }, // U1F52 # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f51, 0, 0, 0, 0}, 0x1f53 }, // U1F53 # GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f59, 0, 0, 0, 0}, 0x1f5b }, // U1F5B # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f60, 0, 0, 0, 0}, 0x1f62 }, // U1F62 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f61, 0, 0, 0, 0}, 0x1f63 }, // U1F63 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f68, 0, 0, 0, 0}, 0x1f6a }, // U1F6A # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), 0x1f69, 0, 0, 0, 0}, 0x1f6b }, // U1F6B # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0055, 0, 0}, 0x01db }, // U01DB # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0075, 0, 0}, 0x01dc }, // U01DC # LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03b9, 0, 0}, 0x1fd2 }, // U1FD2 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03c5, 0, 0}, 0x1fe2 }, // U1FE2 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0, 0}, 0x1f0b }, // U1F0B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0395, 0, 0}, 0x1f1b }, // U1F1B # GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0, 0}, 0x1f2b }, // U1F2B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0399, 0, 0}, 0x1f3b }, // U1F3B # GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x039f, 0, 0}, 0x1f4b }, // U1F4B # GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a5, 0, 0}, 0x1f5b }, // U1F5B # GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0, 0}, 0x1f6b }, // U1F6B # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0, 0}, 0x1f03 }, // U1F03 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b5, 0, 0}, 0x1f13 }, // U1F13 # GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0, 0}, 0x1f23 }, // U1F23 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b9, 0, 0}, 0x1f33 }, // U1F33 # GREEK SMALL LETTER IOTA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03bf, 0, 0}, 0x1f43 }, // U1F43 # GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c5, 0, 0}, 0x1f53 }, // U1F53 # GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0, 0}, 0x1f63 }, // U1F63 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0, 0}, 0x1f0a }, // U1F0A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0395, 0, 0}, 0x1f1a }, // U1F1A # GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0, 0}, 0x1f2a }, // U1F2A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0399, 0, 0}, 0x1f3a }, // U1F3A # GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x039f, 0, 0}, 0x1f4a }, // U1F4A # GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0, 0}, 0x1f6a }, // U1F6A # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0, 0}, 0x1f02 }, // U1F02 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b5, 0, 0}, 0x1f12 }, // U1F12 # GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0, 0}, 0x1f22 }, // U1F22 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b9, 0, 0}, 0x1f32 }, // U1F32 # GREEK SMALL LETTER IOTA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03bf, 0, 0}, 0x1f42 }, // U1F42 # GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c5, 0, 0}, 0x1f52 }, // U1F52 # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0, 0}, 0x1f62 }, // U1F62 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0041, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0061, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0041, 0, 0}, 0x1ea6 }, // U1EA6 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0045, 0, 0}, 0x1ec0 }, // U1EC0 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004f, 0, 0}, 0x1ed2 }, // U1ED2 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0061, 0, 0}, 0x1ea7 }, // U1EA7 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0065, 0, 0}, 0x1ec1 }, // U1EC1 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006f, 0, 0}, 0x1ed3 }, // U1ED3 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0045, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x004f, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0065, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006f, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0041, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0061, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0045, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x004f, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0065, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x006f, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Grave), 0, 0, 0, 0}, 0x0060 }, // grave + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0, 0}, 0x1ea6 }, // U1EA6 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0, 0}, 0x1ec0 }, // U1EC0 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0, 0}, 0x1ed2 }, // U1ED2 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0, 0}, 0x1ea7 }, // U1EA7 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0, 0}, 0x1ec1 }, // U1EC1 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0, 0}, 0x1ed3 }, // U1ED3 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Macron), 0x0045, 0, 0, 0}, 0x1e14 }, // U1E14 # LATIN CAPITAL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Macron), 0x004f, 0, 0, 0}, 0x1e50 }, // U1E50 # LATIN CAPITAL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Macron), 0x0065, 0, 0, 0}, 0x1e15 }, // U1E15 # LATIN SMALL LETTER E WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Macron), 0x006f, 0, 0, 0}, 0x1e51 }, // U1E51 # LATIN SMALL LETTER O WITH MACRON AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0, 0}, 0x1eb0 }, // U1EB0 # LATIN CAPITAL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0, 0}, 0x1eb1 }, // U1EB1 # LATIN SMALL LETTER A WITH BREVE AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0, 0}, 0x01db }, // U01DB # LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0, 0}, 0x01dc }, // U01DC # LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0, 0}, 0x1fd2 }, // U1FD2 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0, 0}, 0x1fe2 }, // U1FE2 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1edc }, // U1EDC # LATIN CAPITAL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1eea }, // U1EEA # LATIN CAPITAL LETTER U WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1edd }, // U1EDD # LATIN SMALL LETTER O WITH HORN AND GRAVE + { {UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1eeb }, // U1EEB # LATIN SMALL LETTER U WITH HORN AND GRAVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), 0x0000, 0, 0, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), 0x0000, 0, 0, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), 0x0000, 0, 0, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), 0x0000, 0, 0, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), 0x0000, 0x004f, 0, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), 0x0000, 0x0055, 0, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), 0x0000, 0x006f, 0, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), 0x0000, 0x0075, 0, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0020, 0, 0, 0, 0}, 0x0027 }, // apostrophe + { {UNITIZE(TQt::Key_Dead_Acute), 0x0041, 0, 0, 0, 0}, 0x00c1 }, // U00C1 # LATIN CAPITAL LETTER A WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0043, 0, 0, 0, 0}, 0x0106 }, // U0106 # LATIN CAPITAL LETTER C WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0045, 0, 0, 0, 0}, 0x00c9 }, // U00C9 # LATIN CAPITAL LETTER E WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0047, 0, 0, 0, 0}, 0x01f4 }, // U01F4 # LATIN CAPITAL LETTER G WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0049, 0, 0, 0, 0}, 0x00cd }, // U00CD # LATIN CAPITAL LETTER I WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x004b, 0, 0, 0, 0}, 0x1e30 }, // U1E30 # LATIN CAPITAL LETTER K WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x004c, 0, 0, 0, 0}, 0x0139 }, // U0139 # LATIN CAPITAL LETTER L WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x004d, 0, 0, 0, 0}, 0x1e3e }, // U1E3E # LATIN CAPITAL LETTER M WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x004e, 0, 0, 0, 0}, 0x0143 }, // U0143 # LATIN CAPITAL LETTER N WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x004f, 0, 0, 0, 0}, 0x00d3 }, // U00D3 # LATIN CAPITAL LETTER O WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0050, 0, 0, 0, 0}, 0x1e54 }, // U1E54 # LATIN CAPITAL LETTER P WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0052, 0, 0, 0, 0}, 0x0154 }, // U0154 # LATIN CAPITAL LETTER R WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0053, 0, 0, 0, 0}, 0x015a }, // U015A # LATIN CAPITAL LETTER S WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0055, 0, 0, 0, 0}, 0x00da }, // U00DA # LATIN CAPITAL LETTER U WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0057, 0, 0, 0, 0}, 0x1e82 }, // U1E82 # LATIN CAPITAL LETTER W WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0059, 0, 0, 0, 0}, 0x00dd }, // U00DD # LATIN CAPITAL LETTER Y WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x005a, 0, 0, 0, 0}, 0x0179 }, // U0179 # LATIN CAPITAL LETTER Z WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0061, 0, 0, 0, 0}, 0x00e1 }, // U00E1 # LATIN SMALL LETTER A WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0063, 0, 0, 0, 0}, 0x0107 }, // U0107 # LATIN SMALL LETTER C WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0065, 0, 0, 0, 0}, 0x00e9 }, // U00E9 # LATIN SMALL LETTER E WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0067, 0, 0, 0, 0}, 0x01f5 }, // U01F5 # LATIN SMALL LETTER G WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0069, 0, 0, 0, 0}, 0x00ed }, // U00ED # LATIN SMALL LETTER I WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x006b, 0, 0, 0, 0}, 0x1e31 }, // U1E31 # LATIN SMALL LETTER K WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x006c, 0, 0, 0, 0}, 0x013a }, // U013A # LATIN SMALL LETTER L WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x006d, 0, 0, 0, 0}, 0x1e3f }, // U1E3F # LATIN SMALL LETTER M WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x006e, 0, 0, 0, 0}, 0x0144 }, // U0144 # LATIN SMALL LETTER N WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x006f, 0, 0, 0, 0}, 0x00f3 }, // U00F3 # LATIN SMALL LETTER O WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0070, 0, 0, 0, 0}, 0x1e55 }, // U1E55 # LATIN SMALL LETTER P WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0072, 0, 0, 0, 0}, 0x0155 }, // U0155 # LATIN SMALL LETTER R WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0073, 0, 0, 0, 0}, 0x015b }, // U015B # LATIN SMALL LETTER S WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0075, 0, 0, 0, 0}, 0x00fa }, // U00FA # LATIN SMALL LETTER U WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0077, 0, 0, 0, 0}, 0x1e83 }, // U1E83 # LATIN SMALL LETTER W WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0079, 0, 0, 0, 0}, 0x00fd }, // U00FD # LATIN SMALL LETTER Y WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x007a, 0, 0, 0, 0}, 0x017a }, // U017A # LATIN SMALL LETTER Z WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00c2, 0, 0, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00c5, 0, 0, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00c6, 0, 0, 0, 0}, 0x01fc }, // U01FC # LATIN CAPITAL LETTER AE WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00c7, 0, 0, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00ca, 0, 0, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00cf, 0, 0, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00d4, 0, 0, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00d5, 0, 0, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00d8, 0, 0, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00dc, 0, 0, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00e2, 0, 0, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00e5, 0, 0, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00e6, 0, 0, 0, 0}, 0x01fd }, // U01FD # LATIN SMALL LETTER AE WITH ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00e7, 0, 0, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00ea, 0, 0, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00ef, 0, 0, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00f4, 0, 0, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00f5, 0, 0, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00f8, 0, 0, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x00fc, 0, 0, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0102, 0, 0, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0103, 0, 0, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0112, 0, 0, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0113, 0, 0, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x014c, 0, 0, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x014d, 0, 0, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0168, 0, 0, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0169, 0, 0, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x01A0, 0, 0, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x01A1, 0, 0, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x01AF, 0, 0, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x01B0, 0, 0, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x0391, 0, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x0395, 0, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x0397, 0, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x0399, 0, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x039f, 0, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03a9, 0, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03b1, 0, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03b5, 0, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03b7, 0, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03b9, 0, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03bf, 0, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03c5, 0, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03c9, 0, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x0391, 0, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x0395, 0, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x0397, 0, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x0399, 0, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x039f, 0, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03a5, 0, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03a9, 0, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03b1, 0, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03b5, 0, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03b7, 0, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03b9, 0, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03bf, 0, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03c5, 0, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03c9, 0, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x0391, 0, 0, 0, 0}, 0x0386 }, // U0386 # GREEK CAPITAL LETTER ALPHA WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x0395, 0, 0, 0, 0}, 0x0388 }, // U0388 # GREEK CAPITAL LETTER EPSILON WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x0397, 0, 0, 0, 0}, 0x0389 }, // U0389 # GREEK CAPITAL LETTER ETA WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x0399, 0, 0, 0, 0}, 0x038a }, // U038A # GREEK CAPITAL LETTER IOTA WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x039f, 0, 0, 0, 0}, 0x038c }, // U038C # GREEK CAPITAL LETTER OMICRON WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03a5, 0, 0, 0, 0}, 0x038e }, // U038E # GREEK CAPITAL LETTER UPSILON WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03a9, 0, 0, 0, 0}, 0x038f }, // U038F # GREEK CAPITAL LETTER OMEGA WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03b1, 0, 0, 0, 0}, 0x03ac }, // U03AC # GREEK SMALL LETTER ALPHA WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03b5, 0, 0, 0, 0}, 0x03ad }, // U03AD # GREEK SMALL LETTER EPSILON WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03b7, 0, 0, 0, 0}, 0x03ae }, // U03AE # GREEK SMALL LETTER ETA WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03b9, 0, 0, 0, 0}, 0x03af }, // U03AF # GREEK SMALL LETTER IOTA WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03bf, 0, 0, 0, 0}, 0x03cc }, // U03CC # GREEK SMALL LETTER OMICRON WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03c5, 0, 0, 0, 0}, 0x03cd }, // U03CD # GREEK SMALL LETTER UPSILON WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03c9, 0, 0, 0, 0}, 0x03ce }, // U03CE # GREEK SMALL LETTER OMEGA WITH TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03ca, 0, 0, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x03cb, 0, 0, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Dead_Acute), 0x0413, 0, 0, 0, 0}, 0x0403 }, // U0403 # CYRILLIC CAPITAL LETTER GJE + { {UNITIZE(TQt::Key_Dead_Acute), 0x041a, 0, 0, 0, 0}, 0x040c }, // U040C # CYRILLIC CAPITAL LETTER KJE + { {UNITIZE(TQt::Key_Dead_Acute), 0x0433, 0, 0, 0, 0}, 0x0453 }, // U0453 # CYRILLIC SMALL LETTER GJE + { {UNITIZE(TQt::Key_Dead_Acute), 0x043a, 0, 0, 0, 0}, 0x045c }, // U045C # CYRILLIC SMALL LETTER KJE + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f00, 0, 0, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f01, 0, 0, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f08, 0, 0, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f09, 0, 0, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f10, 0, 0, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f11, 0, 0, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f18, 0, 0, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f19, 0, 0, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f20, 0, 0, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f21, 0, 0, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f28, 0, 0, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f29, 0, 0, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f30, 0, 0, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f31, 0, 0, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f38, 0, 0, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f39, 0, 0, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f40, 0, 0, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f41, 0, 0, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f48, 0, 0, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f49, 0, 0, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f50, 0, 0, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f51, 0, 0, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f59, 0, 0, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f60, 0, 0, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f61, 0, 0, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f68, 0, 0, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), 0x1f69, 0, 0, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0000, 0x004f, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0000, 0x006f, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0049, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0055, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0069, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0075, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03b9, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03c5, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0, 0}, 0x1f0d }, // U1F0D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0395, 0, 0}, 0x1f1d }, // U1F1D # GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0, 0}, 0x1f2d }, // U1F2D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0399, 0, 0}, 0x1f3d }, // U1F3D # GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x039f, 0, 0}, 0x1f4d }, // U1F4D # GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a5, 0, 0}, 0x1f5d }, // U1F5D # GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0, 0}, 0x1f6d }, // U1F6D # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0, 0}, 0x1f05 }, // U1F05 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b5, 0, 0}, 0x1f15 }, // U1F15 # GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0, 0}, 0x1f25 }, // U1F25 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b9, 0, 0}, 0x1f35 }, // U1F35 # GREEK SMALL LETTER IOTA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03bf, 0, 0}, 0x1f45 }, // U1F45 # GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c5, 0, 0}, 0x1f55 }, // U1F55 # GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0, 0}, 0x1f65 }, // U1F65 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0, 0}, 0x1f0c }, // U1F0C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0395, 0, 0}, 0x1f1c }, // U1F1C # GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0, 0}, 0x1f2c }, // U1F2C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0399, 0, 0}, 0x1f3c }, // U1F3C # GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x039f, 0, 0}, 0x1f4c }, // U1F4C # GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0, 0}, 0x1f6c }, // U1F6C # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0, 0}, 0x1f04 }, // U1F04 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b5, 0, 0}, 0x1f14 }, // U1F14 # GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0, 0}, 0x1f24 }, // U1F24 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b9, 0, 0}, 0x1f34 }, // U1F34 # GREEK SMALL LETTER IOTA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03bf, 0, 0}, 0x1f44 }, // U1F44 # GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c5, 0, 0}, 0x1f54 }, // U1F54 # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0, 0}, 0x1f64 }, // U1F64 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0043, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0063, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x002f, 0x004f, 0, 0}, 0x01fe }, // U01FE # LATIN CAPITAL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x002f, 0x006f, 0, 0}, 0x01ff }, // U01FF # LATIN SMALL LETTER O WITH STROKE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0041, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0045, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004f, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0061, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0065, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006f, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0041, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0061, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0041, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x006f, 0x0061, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x004f, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0055, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x006f, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0075, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0045, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x004f, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0065, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x006f, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Acute), 0, 0, 0, 0}, 0x00b4 }, // acute + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0, 0}, 0x1ea4 }, // U1EA4 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0, 0}, 0x1ebe }, // U1EBE # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0, 0}, 0x1ed0 }, // U1ED0 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0, 0}, 0x1ea5 }, // U1EA5 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0, 0}, 0x1ebf }, // U1EBF # LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0, 0}, 0x1ed1 }, // U1ED1 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0, 0}, 0x1e4c }, // U1E4C # LATIN CAPITAL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Tilde), 0x0055, 0, 0, 0}, 0x1e78 }, // U1E78 # LATIN CAPITAL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0, 0}, 0x1e4d }, // U1E4D # LATIN SMALL LETTER O WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Tilde), 0x0075, 0, 0, 0}, 0x1e79 }, // U1E79 # LATIN SMALL LETTER U WITH TILDE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Macron), 0x0045, 0, 0, 0}, 0x1e16 }, // U1E16 # LATIN CAPITAL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Macron), 0x004f, 0, 0, 0}, 0x1e52 }, // U1E52 # LATIN CAPITAL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Macron), 0x0065, 0, 0, 0}, 0x1e17 }, // U1E17 # LATIN SMALL LETTER E WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Macron), 0x006f, 0, 0, 0}, 0x1e53 }, // U1E53 # LATIN SMALL LETTER O WITH MACRON AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0, 0}, 0x1eae }, // U1EAE # LATIN CAPITAL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0, 0}, 0x1eaf }, // U1EAF # LATIN SMALL LETTER A WITH BREVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0049, 0, 0, 0}, 0x1e2e }, // U1E2E # LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0, 0}, 0x01d7 }, // U01D7 # LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0069, 0, 0, 0}, 0x1e2f }, // U1E2F # LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0, 0}, 0x01d8 }, // U01D8 # LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0, 0}, 0x0390 }, // U0390 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0, 0}, 0x03b0 }, // U03B0 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Abovering), 0x0041, 0, 0, 0}, 0x01fa }, // U01FA # LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Abovering), 0x0061, 0, 0, 0}, 0x01fb }, // U01FB # LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Cedilla), 0x0043, 0, 0, 0}, 0x1e08 }, // U1E08 # LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Cedilla), 0x0063, 0, 0, 0}, 0x1e09 }, // U1E09 # LATIN SMALL LETTER C WITH CEDILLA AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1eda }, // U1EDA # LATIN CAPITAL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1ee8 }, // U1EE8 # LATIN CAPITAL LETTER U WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1edb }, // U1EDB # LATIN SMALL LETTER O WITH HORN AND ACUTE + { {UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1ee9 }, // U1EE9 # LATIN SMALL LETTER U WITH HORN AND ACUTE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x207a }, // U207A # SUPERSCRIPT PLUS SIGN +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x207c }, // U207C # SUPERSCRIPT ETQUALS SIGN +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x00b2 }, // U00B2 # SUPERSCRIPT TWO +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x2079 }, // U2079 # SUPERSCRIPT NINE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x00b3 }, // U00B3 # SUPERSCRIPT THREE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x00b9 }, // U00B9 # SUPERSCRIPT ONE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x2070 }, // U2070 # SUPERSCRIPT ZERO +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x2078 }, // U2078 # SUPERSCRIPT EIGHT +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x2074 }, // U2074 # SUPERSCRIPT FOUR +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x2075 }, // U2075 # SUPERSCRIPT FIVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x2077 }, // U2077 # SUPERSCRIPT SEVEN +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x00b2 }, // U00B2 # SUPERSCRIPT TWO +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0, 0, 0, 0}, 0x2076 }, // U2076 # SUPERSCRIPT SIX +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0x0041, 0, 0, 0}, 0x1eac }, // U1EAC # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0x0045, 0, 0, 0}, 0x1ec6 }, // U1EC6 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0x004f, 0, 0, 0}, 0x1ed8 }, // U1ED8 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0x0061, 0, 0, 0}, 0x1ead }, // U1EAD # LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0x0065, 0, 0, 0}, 0x1ec7 }, // U1EC7 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0000, 0x006f, 0, 0, 0}, 0x1ed9 }, // U1ED9 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0020, 0, 0, 0, 0}, 0x005e }, // asciicircum + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0028, 0, 0, 0, 0}, 0x207d }, // U207D # SUPERSCRIPT LEFT PARENTHESIS + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0029, 0, 0, 0, 0}, 0x207e }, // U207E # SUPERSCRIPT RIGHT PARENTHESIS + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x002b, 0, 0, 0, 0}, 0x207a }, // U207A # SUPERSCRIPT PLUS SIGN + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0030, 0, 0, 0, 0}, 0x2070 }, // U2070 # SUPERSCRIPT ZERO + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0031, 0, 0, 0, 0}, 0x00b9 }, // U00B9 # SUPERSCRIPT ONE + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0032, 0, 0, 0, 0}, 0x00b2 }, // U00B2 # SUPERSCRIPT TWO + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0033, 0, 0, 0, 0}, 0x00b3 }, // U00B3 # SUPERSCRIPT THREE + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0034, 0, 0, 0, 0}, 0x2074 }, // U2074 # SUPERSCRIPT FOUR + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0035, 0, 0, 0, 0}, 0x2075 }, // U2075 # SUPERSCRIPT FIVE + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0036, 0, 0, 0, 0}, 0x2076 }, // U2076 # SUPERSCRIPT SIX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0037, 0, 0, 0, 0}, 0x2077 }, // U2077 # SUPERSCRIPT SEVEN + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0038, 0, 0, 0, 0}, 0x2078 }, // U2078 # SUPERSCRIPT EIGHT + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0039, 0, 0, 0, 0}, 0x2079 }, // U2079 # SUPERSCRIPT NINE + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x003d, 0, 0, 0, 0}, 0x207c }, // U207C # SUPERSCRIPT ETQUALS SIGN + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0, 0, 0}, 0x00c2 }, // U00C2 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0043, 0, 0, 0, 0}, 0x0108 }, // U0108 # LATIN CAPITAL LETTER C WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0, 0, 0}, 0x00ca }, // U00CA # LATIN CAPITAL LETTER E WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0047, 0, 0, 0, 0}, 0x011c }, // U011C # LATIN CAPITAL LETTER G WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0048, 0, 0, 0, 0}, 0x0124 }, // U0124 # LATIN CAPITAL LETTER H WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0049, 0, 0, 0, 0}, 0x00ce }, // U00CE # LATIN CAPITAL LETTER I WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x004a, 0, 0, 0, 0}, 0x0134 }, // U0134 # LATIN CAPITAL LETTER J WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0, 0, 0}, 0x00d4 }, // U00D4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0053, 0, 0, 0, 0}, 0x015c }, // U015C # LATIN CAPITAL LETTER S WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0055, 0, 0, 0, 0}, 0x00db }, // U00DB # LATIN CAPITAL LETTER U WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0057, 0, 0, 0, 0}, 0x0174 }, // U0174 # LATIN CAPITAL LETTER W WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0059, 0, 0, 0, 0}, 0x0176 }, // U0176 # LATIN CAPITAL LETTER Y WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x005a, 0, 0, 0, 0}, 0x1e90 }, // U1E90 # LATIN CAPITAL LETTER Z WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0, 0, 0}, 0x00e2 }, // U00E2 # LATIN SMALL LETTER A WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0063, 0, 0, 0, 0}, 0x0109 }, // U0109 # LATIN SMALL LETTER C WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0, 0, 0}, 0x00ea }, // U00EA # LATIN SMALL LETTER E WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0067, 0, 0, 0, 0}, 0x011d }, // U011D # LATIN SMALL LETTER G WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0068, 0, 0, 0, 0}, 0x0125 }, // U0125 # LATIN SMALL LETTER H WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0069, 0, 0, 0, 0}, 0x00ee }, // U00EE # LATIN SMALL LETTER I WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x006a, 0, 0, 0, 0}, 0x0135 }, // U0135 # LATIN SMALL LETTER J WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0, 0, 0}, 0x00f4 }, // U00F4 # LATIN SMALL LETTER O WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0073, 0, 0, 0, 0}, 0x015d }, // U015D # LATIN SMALL LETTER S WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0075, 0, 0, 0, 0}, 0x00fb }, // U00FB # LATIN SMALL LETTER U WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0077, 0, 0, 0, 0}, 0x0175 }, // U0175 # LATIN SMALL LETTER W WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x0079, 0, 0, 0, 0}, 0x0177 }, // U0177 # LATIN SMALL LETTER Y WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x007a, 0, 0, 0, 0}, 0x1e91 }, // U1E91 # LATIN SMALL LETTER Z WITH CIRCUMFLEX + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x1ea0, 0, 0, 0, 0}, 0x1eac }, // U1EAC # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x1ea1, 0, 0, 0, 0}, 0x1ead }, // U1EAD # LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x1eb8, 0, 0, 0, 0}, 0x1ec6 }, // U1EC6 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x1eb9, 0, 0, 0, 0}, 0x1ec7 }, // U1EC7 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x1ecc, 0, 0, 0, 0}, 0x1ed8 }, // U1ED8 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x1ecd, 0, 0, 0, 0}, 0x1ed9 }, // U1ED9 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x2212, 0, 0, 0, 0}, 0x207b }, // U207B # SUPERSCRIPT MINUS + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4e00, 0, 0, 0, 0}, 0x3192 }, // U3192 # IDEOGRAPHIC ANNOTATION ONE MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4e01, 0, 0, 0, 0}, 0x319c }, // U319C # IDEOGRAPHIC ANNOTATION FOURTH MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4e09, 0, 0, 0, 0}, 0x3194 }, // U3194 # IDEOGRAPHIC ANNOTATION THREE MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4e0a, 0, 0, 0, 0}, 0x3196 }, // U3196 # IDEOGRAPHIC ANNOTATION TOP MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4e0b, 0, 0, 0, 0}, 0x3198 }, // U3198 # IDEOGRAPHIC ANNOTATION BOTTOM MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4e19, 0, 0, 0, 0}, 0x319b }, // U319B # IDEOGRAPHIC ANNOTATION THIRD MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4e2d, 0, 0, 0, 0}, 0x3197 }, // U3197 # IDEOGRAPHIC ANNOTATION MIDDLE MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4e59, 0, 0, 0, 0}, 0x319a }, // U319A # IDEOGRAPHIC ANNOTATION SECOND MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4e8c, 0, 0, 0, 0}, 0x3193 }, // U3193 # IDEOGRAPHIC ANNOTATION TWO MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x4eba, 0, 0, 0, 0}, 0x319f }, // U319F # IDEOGRAPHIC ANNOTATION MAN MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x56db, 0, 0, 0, 0}, 0x3195 }, // U3195 # IDEOGRAPHIC ANNOTATION FOUR MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x5730, 0, 0, 0, 0}, 0x319e }, // U319E # IDEOGRAPHIC ANNOTATION EARTH MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x5929, 0, 0, 0, 0}, 0x319d }, // U319D # IDEOGRAPHIC ANNOTATION HEAVEN MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), 0x7532, 0, 0, 0, 0}, 0x3199 }, // U3199 # IDEOGRAPHIC ANNOTATION FIRST MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0041, 0, 0}, 0x1eac }, // U1EAC # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0045, 0, 0}, 0x1ec6 }, // U1EC6 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x004f, 0, 0}, 0x1ed8 }, // U1ED8 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0061, 0, 0}, 0x1ead }, // U1EAD # LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0065, 0, 0}, 0x1ec7 }, // U1EC7 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x006f, 0, 0}, 0x1ed9 }, // U1ED9 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x0053, 0x004d, 0, 0}, 0x2120 }, // U2120 # SERVICE MARK + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x0054, 0x004d, 0, 0}, 0x2122 }, // U2122 # TRADE MARK SIGN + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0061, 0, 0}, 0x00aa }, // U00AA # FEMININE ORDINAL INDICATOR + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0061, 0, 0}, 0x00aa }, // U00AA # FEMININE ORDINAL INDICATOR + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0068, 0, 0}, 0x02b0 }, // U02B0 # MODIFIER LETTER SMALL H + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0068, 0, 0}, 0x02b0 }, // U02B0 # MODIFIER LETTER SMALL H + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0069, 0, 0}, 0x2071 }, // U2071 # SUPERSCRIPT LATIN SMALL LETTER I + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0069, 0, 0}, 0x2071 }, // U2071 # SUPERSCRIPT LATIN SMALL LETTER I + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006a, 0, 0}, 0x02b2 }, // U02B2 # MODIFIER LETTER SMALL J + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006a, 0, 0}, 0x02b2 }, // U02B2 # MODIFIER LETTER SMALL J + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006c, 0, 0}, 0x02e1 }, // U02E1 # MODIFIER LETTER SMALL L + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006c, 0, 0}, 0x02e1 }, // U02E1 # MODIFIER LETTER SMALL L + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006e, 0, 0}, 0x207f }, // U207F # SUPERSCRIPT LATIN SMALL LETTER N + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006e, 0, 0}, 0x207f }, // U207F # SUPERSCRIPT LATIN SMALL LETTER N + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006f, 0, 0}, 0x00ba }, // U00BA # MASCULINE ORDINAL INDICATOR + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x006f, 0, 0}, 0x00ba }, // U00BA # MASCULINE ORDINAL INDICATOR + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0072, 0, 0}, 0x02b3 }, // U02B3 # MODIFIER LETTER SMALL R + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0072, 0, 0}, 0x02b3 }, // U02B3 # MODIFIER LETTER SMALL R + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0073, 0, 0}, 0x02e2 }, // U02E2 # MODIFIER LETTER SMALL S + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0073, 0, 0}, 0x02e2 }, // U02E2 # MODIFIER LETTER SMALL S + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0077, 0, 0}, 0x02b7 }, // U02B7 # MODIFIER LETTER SMALL W + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0077, 0, 0}, 0x02b7 }, // U02B7 # MODIFIER LETTER SMALL W + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0078, 0, 0}, 0x02e3 }, // U02E3 # MODIFIER LETTER SMALL X + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0078, 0, 0}, 0x02e3 }, // U02E3 # MODIFIER LETTER SMALL X + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0079, 0, 0}, 0x02b8 }, // U02B8 # MODIFIER LETTER SMALL Y + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0079, 0, 0}, 0x02b8 }, // U02B8 # MODIFIER LETTER SMALL Y + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0263, 0, 0}, 0x02e0 }, // U02E0 # MODIFIER LETTER SMALL GAMMA + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0263, 0, 0}, 0x02e0 }, // U02E0 # MODIFIER LETTER SMALL GAMMA + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0266, 0, 0}, 0x02b1 }, // U02B1 # MODIFIER LETTER SMALL H WITH HOOK + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0266, 0, 0}, 0x02b1 }, // U02B1 # MODIFIER LETTER SMALL H WITH HOOK + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0279, 0, 0}, 0x02b4 }, // U02B4 # MODIFIER LETTER SMALL TURNED R + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0279, 0, 0}, 0x02b4 }, // U02B4 # MODIFIER LETTER SMALL TURNED R + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x027b, 0, 0}, 0x02b5 }, // U02B5 # MODIFIER LETTER SMALL TURNED R WITH HOOK + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x027b, 0, 0}, 0x02b5 }, // U02B5 # MODIFIER LETTER SMALL TURNED R WITH HOOK + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0281, 0, 0}, 0x02b6 }, // U02B6 # MODIFIER LETTER SMALL CAPITAL INVERTED R + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0281, 0, 0}, 0x02b6 }, // U02B6 # MODIFIER LETTER SMALL CAPITAL INVERTED R + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0295, 0, 0}, 0x02e4 }, // U02E4 # MODIFIER LETTER SMALL REVERSED GLOTTAL STOP + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0295, 0, 0}, 0x02e4 }, // U02E4 # MODIFIER LETTER SMALL REVERSED GLOTTAL STOP + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Dead_Circumflex), 0, 0, 0, 0}, 0x005e }, // asciicircum + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Dead_Belowdot), 0x0041, 0, 0, 0}, 0x1eac }, // U1EAC # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Dead_Belowdot), 0x0045, 0, 0, 0}, 0x1ec6 }, // U1EC6 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Dead_Belowdot), 0x004f, 0, 0, 0}, 0x1ed8 }, // U1ED8 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Dead_Belowdot), 0x0061, 0, 0, 0}, 0x1ead }, // U1EAD # LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Dead_Belowdot), 0x0065, 0, 0, 0}, 0x1ec7 }, // U1EC7 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Circumflex), UNITIZE(TQt::Key_Dead_Belowdot), 0x006f, 0, 0, 0}, 0x1ed9 }, // U1ED9 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Tilde), 0x0000, 0, 0, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Tilde), 0x0000, 0, 0, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Tilde), 0x0000, 0, 0, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Tilde), 0x0000, 0, 0, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0020, 0, 0, 0, 0}, 0x007e }, // asciitilde + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0041, 0, 0, 0, 0}, 0x00c3 }, // U00C3 # LATIN CAPITAL LETTER A WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0045, 0, 0, 0, 0}, 0x1ebc }, // U1EBC # LATIN CAPITAL LETTER E WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0049, 0, 0, 0, 0}, 0x0128 }, // U0128 # LATIN CAPITAL LETTER I WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x004e, 0, 0, 0, 0}, 0x00d1 }, // U00D1 # LATIN CAPITAL LETTER N WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0, 0, 0}, 0x00d5 }, // U00D5 # LATIN CAPITAL LETTER O WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0055, 0, 0, 0, 0}, 0x0168 }, // U0168 # LATIN CAPITAL LETTER U WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0056, 0, 0, 0, 0}, 0x1e7c }, // U1E7C # LATIN CAPITAL LETTER V WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0059, 0, 0, 0, 0}, 0x1ef8 }, // U1EF8 # LATIN CAPITAL LETTER Y WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0061, 0, 0, 0, 0}, 0x00e3 }, // U00E3 # LATIN SMALL LETTER A WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0065, 0, 0, 0, 0}, 0x1ebd }, // U1EBD # LATIN SMALL LETTER E WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0069, 0, 0, 0, 0}, 0x0129 }, // U0129 # LATIN SMALL LETTER I WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x006e, 0, 0, 0, 0}, 0x00f1 }, // U00F1 # LATIN SMALL LETTER N WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0, 0, 0}, 0x00f5 }, // U00F5 # LATIN SMALL LETTER O WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0075, 0, 0, 0, 0}, 0x0169 }, // U0169 # LATIN SMALL LETTER U WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0076, 0, 0, 0, 0}, 0x1e7d }, // U1E7D # LATIN SMALL LETTER V WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0079, 0, 0, 0, 0}, 0x1ef9 }, // U1EF9 # LATIN SMALL LETTER Y WITH TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x00c2, 0, 0, 0, 0}, 0x1eaa }, // U1EAA # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x00ca, 0, 0, 0, 0}, 0x1ec4 }, // U1EC4 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x00d4, 0, 0, 0, 0}, 0x1ed6 }, // U1ED6 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x00e2, 0, 0, 0, 0}, 0x1eab }, // U1EAB # LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x00ea, 0, 0, 0, 0}, 0x1ec5 }, // U1EC5 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x00f4, 0, 0, 0, 0}, 0x1ed7 }, // U1ED7 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0102, 0, 0, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0103, 0, 0, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x01A0, 0, 0, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x01A1, 0, 0, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x01AF, 0, 0, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x01B0, 0, 0, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x0391, 0, 0, 0}, 0x1f0e }, // U1F0E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x0397, 0, 0, 0}, 0x1f2e }, // U1F2E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x0399, 0, 0, 0}, 0x1f3e }, // U1F3E # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03a9, 0, 0, 0}, 0x1f6e }, // U1F6E # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03b1, 0, 0, 0}, 0x1f06 }, // U1F06 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03b7, 0, 0, 0}, 0x1f26 }, // U1F26 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03b9, 0, 0, 0}, 0x1f36 }, // U1F36 # GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03c5, 0, 0, 0}, 0x1f56 }, // U1F56 # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03c9, 0, 0, 0}, 0x1f66 }, // U1F66 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x0391, 0, 0, 0}, 0x1f0f }, // U1F0F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x0397, 0, 0, 0}, 0x1f2f }, // U1F2F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x0399, 0, 0, 0}, 0x1f3f }, // U1F3F # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03a5, 0, 0, 0}, 0x1f5f }, // U1F5F # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03a9, 0, 0, 0}, 0x1f6f }, // U1F6F # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03b1, 0, 0, 0}, 0x1f07 }, // U1F07 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03b7, 0, 0, 0}, 0x1f27 }, // U1F27 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03b9, 0, 0, 0}, 0x1f37 }, // U1F37 # GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03c5, 0, 0, 0}, 0x1f57 }, // U1F57 # GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03c9, 0, 0, 0}, 0x1f67 }, // U1F67 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x03b1, 0, 0, 0, 0}, 0x1fb6 }, // U1FB6 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x03b7, 0, 0, 0, 0}, 0x1fc6 }, // U1FC6 # GREEK SMALL LETTER ETA WITH PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x03b9, 0, 0, 0, 0}, 0x1fd6 }, // U1FD6 # GREEK SMALL LETTER IOTA WITH PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x03c5, 0, 0, 0, 0}, 0x1fe6 }, // U1FE6 # GREEK SMALL LETTER UPSILON WITH PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x03c9, 0, 0, 0, 0}, 0x1ff6 }, // U1FF6 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x03ca, 0, 0, 0, 0}, 0x1fd7 }, // U1FD7 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x03cb, 0, 0, 0, 0}, 0x1fe7 }, // U1FE7 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f00, 0, 0, 0, 0}, 0x1f06 }, // U1F06 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f01, 0, 0, 0, 0}, 0x1f07 }, // U1F07 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f08, 0, 0, 0, 0}, 0x1f0e }, // U1F0E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f09, 0, 0, 0, 0}, 0x1f0f }, // U1F0F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f20, 0, 0, 0, 0}, 0x1f26 }, // U1F26 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f21, 0, 0, 0, 0}, 0x1f27 }, // U1F27 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f28, 0, 0, 0, 0}, 0x1f2e }, // U1F2E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f29, 0, 0, 0, 0}, 0x1f2f }, // U1F2F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f30, 0, 0, 0, 0}, 0x1f36 }, // U1F36 # GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f31, 0, 0, 0, 0}, 0x1f37 }, // U1F37 # GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f38, 0, 0, 0, 0}, 0x1f3e }, // U1F3E # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f39, 0, 0, 0, 0}, 0x1f3f }, // U1F3F # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f50, 0, 0, 0, 0}, 0x1f56 }, // U1F56 # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f51, 0, 0, 0, 0}, 0x1f57 }, // U1F57 # GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f59, 0, 0, 0, 0}, 0x1f5f }, // U1F5F # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f60, 0, 0, 0, 0}, 0x1f66 }, // U1F66 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f61, 0, 0, 0, 0}, 0x1f67 }, // U1F67 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f68, 0, 0, 0, 0}, 0x1f6e }, // U1F6E # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), 0x1f69, 0, 0, 0, 0}, 0x1f6f }, // U1F6F # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03b9, 0, 0}, 0x1fd7 }, // U1FD7 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x03c5, 0, 0}, 0x1fe7 }, // U1FE7 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0, 0}, 0x1f0f }, // U1F0F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0, 0}, 0x1f2f }, // U1F2F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0399, 0, 0}, 0x1f3f }, // U1F3F # GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a5, 0, 0}, 0x1f5f }, // U1F5F # GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0, 0}, 0x1f6f }, // U1F6F # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0, 0}, 0x1f07 }, // U1F07 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0, 0}, 0x1f27 }, // U1F27 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b9, 0, 0}, 0x1f37 }, // U1F37 # GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c5, 0, 0}, 0x1f57 }, // U1F57 # GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0, 0}, 0x1f67 }, // U1F67 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0, 0}, 0x1f0e }, // U1F0E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0, 0}, 0x1f2e }, // U1F2E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0399, 0, 0}, 0x1f3e }, // U1F3E # GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0, 0}, 0x1f6e }, // U1F6E # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0, 0}, 0x1f06 }, // U1F06 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0, 0}, 0x1f26 }, // U1F26 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b9, 0, 0}, 0x1f36 }, // U1F36 # GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c5, 0, 0}, 0x1f56 }, // U1F56 # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0, 0}, 0x1f66 }, // U1F66 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0041, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0061, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0041, 0, 0}, 0x1eaa }, // U1EAA # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0045, 0, 0}, 0x1ec4 }, // U1EC4 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004f, 0, 0}, 0x1ed6 }, // U1ED6 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0061, 0, 0}, 0x1eab }, // U1EAB # LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0065, 0, 0}, 0x1ec5 }, // U1EC5 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006f, 0, 0}, 0x1ed7 }, // U1ED7 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0041, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0061, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0, 0}, 0x1eaa }, // U1EAA # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0, 0}, 0x1ec4 }, // U1EC4 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0, 0}, 0x1ed6 }, // U1ED6 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0, 0}, 0x1eab }, // U1EAB # LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0, 0}, 0x1ec5 }, // U1EC5 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0, 0}, 0x1ed7 }, // U1ED7 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Tilde), 0, 0, 0, 0}, 0x007e }, // asciitilde + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0, 0}, 0x1eb4 }, // U1EB4 # LATIN CAPITAL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0, 0}, 0x1eb5 }, // U1EB5 # LATIN SMALL LETTER A WITH BREVE AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0, 0}, 0x1fd7 }, // U1FD7 # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0, 0}, 0x1fe7 }, // U1FE7 # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1ee0 }, // U1EE0 # LATIN CAPITAL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1eee }, // U1EEE # LATIN CAPITAL LETTER U WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1ee1 }, // U1EE1 # LATIN SMALL LETTER O WITH HORN AND TILDE + { {UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1eef }, // U1EEF # LATIN SMALL LETTER U WITH HORN AND TILDE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Macron), 0x0000, 0x004c, 0, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Dead_Macron), 0x0000, 0x004f, 0, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Dead_Macron), 0x0000, 0x0052, 0, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Dead_Macron), 0x0000, 0x006c, 0, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Dead_Macron), 0x0000, 0x006f, 0, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Dead_Macron), 0x0000, 0x0072, 0, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0020, 0, 0, 0, 0}, 0x00af }, // macron + { {UNITIZE(TQt::Key_Dead_Macron), 0x0041, 0, 0, 0, 0}, 0x0100 }, // U0100 # LATIN CAPITAL LETTER A WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0045, 0, 0, 0, 0}, 0x0112 }, // U0112 # LATIN CAPITAL LETTER E WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0047, 0, 0, 0, 0}, 0x1e20 }, // U1E20 # LATIN CAPITAL LETTER G WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0049, 0, 0, 0, 0}, 0x012a }, // U012A # LATIN CAPITAL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x004f, 0, 0, 0, 0}, 0x014c }, // U014C # LATIN CAPITAL LETTER O WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0055, 0, 0, 0, 0}, 0x016a }, // U016A # LATIN CAPITAL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0059, 0, 0, 0, 0}, 0x0232 }, // U0232 # LATIN CAPITAL LETTER Y WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0061, 0, 0, 0, 0}, 0x0101 }, // U0101 # LATIN SMALL LETTER A WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0065, 0, 0, 0, 0}, 0x0113 }, // U0113 # LATIN SMALL LETTER E WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0067, 0, 0, 0, 0}, 0x1e21 }, // U1E21 # LATIN SMALL LETTER G WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0069, 0, 0, 0, 0}, 0x012b }, // U012B # LATIN SMALL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x006f, 0, 0, 0, 0}, 0x014d }, // U014D # LATIN SMALL LETTER O WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0075, 0, 0, 0, 0}, 0x016b }, // U016B # LATIN SMALL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0079, 0, 0, 0, 0}, 0x0233 }, // U0233 # LATIN SMALL LETTER Y WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00c4, 0, 0, 0, 0}, 0x01de }, // U01DE # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00c6, 0, 0, 0, 0}, 0x01e2 }, // U01E2 # LATIN CAPITAL LETTER AE WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00d5, 0, 0, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00d6, 0, 0, 0, 0}, 0x022a }, // U022A # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00dc, 0, 0, 0, 0}, 0x01d5 }, // U01D5 # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00e4, 0, 0, 0, 0}, 0x01df }, // U01DF # LATIN SMALL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00e6, 0, 0, 0, 0}, 0x01e3 }, // U01E3 # LATIN SMALL LETTER AE WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00f5, 0, 0, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00f6, 0, 0, 0, 0}, 0x022b }, // U022B # LATIN SMALL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x00fc, 0, 0, 0, 0}, 0x01d6 }, // U01D6 # LATIN SMALL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x01ea, 0, 0, 0, 0}, 0x01ec }, // U01EC # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x01eb, 0, 0, 0, 0}, 0x01ed }, // U01ED # LATIN SMALL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0226, 0, 0, 0, 0}, 0x01e0 }, // U01E0 # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0227, 0, 0, 0, 0}, 0x01e1 }, // U01E1 # LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x022e, 0, 0, 0, 0}, 0x0230 }, // U0230 # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x022f, 0, 0, 0, 0}, 0x0231 }, // U0231 # LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0391, 0, 0, 0, 0}, 0x1fb9 }, // U1FB9 # GREEK CAPITAL LETTER ALPHA WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0399, 0, 0, 0, 0}, 0x1fd9 }, // U1FD9 # GREEK CAPITAL LETTER IOTA WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x03a5, 0, 0, 0, 0}, 0x1fe9 }, // U1FE9 # GREEK CAPITAL LETTER UPSILON WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x03b1, 0, 0, 0, 0}, 0x1fb1 }, // U1FB1 # GREEK SMALL LETTER ALPHA WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x03b9, 0, 0, 0, 0}, 0x1fd1 }, // U1FD1 # GREEK SMALL LETTER IOTA WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x03c5, 0, 0, 0, 0}, 0x1fe1 }, // U1FE1 # GREEK SMALL LETTER UPSILON WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0418, 0, 0, 0, 0}, 0x04e2 }, // U04E2 # CYRILLIC CAPITAL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0423, 0, 0, 0, 0}, 0x04ee }, // U04EE # CYRILLIC CAPITAL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0438, 0, 0, 0, 0}, 0x04e3 }, // U04E3 # CYRILLIC SMALL LETTER I WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x0443, 0, 0, 0, 0}, 0x04ef }, // U04EF # CYRILLIC SMALL LETTER U WITH MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x1e36, 0, 0, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x1e37, 0, 0, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x1e5a, 0, 0, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), 0x1e5b, 0, 0, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x004c, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0052, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x006c, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0072, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0041, 0, 0}, 0x01de }, // U01DE # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x004f, 0, 0}, 0x022a }, // U022A # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0055, 0, 0}, 0x01d5 }, // U01D5 # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0061, 0, 0}, 0x01df }, // U01DF # LATIN SMALL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x006f, 0, 0}, 0x022b }, // U022B # LATIN SMALL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0075, 0, 0}, 0x01d6 }, // U01D6 # LATIN SMALL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0041, 0, 0}, 0x01e0 }, // U01E0 # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x002e, 0x004f, 0, 0}, 0x0230 }, // U0230 # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x002e, 0x0061, 0, 0}, 0x01e1 }, // U01E1 # LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x002e, 0x006f, 0, 0}, 0x0231 }, // U0231 # LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x003b, 0x004f, 0, 0}, 0x01ec }, // U01EC # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x003b, 0x006f, 0, 0}, 0x01ed }, // U01ED # LATIN SMALL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x004f, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x006f, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0, 0}, 0x022c }, // U022C # LATIN CAPITAL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0, 0}, 0x022d }, // U022D # LATIN SMALL LETTER O WITH TILDE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Macron), 0, 0, 0, 0}, 0x00af }, // macron + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Abovedot), 0x0041, 0, 0, 0}, 0x01e0 }, // U01E0 # LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Abovedot), 0x004f, 0, 0, 0}, 0x0230 }, // U0230 # LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Abovedot), 0x0061, 0, 0, 0}, 0x01e1 }, // U01E1 # LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Abovedot), 0x006f, 0, 0, 0}, 0x0231 }, // U0231 # LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0041, 0, 0, 0}, 0x01de }, // U01DE # LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Diaeresis), 0x004f, 0, 0, 0}, 0x022a }, // U022A # LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0, 0}, 0x01d5 }, // U01D5 # LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0061, 0, 0, 0}, 0x01df }, // U01DF # LATIN SMALL LETTER A WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Diaeresis), 0x006f, 0, 0, 0}, 0x022b }, // U022B # LATIN SMALL LETTER O WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0, 0}, 0x01d6 }, // U01D6 # LATIN SMALL LETTER U WITH DIAERESIS AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Ogonek), 0x004f, 0, 0, 0}, 0x01ec }, // U01EC # LATIN CAPITAL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Ogonek), 0x006f, 0, 0, 0}, 0x01ed }, // U01ED # LATIN SMALL LETTER O WITH OGONEK AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Belowdot), 0x004c, 0, 0, 0}, 0x1e38 }, // U1E38 # LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Belowdot), 0x0052, 0, 0, 0}, 0x1e5c }, // U1E5C # LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Belowdot), 0x006c, 0, 0, 0}, 0x1e39 }, // U1E39 # LATIN SMALL LETTER L WITH DOT BELOW AND MACRON + { {UNITIZE(TQt::Key_Dead_Macron), UNITIZE(TQt::Key_Dead_Belowdot), 0x0072, 0, 0, 0}, 0x1e5d }, // U1E5D # LATIN SMALL LETTER R WITH DOT BELOW AND MACRON +// /* broken */ { {UNITIZE(TQt::Key_Dead_Breve), 0x0000, 0x0041, 0, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Breve), 0x0000, 0x0061, 0, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Breve), 0x0020, 0, 0, 0, 0}, 0x02d8 }, // breve + { {UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0, 0, 0}, 0x0102 }, // U0102 # LATIN CAPITAL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0045, 0, 0, 0, 0}, 0x0114 }, // U0114 # LATIN CAPITAL LETTER E WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0047, 0, 0, 0, 0}, 0x011e }, // U011E # LATIN CAPITAL LETTER G WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0049, 0, 0, 0, 0}, 0x012c }, // U012C # LATIN CAPITAL LETTER I WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x004f, 0, 0, 0, 0}, 0x014e }, // U014E # LATIN CAPITAL LETTER O WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0055, 0, 0, 0, 0}, 0x016c }, // U016C # LATIN CAPITAL LETTER U WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0, 0, 0}, 0x0103 }, // U0103 # LATIN SMALL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0065, 0, 0, 0, 0}, 0x0115 }, // U0115 # LATIN SMALL LETTER E WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0067, 0, 0, 0, 0}, 0x011f }, // U011F # LATIN SMALL LETTER G WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0069, 0, 0, 0, 0}, 0x012d }, // U012D # LATIN SMALL LETTER I WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x006f, 0, 0, 0, 0}, 0x014f }, // U014F # LATIN SMALL LETTER O WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0075, 0, 0, 0, 0}, 0x016d }, // U016D # LATIN SMALL LETTER U WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0228, 0, 0, 0, 0}, 0x1e1c }, // U1E1C # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0229, 0, 0, 0, 0}, 0x1e1d }, // U1E1D # LATIN SMALL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0391, 0, 0, 0, 0}, 0x1fb8 }, // U1FB8 # GREEK CAPITAL LETTER ALPHA WITH VRACHY + { {UNITIZE(TQt::Key_Dead_Breve), 0x0399, 0, 0, 0, 0}, 0x1fd8 }, // U1FD8 # GREEK CAPITAL LETTER IOTA WITH VRACHY + { {UNITIZE(TQt::Key_Dead_Breve), 0x03a5, 0, 0, 0, 0}, 0x1fe8 }, // U1FE8 # GREEK CAPITAL LETTER UPSILON WITH VRACHY + { {UNITIZE(TQt::Key_Dead_Breve), 0x03b1, 0, 0, 0, 0}, 0x1fb0 }, // U1FB0 # GREEK SMALL LETTER ALPHA WITH VRACHY + { {UNITIZE(TQt::Key_Dead_Breve), 0x03b9, 0, 0, 0, 0}, 0x1fd0 }, // U1FD0 # GREEK SMALL LETTER IOTA WITH VRACHY + { {UNITIZE(TQt::Key_Dead_Breve), 0x03c5, 0, 0, 0, 0}, 0x1fe0 }, // U1FE0 # GREEK SMALL LETTER UPSILON WITH VRACHY + { {UNITIZE(TQt::Key_Dead_Breve), 0x0410, 0, 0, 0, 0}, 0x04d0 }, // U04D0 # CYRILLIC CAPITAL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0415, 0, 0, 0, 0}, 0x04d6 }, // U04D6 # CYRILLIC CAPITAL LETTER IE WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0416, 0, 0, 0, 0}, 0x04c1 }, // U04C1 # CYRILLIC CAPITAL LETTER ZHE WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0418, 0, 0, 0, 0}, 0x0419 }, // U0419 # CYRILLIC CAPITAL LETTER SHORT I + { {UNITIZE(TQt::Key_Dead_Breve), 0x0423, 0, 0, 0, 0}, 0x040e }, // U040E # CYRILLIC CAPITAL LETTER SHORT U + { {UNITIZE(TQt::Key_Dead_Breve), 0x0430, 0, 0, 0, 0}, 0x04d1 }, // U04D1 # CYRILLIC SMALL LETTER A WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0435, 0, 0, 0, 0}, 0x04d7 }, // U04D7 # CYRILLIC SMALL LETTER IE WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0436, 0, 0, 0, 0}, 0x04c2 }, // U04C2 # CYRILLIC SMALL LETTER ZHE WITH BREVE + { {UNITIZE(TQt::Key_Dead_Breve), 0x0438, 0, 0, 0, 0}, 0x0439 }, // U0439 # CYRILLIC SMALL LETTER SHORT I + { {UNITIZE(TQt::Key_Dead_Breve), 0x0443, 0, 0, 0, 0}, 0x045e }, // U045E # CYRILLIC SMALL LETTER SHORT U + { {UNITIZE(TQt::Key_Dead_Breve), 0x1ea0, 0, 0, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Breve), 0x1ea1, 0, 0, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Breve), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0041, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Breve), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0061, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Breve), UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0045, 0, 0}, 0x1e1c }, // U1E1C # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Dead_Breve), UNITIZE(TQt::Key_Multi_key), 0x002c, 0x0065, 0, 0}, 0x1e1d }, // U1E1D # LATIN SMALL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Dead_Breve), UNITIZE(TQt::Key_Dead_Breve), 0, 0, 0, 0}, 0x02d8 }, // breve + { {UNITIZE(TQt::Key_Dead_Breve), UNITIZE(TQt::Key_Dead_Cedilla), 0x0045, 0, 0, 0}, 0x1e1c }, // U1E1C # LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Dead_Breve), UNITIZE(TQt::Key_Dead_Cedilla), 0x0065, 0, 0, 0}, 0x1e1d }, // U1E1D # LATIN SMALL LETTER E WITH CEDILLA AND BREVE + { {UNITIZE(TQt::Key_Dead_Breve), UNITIZE(TQt::Key_Dead_Belowdot), 0x0041, 0, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Breve), UNITIZE(TQt::Key_Dead_Belowdot), 0x0061, 0, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0000, 0x0053, 0, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0000, 0x0053, 0, 0, 0}, 0x1e68 }, // U1E68 # LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0000, 0x0073, 0, 0, 0}, 0x1e69 }, // U1E69 # LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0000, 0x0073, 0, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0020, 0, 0, 0, 0}, 0x02d9 }, // abovedot + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0041, 0, 0, 0, 0}, 0x0226 }, // U0226 # LATIN CAPITAL LETTER A WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0042, 0, 0, 0, 0}, 0x1e02 }, // U1E02 # LATIN CAPITAL LETTER B WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0043, 0, 0, 0, 0}, 0x010a }, // U010A # LATIN CAPITAL LETTER C WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0044, 0, 0, 0, 0}, 0x1e0a }, // U1E0A # LATIN CAPITAL LETTER D WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0045, 0, 0, 0, 0}, 0x0116 }, // U0116 # LATIN CAPITAL LETTER E WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0046, 0, 0, 0, 0}, 0x1e1e }, // U1E1E # LATIN CAPITAL LETTER F WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0047, 0, 0, 0, 0}, 0x0120 }, // U0120 # LATIN CAPITAL LETTER G WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0048, 0, 0, 0, 0}, 0x1e22 }, // U1E22 # LATIN CAPITAL LETTER H WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0049, 0, 0, 0, 0}, 0x0130 }, // U0130 # LATIN CAPITAL LETTER I WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x004d, 0, 0, 0, 0}, 0x1e40 }, // U1E40 # LATIN CAPITAL LETTER M WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x004e, 0, 0, 0, 0}, 0x1e44 }, // U1E44 # LATIN CAPITAL LETTER N WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x004f, 0, 0, 0, 0}, 0x022e }, // U022E # LATIN CAPITAL LETTER O WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0050, 0, 0, 0, 0}, 0x1e56 }, // U1E56 # LATIN CAPITAL LETTER P WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0052, 0, 0, 0, 0}, 0x1e58 }, // U1E58 # LATIN CAPITAL LETTER R WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0053, 0, 0, 0, 0}, 0x1e60 }, // U1E60 # LATIN CAPITAL LETTER S WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0054, 0, 0, 0, 0}, 0x1e6a }, // U1E6A # LATIN CAPITAL LETTER T WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0057, 0, 0, 0, 0}, 0x1e86 }, // U1E86 # LATIN CAPITAL LETTER W WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0058, 0, 0, 0, 0}, 0x1e8a }, // U1E8A # LATIN CAPITAL LETTER X WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0059, 0, 0, 0, 0}, 0x1e8e }, // U1E8E # LATIN CAPITAL LETTER Y WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x005a, 0, 0, 0, 0}, 0x017b }, // U017B # LATIN CAPITAL LETTER Z WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0061, 0, 0, 0, 0}, 0x0227 }, // U0227 # LATIN SMALL LETTER A WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0062, 0, 0, 0, 0}, 0x1e03 }, // U1E03 # LATIN SMALL LETTER B WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0063, 0, 0, 0, 0}, 0x010b }, // U010B # LATIN SMALL LETTER C WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0064, 0, 0, 0, 0}, 0x1e0b }, // U1E0B # LATIN SMALL LETTER D WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0065, 0, 0, 0, 0}, 0x0117 }, // U0117 # LATIN SMALL LETTER E WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0066, 0, 0, 0, 0}, 0x1e1f }, // U1E1F # LATIN SMALL LETTER F WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0067, 0, 0, 0, 0}, 0x0121 }, // U0121 # LATIN SMALL LETTER G WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0068, 0, 0, 0, 0}, 0x1e23 }, // U1E23 # LATIN SMALL LETTER H WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0069, 0, 0, 0, 0}, 0x0131 }, // U0131 # LATIN SMALL LETTER DOTLESS I + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x006d, 0, 0, 0, 0}, 0x1e41 }, // U1E41 # LATIN SMALL LETTER M WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x006e, 0, 0, 0, 0}, 0x1e45 }, // U1E45 # LATIN SMALL LETTER N WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x006f, 0, 0, 0, 0}, 0x022f }, // U022F # LATIN SMALL LETTER O WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0070, 0, 0, 0, 0}, 0x1e57 }, // U1E57 # LATIN SMALL LETTER P WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0072, 0, 0, 0, 0}, 0x1e59 }, // U1E59 # LATIN SMALL LETTER R WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0073, 0, 0, 0, 0}, 0x1e61 }, // U1E61 # LATIN SMALL LETTER S WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0074, 0, 0, 0, 0}, 0x1e6b }, // U1E6B # LATIN SMALL LETTER T WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0077, 0, 0, 0, 0}, 0x1e87 }, // U1E87 # LATIN SMALL LETTER W WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0078, 0, 0, 0, 0}, 0x1e8b }, // U1E8B # LATIN SMALL LETTER X WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0079, 0, 0, 0, 0}, 0x1e8f }, // U1E8F # LATIN SMALL LETTER Y WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x007a, 0, 0, 0, 0}, 0x017c }, // U017C # LATIN SMALL LETTER Z WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x015a, 0, 0, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x015b, 0, 0, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0160, 0, 0, 0, 0}, 0x1e66 }, // U1E66 # LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x0161, 0, 0, 0, 0}, 0x1e67 }, // U1E67 # LATIN SMALL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x017f, 0, 0, 0, 0}, 0x1e9b }, // U1E9B # LATIN SMALL LETTER LONG S WITH DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x1e62, 0, 0, 0, 0}, 0x1e68 }, // U1E68 # LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), 0x1e63, 0, 0, 0, 0}, 0x1e69 }, // U1E69 # LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0053, 0, 0}, 0x1e68 }, // U1E68 # LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Multi_key), 0x0021, 0x0073, 0, 0}, 0x1e69 }, // U1E69 # LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0053, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0073, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0053, 0, 0}, 0x1e66 }, // U1E66 # LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Multi_key), 0x0063, 0x0073, 0, 0}, 0x1e67 }, // U1E67 # LATIN SMALL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0053, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0073, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Dead_Acute), 0x0053, 0, 0, 0}, 0x1e64 }, // U1E64 # LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Dead_Acute), 0x0073, 0, 0, 0}, 0x1e65 }, // U1E65 # LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Dead_Abovedot), 0, 0, 0, 0}, 0x02d9 }, // abovedot + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Dead_Caron), 0x0053, 0, 0, 0}, 0x1e66 }, // U1E66 # LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Dead_Caron), 0x0073, 0, 0, 0}, 0x1e67 }, // U1E67 # LATIN SMALL LETTER S WITH CARON AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Dead_Belowdot), 0x0053, 0, 0, 0}, 0x1e68 }, // U1E68 # LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE + { {UNITIZE(TQt::Key_Dead_Abovedot), UNITIZE(TQt::Key_Dead_Belowdot), 0x0073, 0, 0, 0}, 0x1e69 }, // U1E69 # LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0000, 0x004f, 0, 0, 0}, 0x1e4e }, // U1E4E # LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS +// /* broken */ { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0000, 0x006f, 0, 0, 0}, 0x1e4f }, // U1E4F # LATIN SMALL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0020, 0, 0, 0, 0}, 0x005c }, // quotedbl + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0027, 0, 0, 0, 0}, 0x0344 }, // U0344 # COMBINING GREEK DIALYTIKA TONOS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0041, 0, 0, 0, 0}, 0x00c4 }, // U00C4 # LATIN CAPITAL LETTER A WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0045, 0, 0, 0, 0}, 0x00cb }, // U00CB # LATIN CAPITAL LETTER E WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0048, 0, 0, 0, 0}, 0x1e26 }, // U1E26 # LATIN CAPITAL LETTER H WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0049, 0, 0, 0, 0}, 0x00cf }, // U00CF # LATIN CAPITAL LETTER I WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x004f, 0, 0, 0, 0}, 0x00d6 }, // U00D6 # LATIN CAPITAL LETTER O WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0, 0, 0}, 0x00dc }, // U00DC # LATIN CAPITAL LETTER U WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0057, 0, 0, 0, 0}, 0x1e84 }, // U1E84 # LATIN CAPITAL LETTER W WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0058, 0, 0, 0, 0}, 0x1e8c }, // U1E8C # LATIN CAPITAL LETTER X WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0059, 0, 0, 0, 0}, 0x0178 }, // U0178 # LATIN CAPITAL LETTER Y WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0061, 0, 0, 0, 0}, 0x00e4 }, // U00E4 # LATIN SMALL LETTER A WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0065, 0, 0, 0, 0}, 0x00eb }, // U00EB # LATIN SMALL LETTER E WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0068, 0, 0, 0, 0}, 0x1e27 }, // U1E27 # LATIN SMALL LETTER H WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0069, 0, 0, 0, 0}, 0x00ef }, // U00EF # LATIN SMALL LETTER I WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x006f, 0, 0, 0, 0}, 0x00f6 }, // U00F6 # LATIN SMALL LETTER O WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0074, 0, 0, 0, 0}, 0x1e97 }, // U1E97 # LATIN SMALL LETTER T WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0, 0, 0}, 0x00fc }, // U00FC # LATIN SMALL LETTER U WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0077, 0, 0, 0, 0}, 0x1e85 }, // U1E85 # LATIN SMALL LETTER W WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0078, 0, 0, 0, 0}, 0x1e8d }, // U1E8D # LATIN SMALL LETTER X WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0079, 0, 0, 0, 0}, 0x00ff }, // U00FF # LATIN SMALL LETTER Y WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x00b4, 0, 0, 0, 0}, 0x0344 }, // U0344 # COMBINING GREEK DIALYTIKA TONOS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x00d5, 0, 0, 0, 0}, 0x1e4e }, // U1E4E # LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x00f5, 0, 0, 0, 0}, 0x1e4f }, // U1E4F # LATIN SMALL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x016a, 0, 0, 0, 0}, 0x1e7a }, // U1E7A # LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x016b, 0, 0, 0, 0}, 0x1e7b }, // U1E7B # LATIN SMALL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0399, 0, 0, 0, 0}, 0x03aa }, // U03AA # GREEK CAPITAL LETTER IOTA WITH DIALYTIKA + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x03a5, 0, 0, 0, 0}, 0x03ab }, // U03AB # GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x03b9, 0, 0, 0, 0}, 0x03ca }, // U03CA # GREEK SMALL LETTER IOTA WITH DIALYTIKA + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x03c5, 0, 0, 0, 0}, 0x03cb }, // U03CB # GREEK SMALL LETTER UPSILON WITH DIALYTIKA + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0406, 0, 0, 0, 0}, 0x0407 }, // U0407 # CYRILLIC CAPITAL LETTER YI + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0410, 0, 0, 0, 0}, 0x04d2 }, // U04D2 # CYRILLIC CAPITAL LETTER A WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0415, 0, 0, 0, 0}, 0x0401 }, // U0401 # CYRILLIC CAPITAL LETTER IO + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0416, 0, 0, 0, 0}, 0x04dc }, // U04DC # CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0417, 0, 0, 0, 0}, 0x04de }, // U04DE # CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0418, 0, 0, 0, 0}, 0x04e4 }, // U04E4 # CYRILLIC CAPITAL LETTER I WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x041e, 0, 0, 0, 0}, 0x04e6 }, // U04E6 # CYRILLIC CAPITAL LETTER O WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0423, 0, 0, 0, 0}, 0x04f0 }, // U04F0 # CYRILLIC CAPITAL LETTER U WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0427, 0, 0, 0, 0}, 0x04f4 }, // U04F4 # CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x042b, 0, 0, 0, 0}, 0x04f8 }, // U04F8 # CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x042d, 0, 0, 0, 0}, 0x04ec }, // U04EC # CYRILLIC CAPITAL LETTER E WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0430, 0, 0, 0, 0}, 0x04d3 }, // U04D3 # CYRILLIC SMALL LETTER A WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0435, 0, 0, 0, 0}, 0x0451 }, // U0451 # CYRILLIC SMALL LETTER IO + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0436, 0, 0, 0, 0}, 0x04dd }, // U04DD # CYRILLIC SMALL LETTER ZHE WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0437, 0, 0, 0, 0}, 0x04df }, // U04DF # CYRILLIC SMALL LETTER ZE WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0438, 0, 0, 0, 0}, 0x04e5 }, // U04E5 # CYRILLIC SMALL LETTER I WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x043e, 0, 0, 0, 0}, 0x04e7 }, // U04E7 # CYRILLIC SMALL LETTER O WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0443, 0, 0, 0, 0}, 0x04f1 }, // U04F1 # CYRILLIC SMALL LETTER U WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0447, 0, 0, 0, 0}, 0x04f5 }, // U04F5 # CYRILLIC SMALL LETTER CHE WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x044b, 0, 0, 0, 0}, 0x04f9 }, // U04F9 # CYRILLIC SMALL LETTER YERU WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x044d, 0, 0, 0, 0}, 0x04ed }, // U04ED # CYRILLIC SMALL LETTER E WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x0456, 0, 0, 0, 0}, 0x0457 }, // U0457 # CYRILLIC SMALL LETTER YI + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x04d8, 0, 0, 0, 0}, 0x04da }, // U04DA # CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x04d9, 0, 0, 0, 0}, 0x04db }, // U04DB # CYRILLIC SMALL LETTER SCHWA WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x04e8, 0, 0, 0, 0}, 0x04ea }, // U04EA # CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), 0x04e9, 0, 0, 0, 0}, 0x04eb }, // U04EB # CYRILLIC SMALL LETTER BARRED O WITH DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0055, 0, 0}, 0x1e7a }, // U1E7A # LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Multi_key), 0x005f, 0x0075, 0, 0}, 0x1e7b }, // U1E7B # LATIN SMALL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x004f, 0, 0}, 0x1e4e }, // U1E4E # LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x006f, 0, 0}, 0x1e4f }, // U1E4F # LATIN SMALL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0055, 0, 0}, 0x1e7a }, // U1E7A # LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Multi_key), 0x00af, 0x0075, 0, 0}, 0x1e7b }, // U1E7B # LATIN SMALL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Dead_Tilde), 0x004f, 0, 0, 0}, 0x1e4e }, // U1E4E # LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Dead_Tilde), 0x006f, 0, 0, 0}, 0x1e4f }, // U1E4F # LATIN SMALL LETTER O WITH TILDE AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Dead_Macron), 0x0055, 0, 0, 0}, 0x1e7a }, // U1E7A # LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Dead_Macron), 0x0075, 0, 0, 0}, 0x1e7b }, // U1E7B # LATIN SMALL LETTER U WITH MACRON AND DIAERESIS + { {UNITIZE(TQt::Key_Dead_Diaeresis), UNITIZE(TQt::Key_Dead_Diaeresis), 0, 0, 0, 0}, 0x00a8 }, // diaeresis + { {UNITIZE(TQt::Key_Dead_Abovering), 0x0020, 0, 0, 0, 0}, 0x00b0 }, // degree + { {UNITIZE(TQt::Key_Dead_Abovering), 0x0041, 0, 0, 0, 0}, 0x00c5 }, // U00C5 # LATIN CAPITAL LETTER A WITH RING ABOVE + { {UNITIZE(TQt::Key_Dead_Abovering), 0x0055, 0, 0, 0, 0}, 0x016e }, // U016E # LATIN CAPITAL LETTER U WITH RING ABOVE + { {UNITIZE(TQt::Key_Dead_Abovering), 0x0061, 0, 0, 0, 0}, 0x00e5 }, // U00E5 # LATIN SMALL LETTER A WITH RING ABOVE + { {UNITIZE(TQt::Key_Dead_Abovering), 0x0075, 0, 0, 0, 0}, 0x016f }, // U016F # LATIN SMALL LETTER U WITH RING ABOVE + { {UNITIZE(TQt::Key_Dead_Abovering), 0x0077, 0, 0, 0, 0}, 0x1e98 }, // U1E98 # LATIN SMALL LETTER W WITH RING ABOVE + { {UNITIZE(TQt::Key_Dead_Abovering), 0x0079, 0, 0, 0, 0}, 0x1e99 }, // U1E99 # LATIN SMALL LETTER Y WITH RING ABOVE + { {UNITIZE(TQt::Key_Dead_Abovering), UNITIZE(TQt::Key_Dead_Abovering), 0, 0, 0, 0}, 0x00b0 }, // degree + { {UNITIZE(TQt::Key_Dead_Doubleacute), 0x0020, 0, 0, 0, 0}, 0x02dd }, // U2dd + { {UNITIZE(TQt::Key_Dead_Doubleacute), 0x004f, 0, 0, 0, 0}, 0x0150 }, // U0150 # LATIN CAPITAL LETTER O WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Dead_Doubleacute), 0x0055, 0, 0, 0, 0}, 0x0170 }, // U0170 # LATIN CAPITAL LETTER U WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Dead_Doubleacute), 0x006f, 0, 0, 0, 0}, 0x0151 }, // U0151 # LATIN SMALL LETTER O WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Dead_Doubleacute), 0x0075, 0, 0, 0, 0}, 0x0171 }, // U0171 # LATIN SMALL LETTER U WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Dead_Doubleacute), 0x0423, 0, 0, 0, 0}, 0x04f2 }, // U04F2 # CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Dead_Doubleacute), 0x0443, 0, 0, 0, 0}, 0x04f3 }, // U04F3 # CYRILLIC SMALL LETTER U WITH DOUBLE ACUTE + { {UNITIZE(TQt::Key_Dead_Doubleacute), UNITIZE(TQt::Key_Dead_Doubleacute), 0, 0, 0, 0}, 0x02dd }, // U2dd + { {UNITIZE(TQt::Key_Dead_Caron), 0x0020, 0, 0, 0, 0}, 0x02c7 }, // caron + { {UNITIZE(TQt::Key_Dead_Caron), 0x0041, 0, 0, 0, 0}, 0x01cd }, // U01CD # LATIN CAPITAL LETTER A WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0043, 0, 0, 0, 0}, 0x010c }, // U010C # LATIN CAPITAL LETTER C WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0044, 0, 0, 0, 0}, 0x010e }, // U010E # LATIN CAPITAL LETTER D WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0045, 0, 0, 0, 0}, 0x011a }, // U011A # LATIN CAPITAL LETTER E WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0047, 0, 0, 0, 0}, 0x01e6 }, // U01E6 # LATIN CAPITAL LETTER G WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0048, 0, 0, 0, 0}, 0x021e }, // U021E # LATIN CAPITAL LETTER H WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0049, 0, 0, 0, 0}, 0x01cf }, // U01CF # LATIN CAPITAL LETTER I WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x004b, 0, 0, 0, 0}, 0x01e8 }, // U01E8 # LATIN CAPITAL LETTER K WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x004c, 0, 0, 0, 0}, 0x013d }, // U013D # LATIN CAPITAL LETTER L WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x004e, 0, 0, 0, 0}, 0x0147 }, // U0147 # LATIN CAPITAL LETTER N WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x004f, 0, 0, 0, 0}, 0x01d1 }, // U01D1 # LATIN CAPITAL LETTER O WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0052, 0, 0, 0, 0}, 0x0158 }, // U0158 # LATIN CAPITAL LETTER R WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0053, 0, 0, 0, 0}, 0x0160 }, // U0160 # LATIN CAPITAL LETTER S WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0054, 0, 0, 0, 0}, 0x0164 }, // U0164 # LATIN CAPITAL LETTER T WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0055, 0, 0, 0, 0}, 0x01d3 }, // U01D3 # LATIN CAPITAL LETTER U WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x005a, 0, 0, 0, 0}, 0x017d }, // U017D # LATIN CAPITAL LETTER Z WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0061, 0, 0, 0, 0}, 0x01ce }, // U01CE # LATIN SMALL LETTER A WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0063, 0, 0, 0, 0}, 0x010d }, // U010D # LATIN SMALL LETTER C WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0064, 0, 0, 0, 0}, 0x010f }, // U010F # LATIN SMALL LETTER D WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0065, 0, 0, 0, 0}, 0x011b }, // U011B # LATIN SMALL LETTER E WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0067, 0, 0, 0, 0}, 0x01e7 }, // U01E7 # LATIN SMALL LETTER G WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0068, 0, 0, 0, 0}, 0x021f }, // U021F # LATIN SMALL LETTER H WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0069, 0, 0, 0, 0}, 0x01d0 }, // U01D0 # LATIN SMALL LETTER I WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x006a, 0, 0, 0, 0}, 0x01f0 }, // U01F0 # LATIN SMALL LETTER J WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x006b, 0, 0, 0, 0}, 0x01e9 }, // U01E9 # LATIN SMALL LETTER K WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x006c, 0, 0, 0, 0}, 0x013e }, // U013E # LATIN SMALL LETTER L WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x006e, 0, 0, 0, 0}, 0x0148 }, // U0148 # LATIN SMALL LETTER N WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x006f, 0, 0, 0, 0}, 0x01d2 }, // U01D2 # LATIN SMALL LETTER O WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0072, 0, 0, 0, 0}, 0x0159 }, // U0159 # LATIN SMALL LETTER R WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0073, 0, 0, 0, 0}, 0x0161 }, // U0161 # LATIN SMALL LETTER S WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0074, 0, 0, 0, 0}, 0x0165 }, // U0165 # LATIN SMALL LETTER T WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0075, 0, 0, 0, 0}, 0x01d4 }, // U01D4 # LATIN SMALL LETTER U WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x007a, 0, 0, 0, 0}, 0x017e }, // U017E # LATIN SMALL LETTER Z WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x00dc, 0, 0, 0, 0}, 0x01d9 }, // U01D9 # LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x00fc, 0, 0, 0, 0}, 0x01da }, // U01DA # LATIN SMALL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x01b7, 0, 0, 0, 0}, 0x01ee }, // U01EE # LATIN CAPITAL LETTER EZH WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), 0x0292, 0, 0, 0, 0}, 0x01ef }, // U01EF # LATIN SMALL LETTER EZH WITH CARON + { {UNITIZE(TQt::Key_Dead_Caron), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0055, 0, 0}, 0x01d9 }, // U01D9 # LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Dead_Caron), UNITIZE(TQt::Key_Multi_key), 0x0022, 0x0075, 0, 0}, 0x01da }, // U01DA # LATIN SMALL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Dead_Caron), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0055, 0, 0, 0}, 0x01d9 }, // U01D9 # LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Dead_Caron), UNITIZE(TQt::Key_Dead_Diaeresis), 0x0075, 0, 0, 0}, 0x01da }, // U01DA # LATIN SMALL LETTER U WITH DIAERESIS AND CARON + { {UNITIZE(TQt::Key_Dead_Caron), UNITIZE(TQt::Key_Dead_Caron), 0, 0, 0, 0}, 0x02c7 }, // caron + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0020, 0, 0, 0, 0}, 0x00b8 }, // cedilla + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0043, 0, 0, 0, 0}, 0x00c7 }, // U00C7 # LATIN CAPITAL LETTER C WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0044, 0, 0, 0, 0}, 0x1e10 }, // U1E10 # LATIN CAPITAL LETTER D WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0045, 0, 0, 0, 0}, 0x0228 }, // U0228 # LATIN CAPITAL LETTER E WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0047, 0, 0, 0, 0}, 0x0122 }, // U0122 # LATIN CAPITAL LETTER G WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0048, 0, 0, 0, 0}, 0x1e28 }, // U1E28 # LATIN CAPITAL LETTER H WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x004b, 0, 0, 0, 0}, 0x0136 }, // U0136 # LATIN CAPITAL LETTER K WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x004c, 0, 0, 0, 0}, 0x013b }, // U013B # LATIN CAPITAL LETTER L WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x004e, 0, 0, 0, 0}, 0x0145 }, // U0145 # LATIN CAPITAL LETTER N WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0052, 0, 0, 0, 0}, 0x0156 }, // U0156 # LATIN CAPITAL LETTER R WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0053, 0, 0, 0, 0}, 0x015e }, // U015E # LATIN CAPITAL LETTER S WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0054, 0, 0, 0, 0}, 0x0162 }, // U0162 # LATIN CAPITAL LETTER T WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0063, 0, 0, 0, 0}, 0x00e7 }, // U00E7 # LATIN SMALL LETTER C WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0064, 0, 0, 0, 0}, 0x1e11 }, // U1E11 # LATIN SMALL LETTER D WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0065, 0, 0, 0, 0}, 0x0229 }, // U0229 # LATIN SMALL LETTER E WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0067, 0, 0, 0, 0}, 0x0123 }, // U0123 # LATIN SMALL LETTER G WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0068, 0, 0, 0, 0}, 0x1e29 }, // U1E29 # LATIN SMALL LETTER H WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x006b, 0, 0, 0, 0}, 0x0137 }, // U0137 # LATIN SMALL LETTER K WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x006c, 0, 0, 0, 0}, 0x013c }, // U013C # LATIN SMALL LETTER L WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x006e, 0, 0, 0, 0}, 0x0146 }, // U0146 # LATIN SMALL LETTER N WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0072, 0, 0, 0, 0}, 0x0157 }, // U0157 # LATIN SMALL LETTER R WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0073, 0, 0, 0, 0}, 0x015f }, // U015F # LATIN SMALL LETTER S WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), 0x0074, 0, 0, 0, 0}, 0x0163 }, // U0163 # LATIN SMALL LETTER T WITH CEDILLA + { {UNITIZE(TQt::Key_Dead_Cedilla), UNITIZE(TQt::Key_Dead_Cedilla), 0, 0, 0, 0}, 0x00b8 }, // cedilla + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x0041, 0, 0, 0, 0}, 0x0104 }, // U0104 # LATIN CAPITAL LETTER A WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x0045, 0, 0, 0, 0}, 0x0118 }, // U0118 # LATIN CAPITAL LETTER E WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x0049, 0, 0, 0, 0}, 0x012e }, // U012E # LATIN CAPITAL LETTER I WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x004f, 0, 0, 0, 0}, 0x01ea }, // U01EA # LATIN CAPITAL LETTER O WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x0055, 0, 0, 0, 0}, 0x0172 }, // U0172 # LATIN CAPITAL LETTER U WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x0061, 0, 0, 0, 0}, 0x0105 }, // U0105 # LATIN SMALL LETTER A WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x0065, 0, 0, 0, 0}, 0x0119 }, // U0119 # LATIN SMALL LETTER E WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x0069, 0, 0, 0, 0}, 0x012f }, // U012F # LATIN SMALL LETTER I WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x006f, 0, 0, 0, 0}, 0x01eb }, // U01EB # LATIN SMALL LETTER O WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), 0x0075, 0, 0, 0, 0}, 0x0173 }, // U0173 # LATIN SMALL LETTER U WITH OGONEK + { {UNITIZE(TQt::Key_Dead_Ogonek), UNITIZE(TQt::Key_Dead_Ogonek), 0, 0, 0, 0}, 0x02db }, // ogonek +// /* broken */ { {UNITIZE(TQt::Key_Dead_Ogonek), dead_space, 0, 0, 0, 0}, 0x02db }, // ogonek +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x0391, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x0391, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x0397, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x0397, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x03a9, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x03a9, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x03b1, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x03b1, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x03b7, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x03b7, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x03c9, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0313, 0x03c9, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x0391, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x0391, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x0397, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x0397, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x03a9, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x03a9, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x03b1, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x03b1, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x03b7, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x03b7, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x03c9, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x0314, 0x03c9, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x03b1, 0, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x03b1, 0, 0, 0}, 0x1fb2 }, // U1FB2 # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x03b7, 0, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x03b7, 0, 0, 0}, 0x1fc2 }, // U1FC2 # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x03c9, 0, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x03c9, 0, 0, 0}, 0x1ff2 }, // U1FF2 # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f00, 0, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f00, 0, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f01, 0, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f01, 0, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f08, 0, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f08, 0, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f09, 0, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f09, 0, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f20, 0, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f20, 0, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f21, 0, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f21, 0, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f28, 0, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f28, 0, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f29, 0, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f29, 0, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f60, 0, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f60, 0, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f61, 0, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f61, 0, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f68, 0, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f68, 0, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f69, 0, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, 0x1f69, 0, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), 0x0000, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0313, 0x0391, 0, 0, 0}, 0x1f88 }, // U1F88 # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0313, 0x0397, 0, 0, 0}, 0x1f98 }, // U1F98 # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0313, 0x03a9, 0, 0, 0}, 0x1fa8 }, // U1FA8 # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0313, 0x03b1, 0, 0, 0}, 0x1f80 }, // U1F80 # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0313, 0x03b7, 0, 0, 0}, 0x1f90 }, // U1F90 # GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0313, 0x03c9, 0, 0, 0}, 0x1fa0 }, // U1FA0 # GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0314, 0x0391, 0, 0, 0}, 0x1f89 }, // U1F89 # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0314, 0x0397, 0, 0, 0}, 0x1f99 }, // U1F99 # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0314, 0x03a9, 0, 0, 0}, 0x1fa9 }, // U1FA9 # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0314, 0x03b1, 0, 0, 0}, 0x1f81 }, // U1F81 # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0314, 0x03b7, 0, 0, 0}, 0x1f91 }, // U1F91 # GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0314, 0x03c9, 0, 0, 0}, 0x1fa1 }, // U1FA1 # GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0313, 0x0391, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0313, 0x0397, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0313, 0x03a9, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0313, 0x03b1, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0313, 0x03b7, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0313, 0x03c9, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0314, 0x0391, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0314, 0x0397, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0314, 0x03a9, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0314, 0x03b1, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0314, 0x03b7, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x0314, 0x03c9, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x03b1, 0, 0, 0}, 0x1fb7 }, // U1FB7 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x03b7, 0, 0, 0}, 0x1fc7 }, // U1FC7 # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x03c9, 0, 0, 0}, 0x1ff7 }, // U1FF7 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f00, 0, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f01, 0, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f08, 0, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f09, 0, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f20, 0, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f21, 0, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f28, 0, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f29, 0, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f60, 0, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f61, 0, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f68, 0, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, 0x1f69, 0, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0342, UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0391, 0, 0, 0, 0}, 0x1fbc }, // U1FBC # GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x0397, 0, 0, 0, 0}, 0x1fcc }, // U1FCC # GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x03a9, 0, 0, 0, 0}, 0x1ffc }, // U1FFC # GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x03ac, 0, 0, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x03ae, 0, 0, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x03b1, 0, 0, 0, 0}, 0x1fb3 }, // U1FB3 # GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x03b7, 0, 0, 0, 0}, 0x1fc3 }, // U1FC3 # GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x03c9, 0, 0, 0, 0}, 0x1ff3 }, // U1FF3 # GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x03ce, 0, 0, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f00, 0, 0, 0, 0}, 0x1f80 }, // U1F80 # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f01, 0, 0, 0, 0}, 0x1f81 }, // U1F81 # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f02, 0, 0, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f03, 0, 0, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f04, 0, 0, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f05, 0, 0, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f06, 0, 0, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f07, 0, 0, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f08, 0, 0, 0, 0}, 0x1f88 }, // U1F88 # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f09, 0, 0, 0, 0}, 0x1f89 }, // U1F89 # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f0a, 0, 0, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f0b, 0, 0, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f0c, 0, 0, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f0d, 0, 0, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f0e, 0, 0, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f0f, 0, 0, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f20, 0, 0, 0, 0}, 0x1f90 }, // U1F90 # GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f21, 0, 0, 0, 0}, 0x1f91 }, // U1F91 # GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f22, 0, 0, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f23, 0, 0, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f24, 0, 0, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f25, 0, 0, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f26, 0, 0, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f27, 0, 0, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f28, 0, 0, 0, 0}, 0x1f98 }, // U1F98 # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f29, 0, 0, 0, 0}, 0x1f99 }, // U1F99 # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f2a, 0, 0, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f2b, 0, 0, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f2c, 0, 0, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f2d, 0, 0, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f2e, 0, 0, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f2f, 0, 0, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f60, 0, 0, 0, 0}, 0x1fa0 }, // U1FA0 # GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f61, 0, 0, 0, 0}, 0x1fa1 }, // U1FA1 # GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f62, 0, 0, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f63, 0, 0, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f64, 0, 0, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f65, 0, 0, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f66, 0, 0, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f67, 0, 0, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f68, 0, 0, 0, 0}, 0x1fa8 }, // U1FA8 # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f69, 0, 0, 0, 0}, 0x1fa9 }, // U1FA9 # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f6a, 0, 0, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f6b, 0, 0, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f6c, 0, 0, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f6d, 0, 0, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f6e, 0, 0, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f6f, 0, 0, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f70, 0, 0, 0, 0}, 0x1fb2 }, // U1FB2 # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f74, 0, 0, 0, 0}, 0x1fc2 }, // U1FC2 # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1f7c, 0, 0, 0, 0}, 0x1ff2 }, // U1FF2 # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1fb6, 0, 0, 0, 0}, 0x1fb7 }, // U1FB7 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1fc6, 0, 0, 0, 0}, 0x1fc7 }, // U1FC7 # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), 0x1ff6, 0, 0, 0, 0}, 0x1ff7 }, // U1FF7 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0028, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0029, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0313, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x0314, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03b1, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03b7, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x03c9, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f00, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f01, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f08, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f09, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f20, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f21, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f28, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f29, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f60, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f61, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f68, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0027, 0x1f69, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0, 0}, 0x1f89 }, // U1F89 # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0, 0}, 0x1f99 }, // U1F99 # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0, 0}, 0x1fa9 }, // U1FA9 # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0, 0}, 0x1f81 }, // U1F81 # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0, 0}, 0x1f91 }, // U1F91 # GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0, 0}, 0x1fa1 }, // U1FA1 # GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0, 0}, 0x1f88 }, // U1F88 # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0, 0}, 0x1f98 }, // U1F98 # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0, 0}, 0x1fa8 }, // U1FA8 # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0, 0}, 0x1f80 }, // U1F80 # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0, 0}, 0x1f90 }, // U1F90 # GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0, 0}, 0x1fa0 }, // U1FA0 # GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0028, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0029, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0313, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x0314, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03b1, 0, 0}, 0x1fb2 }, // U1FB2 # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03b7, 0, 0}, 0x1fc2 }, // U1FC2 # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x03c9, 0, 0}, 0x1ff2 }, // U1FF2 # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f00, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f01, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f08, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f09, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f20, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f21, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f28, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f29, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f60, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f61, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f68, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x0060, 0x1f69, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0028, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0029, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0313, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x0314, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03b1, 0, 0}, 0x1fb7 }, // U1FB7 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03b7, 0, 0}, 0x1fc7 }, // U1FC7 # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x03c9, 0, 0}, 0x1ff7 }, // U1FF7 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f00, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f01, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f08, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f09, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f20, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f21, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f28, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f29, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f60, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f61, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f68, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x007e, 0x1f69, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0028, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0029, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0313, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x0314, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03b1, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03b7, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x03c9, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f00, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f01, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f08, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f09, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f20, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f21, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f28, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f29, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f60, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f61, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f68, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Multi_key), 0x00b4, 0x1f69, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x0391, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x0397, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03a9, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03b1, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03b7, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0313, 0x03c9, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x0391, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x0397, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03a9, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03b1, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03b7, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x0314, 0x03c9, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x03b1, 0, 0, 0}, 0x1fb2 }, // U1FB2 # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x03b7, 0, 0, 0}, 0x1fc2 }, // U1FC2 # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x03c9, 0, 0, 0}, 0x1ff2 }, // U1FF2 # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f00, 0, 0, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f01, 0, 0, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f08, 0, 0, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f09, 0, 0, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f20, 0, 0, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f21, 0, 0, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f28, 0, 0, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f29, 0, 0, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f60, 0, 0, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f61, 0, 0, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f68, 0, 0, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), 0x1f69, 0, 0, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0}, 0x1f8b }, // U1F8B # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0}, 0x1f9b }, // U1F9B # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0}, 0x1fab }, // U1FAB # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0}, 0x1f83 }, // U1F83 # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0}, 0x1f93 }, // U1F93 # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0}, 0x1fa3 }, // U1FA3 # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0}, 0x1f8a }, // U1F8A # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0}, 0x1f9a }, // U1F9A # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0}, 0x1faa }, // U1FAA # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0}, 0x1f82 }, // U1F82 # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0}, 0x1f92 }, // U1F92 # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Grave), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0}, 0x1fa2 }, // U1FA2 # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x0391, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x0397, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03a9, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03b1, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03b7, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0313, 0x03c9, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x0391, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x0397, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03a9, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03b1, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03b7, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x0314, 0x03c9, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x03b1, 0, 0, 0}, 0x1fb4 }, // U1FB4 # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x03b7, 0, 0, 0}, 0x1fc4 }, // U1FC4 # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x03c9, 0, 0, 0}, 0x1ff4 }, // U1FF4 # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f00, 0, 0, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f01, 0, 0, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f08, 0, 0, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f09, 0, 0, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f20, 0, 0, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f21, 0, 0, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f28, 0, 0, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f29, 0, 0, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f60, 0, 0, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f61, 0, 0, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f68, 0, 0, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), 0x1f69, 0, 0, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0}, 0x1f8d }, // U1F8D # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0}, 0x1f9d }, // U1F9D # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0}, 0x1fad }, // U1FAD # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0}, 0x1f85 }, // U1F85 # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0}, 0x1f95 }, // U1F95 # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0}, 0x1fa5 }, // U1FA5 # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0}, 0x1f8c }, // U1F8C # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0}, 0x1f9c }, // U1F9C # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0}, 0x1fac }, // U1FAC # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0}, 0x1f84 }, // U1F84 # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0}, 0x1f94 }, // U1F94 # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Acute), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0}, 0x1fa4 }, // U1FA4 # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x0391, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x0397, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03a9, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03b1, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03b7, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0313, 0x03c9, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x0391, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x0397, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03a9, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03b1, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03b7, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x0314, 0x03c9, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x03b1, 0, 0, 0}, 0x1fb7 }, // U1FB7 # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x03b7, 0, 0, 0}, 0x1fc7 }, // U1FC7 # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x03c9, 0, 0, 0}, 0x1ff7 }, // U1FF7 # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f00, 0, 0, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f01, 0, 0, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f08, 0, 0, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f09, 0, 0, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f20, 0, 0, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f21, 0, 0, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f28, 0, 0, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f29, 0, 0, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f60, 0, 0, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f61, 0, 0, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f68, 0, 0, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), 0x1f69, 0, 0, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0391, 0}, 0x1f8f }, // U1F8F # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x0397, 0}, 0x1f9f }, // U1F9F # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03a9, 0}, 0x1faf }, // U1FAF # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b1, 0}, 0x1f87 }, // U1F87 # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03b7, 0}, 0x1f97 }, // U1F97 # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0028, 0x03c9, 0}, 0x1fa7 }, // U1FA7 # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0391, 0}, 0x1f8e }, // U1F8E # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x0397, 0}, 0x1f9e }, // U1F9E # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03a9, 0}, 0x1fae }, // U1FAE # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b1, 0}, 0x1f86 }, // U1F86 # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03b7, 0}, 0x1f96 }, // U1F96 # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Tilde), UNITIZE(TQt::Key_Multi_key), 0x0029, 0x03c9, 0}, 0x1fa6 }, // U1FA6 # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI + { {UNITIZE(TQt::Key_Dead_Iota), UNITIZE(TQt::Key_Dead_Iota), 0, 0, 0, 0}, 0x037a }, // U37a +// /* broken */ { {UNITIZE(TQt::Key_Dead_Iota), dead_space, 0, 0, 0, 0}, 0x037a }, // U37a + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3046, 0, 0, 0, 0}, 0x3094 }, // U3094 # HIRAGANA LETTER VU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x304b, 0, 0, 0, 0}, 0x304c }, // U304C # HIRAGANA LETTER GA + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x304d, 0, 0, 0, 0}, 0x304e }, // U304E # HIRAGANA LETTER GI + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x304f, 0, 0, 0, 0}, 0x3050 }, // U3050 # HIRAGANA LETTER GU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3051, 0, 0, 0, 0}, 0x3052 }, // U3052 # HIRAGANA LETTER GE + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3053, 0, 0, 0, 0}, 0x3054 }, // U3054 # HIRAGANA LETTER GO + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3055, 0, 0, 0, 0}, 0x3056 }, // U3056 # HIRAGANA LETTER ZA + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3057, 0, 0, 0, 0}, 0x3058 }, // U3058 # HIRAGANA LETTER ZI + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3059, 0, 0, 0, 0}, 0x305a }, // U305A # HIRAGANA LETTER ZU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x305b, 0, 0, 0, 0}, 0x305c }, // U305C # HIRAGANA LETTER ZE + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x305d, 0, 0, 0, 0}, 0x305e }, // U305E # HIRAGANA LETTER ZO + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x305f, 0, 0, 0, 0}, 0x3060 }, // U3060 # HIRAGANA LETTER DA + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3061, 0, 0, 0, 0}, 0x3062 }, // U3062 # HIRAGANA LETTER DI + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3064, 0, 0, 0, 0}, 0x3065 }, // U3065 # HIRAGANA LETTER DU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3066, 0, 0, 0, 0}, 0x3067 }, // U3067 # HIRAGANA LETTER DE + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3068, 0, 0, 0, 0}, 0x3069 }, // U3069 # HIRAGANA LETTER DO + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x306f, 0, 0, 0, 0}, 0x3070 }, // U3070 # HIRAGANA LETTER BA + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3072, 0, 0, 0, 0}, 0x3073 }, // U3073 # HIRAGANA LETTER BI + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3075, 0, 0, 0, 0}, 0x3076 }, // U3076 # HIRAGANA LETTER BU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x3078, 0, 0, 0, 0}, 0x3079 }, // U3079 # HIRAGANA LETTER BE + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x307b, 0, 0, 0, 0}, 0x307c }, // U307C # HIRAGANA LETTER BO + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x309d, 0, 0, 0, 0}, 0x309e }, // U309E # HIRAGANA VOICED ITERATION MARK + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30a6, 0, 0, 0, 0}, 0x30f4 }, // U30F4 # KATAKANA LETTER VU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30ab, 0, 0, 0, 0}, 0x30ac }, // U30AC # KATAKANA LETTER GA + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30ad, 0, 0, 0, 0}, 0x30ae }, // U30AE # KATAKANA LETTER GI + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30af, 0, 0, 0, 0}, 0x30b0 }, // U30B0 # KATAKANA LETTER GU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30b1, 0, 0, 0, 0}, 0x30b2 }, // U30B2 # KATAKANA LETTER GE + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30b3, 0, 0, 0, 0}, 0x30b4 }, // U30B4 # KATAKANA LETTER GO + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30b5, 0, 0, 0, 0}, 0x30b6 }, // U30B6 # KATAKANA LETTER ZA + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30b7, 0, 0, 0, 0}, 0x30b8 }, // U30B8 # KATAKANA LETTER ZI + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30b9, 0, 0, 0, 0}, 0x30ba }, // U30BA # KATAKANA LETTER ZU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30bb, 0, 0, 0, 0}, 0x30bc }, // U30BC # KATAKANA LETTER ZE + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30bd, 0, 0, 0, 0}, 0x30be }, // U30BE # KATAKANA LETTER ZO + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30bf, 0, 0, 0, 0}, 0x30c0 }, // U30C0 # KATAKANA LETTER DA + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30c1, 0, 0, 0, 0}, 0x30c2 }, // U30C2 # KATAKANA LETTER DI + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30c4, 0, 0, 0, 0}, 0x30c5 }, // U30C5 # KATAKANA LETTER DU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30c6, 0, 0, 0, 0}, 0x30c7 }, // U30C7 # KATAKANA LETTER DE + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30c8, 0, 0, 0, 0}, 0x30c9 }, // U30C9 # KATAKANA LETTER DO + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30cf, 0, 0, 0, 0}, 0x30d0 }, // U30D0 # KATAKANA LETTER BA + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30d2, 0, 0, 0, 0}, 0x30d3 }, // U30D3 # KATAKANA LETTER BI + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30d5, 0, 0, 0, 0}, 0x30d6 }, // U30D6 # KATAKANA LETTER BU + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30d8, 0, 0, 0, 0}, 0x30d9 }, // U30D9 # KATAKANA LETTER BE + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30db, 0, 0, 0, 0}, 0x30dc }, // U30DC # KATAKANA LETTER BO + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30ef, 0, 0, 0, 0}, 0x30f7 }, // U30F7 # KATAKANA LETTER VA + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30f0, 0, 0, 0, 0}, 0x30f8 }, // U30F8 # KATAKANA LETTER VI + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30f1, 0, 0, 0, 0}, 0x30f9 }, // U30F9 # KATAKANA LETTER VE + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30f2, 0, 0, 0, 0}, 0x30fa }, // U30FA # KATAKANA LETTER VO + { {UNITIZE(TQt::Key_Dead_Voiced_Sound), 0x30fd, 0, 0, 0, 0}, 0x30fe }, // U30FE # KATAKANA VOICED ITERATION MARK + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x306f, 0, 0, 0, 0}, 0x3071 }, // U3071 # HIRAGANA LETTER PA + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x3072, 0, 0, 0, 0}, 0x3074 }, // U3074 # HIRAGANA LETTER PI + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x3075, 0, 0, 0, 0}, 0x3077 }, // U3077 # HIRAGANA LETTER PU + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x3078, 0, 0, 0, 0}, 0x307a }, // U307A # HIRAGANA LETTER PE + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x307b, 0, 0, 0, 0}, 0x307d }, // U307D # HIRAGANA LETTER PO + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x30cf, 0, 0, 0, 0}, 0x30d1 }, // U30D1 # KATAKANA LETTER PA + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x30d2, 0, 0, 0, 0}, 0x30d4 }, // U30D4 # KATAKANA LETTER PI + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x30d5, 0, 0, 0, 0}, 0x30d7 }, // U30D7 # KATAKANA LETTER PU + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x30d8, 0, 0, 0, 0}, 0x30da }, // U30DA # KATAKANA LETTER PE + { {UNITIZE(TQt::Key_Dead_Semivoiced_Sound), 0x30db, 0, 0, 0, 0}, 0x30dd }, // U30DD # KATAKANA LETTER PO +// /* broken */ { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0000, 0, 0, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0000, 0, 0, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0000, 0, 0, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0000, 0, 0, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0041, 0, 0, 0, 0}, 0x1ea0 }, // U1EA0 # LATIN CAPITAL LETTER A WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0042, 0, 0, 0, 0}, 0x1e04 }, // U1E04 # LATIN CAPITAL LETTER B WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0044, 0, 0, 0, 0}, 0x1e0c }, // U1E0C # LATIN CAPITAL LETTER D WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0045, 0, 0, 0, 0}, 0x1eb8 }, // U1EB8 # LATIN CAPITAL LETTER E WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0048, 0, 0, 0, 0}, 0x1e24 }, // U1E24 # LATIN CAPITAL LETTER H WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0049, 0, 0, 0, 0}, 0x1eca }, // U1ECA # LATIN CAPITAL LETTER I WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x004b, 0, 0, 0, 0}, 0x1e32 }, // U1E32 # LATIN CAPITAL LETTER K WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x004c, 0, 0, 0, 0}, 0x1e36 }, // U1E36 # LATIN CAPITAL LETTER L WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x004d, 0, 0, 0, 0}, 0x1e42 }, // U1E42 # LATIN CAPITAL LETTER M WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x004e, 0, 0, 0, 0}, 0x1e46 }, // U1E46 # LATIN CAPITAL LETTER N WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x004f, 0, 0, 0, 0}, 0x1ecc }, // U1ECC # LATIN CAPITAL LETTER O WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0052, 0, 0, 0, 0}, 0x1e5a }, // U1E5A # LATIN CAPITAL LETTER R WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0053, 0, 0, 0, 0}, 0x1e62 }, // U1E62 # LATIN CAPITAL LETTER S WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0054, 0, 0, 0, 0}, 0x1e6c }, // U1E6C # LATIN CAPITAL LETTER T WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0055, 0, 0, 0, 0}, 0x1ee4 }, // U1EE4 # LATIN CAPITAL LETTER U WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0056, 0, 0, 0, 0}, 0x1e7e }, // U1E7E # LATIN CAPITAL LETTER V WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0057, 0, 0, 0, 0}, 0x1e88 }, // U1E88 # LATIN CAPITAL LETTER W WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0059, 0, 0, 0, 0}, 0x1ef4 }, // U1EF4 # LATIN CAPITAL LETTER Y WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x005a, 0, 0, 0, 0}, 0x1e92 }, // U1E92 # LATIN CAPITAL LETTER Z WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0061, 0, 0, 0, 0}, 0x1ea1 }, // U1EA1 # LATIN SMALL LETTER A WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0062, 0, 0, 0, 0}, 0x1e05 }, // U1E05 # LATIN SMALL LETTER B WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0064, 0, 0, 0, 0}, 0x1e0d }, // U1E0D # LATIN SMALL LETTER D WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0065, 0, 0, 0, 0}, 0x1eb9 }, // U1EB9 # LATIN SMALL LETTER E WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0068, 0, 0, 0, 0}, 0x1e25 }, // U1E25 # LATIN SMALL LETTER H WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0069, 0, 0, 0, 0}, 0x1ecb }, // U1ECB # LATIN SMALL LETTER I WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x006b, 0, 0, 0, 0}, 0x1e33 }, // U1E33 # LATIN SMALL LETTER K WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x006c, 0, 0, 0, 0}, 0x1e37 }, // U1E37 # LATIN SMALL LETTER L WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x006d, 0, 0, 0, 0}, 0x1e43 }, // U1E43 # LATIN SMALL LETTER M WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x006e, 0, 0, 0, 0}, 0x1e47 }, // U1E47 # LATIN SMALL LETTER N WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x006f, 0, 0, 0, 0}, 0x1ecd }, // U1ECD # LATIN SMALL LETTER O WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0072, 0, 0, 0, 0}, 0x1e5b }, // U1E5B # LATIN SMALL LETTER R WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0073, 0, 0, 0, 0}, 0x1e63 }, // U1E63 # LATIN SMALL LETTER S WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0074, 0, 0, 0, 0}, 0x1e6d }, // U1E6D # LATIN SMALL LETTER T WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0075, 0, 0, 0, 0}, 0x1ee5 }, // U1EE5 # LATIN SMALL LETTER U WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0076, 0, 0, 0, 0}, 0x1e7f }, // U1E7F # LATIN SMALL LETTER V WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0077, 0, 0, 0, 0}, 0x1e89 }, // U1E89 # LATIN SMALL LETTER W WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0079, 0, 0, 0, 0}, 0x1ef5 }, // U1EF5 # LATIN SMALL LETTER Y WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x007a, 0, 0, 0, 0}, 0x1e93 }, // U1E93 # LATIN SMALL LETTER Z WITH DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x00c2, 0, 0, 0, 0}, 0x1eac }, // U1EAC # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x00ca, 0, 0, 0, 0}, 0x1ec6 }, // U1EC6 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x00d4, 0, 0, 0, 0}, 0x1ed8 }, // U1ED8 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x00e2, 0, 0, 0, 0}, 0x1ead }, // U1EAD # LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x00ea, 0, 0, 0, 0}, 0x1ec7 }, // U1EC7 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x00f4, 0, 0, 0, 0}, 0x1ed9 }, // U1ED9 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0102, 0, 0, 0, 0}, 0x1eb6 }, // U1EB6 # LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x0103, 0, 0, 0, 0}, 0x1eb7 }, // U1EB7 # LATIN SMALL LETTER A WITH BREVE AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x01A0, 0, 0, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x01A1, 0, 0, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x01AF, 0, 0, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), 0x01B0, 0, 0, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1ee2 }, // U1EE2 # LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1ef0 }, // U1EF0 # LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1ee3 }, // U1EE3 # LATIN SMALL LETTER O WITH HORN AND DOT BELOW + { {UNITIZE(TQt::Key_Dead_Belowdot), UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1ef1 }, // U1EF1 # LATIN SMALL LETTER U WITH HORN AND DOT BELOW +// /* broken */ { {UNITIZE(TQt::Key_Dead_Hook), 0x0000, 0, 0, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Hook), 0x0000, 0, 0, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Hook), 0x0000, 0, 0, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE +// /* broken */ { {UNITIZE(TQt::Key_Dead_Hook), 0x0000, 0, 0, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0041, 0, 0, 0, 0}, 0x1ea2 }, // U1EA2 # LATIN CAPITAL LETTER A WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0045, 0, 0, 0, 0}, 0x1eba }, // U1EBA # LATIN CAPITAL LETTER E WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0049, 0, 0, 0, 0}, 0x1ec8 }, // U1EC8 # LATIN CAPITAL LETTER I WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x004f, 0, 0, 0, 0}, 0x1ece }, // U1ECE # LATIN CAPITAL LETTER O WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0055, 0, 0, 0, 0}, 0x1ee6 }, // U1EE6 # LATIN CAPITAL LETTER U WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0059, 0, 0, 0, 0}, 0x1ef6 }, // U1EF6 # LATIN CAPITAL LETTER Y WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0061, 0, 0, 0, 0}, 0x1ea3 }, // U1EA3 # LATIN SMALL LETTER A WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0065, 0, 0, 0, 0}, 0x1ebb }, // U1EBB # LATIN SMALL LETTER E WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0069, 0, 0, 0, 0}, 0x1ec9 }, // U1EC9 # LATIN SMALL LETTER I WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x006f, 0, 0, 0, 0}, 0x1ecf }, // U1ECF # LATIN SMALL LETTER O WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0075, 0, 0, 0, 0}, 0x1ee7 }, // U1EE7 # LATIN SMALL LETTER U WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0079, 0, 0, 0, 0}, 0x1ef7 }, // U1EF7 # LATIN SMALL LETTER Y WITH HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x00c2, 0, 0, 0, 0}, 0x1ea8 }, // U1EA8 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x00ca, 0, 0, 0, 0}, 0x1ec2 }, // U1EC2 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x00d4, 0, 0, 0, 0}, 0x1ed4 }, // U1ED4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x00e2, 0, 0, 0, 0}, 0x1ea9 }, // U1EA9 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x00ea, 0, 0, 0, 0}, 0x1ec3 }, // U1EC3 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x00f4, 0, 0, 0, 0}, 0x1ed5 }, // U1ED5 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0102, 0, 0, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x0103, 0, 0, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x01A0, 0, 0, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x01A1, 0, 0, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x01AF, 0, 0, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), 0x01B0, 0, 0, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x004f, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0055, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x006f, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x002b, 0x0075, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0041, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x0055, 0x0061, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0041, 0, 0}, 0x1ea8 }, // U1EA8 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0045, 0, 0}, 0x1ec2 }, // U1EC2 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x004f, 0, 0}, 0x1ed4 }, // U1ED4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0061, 0, 0}, 0x1ea9 }, // U1EA9 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x0065, 0, 0}, 0x1ec3 }, // U1EC3 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x005e, 0x006f, 0, 0}, 0x1ed5 }, // U1ED5 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0041, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Multi_key), 0x0062, 0x0061, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Circumflex), 0x0041, 0, 0, 0}, 0x1ea8 }, // U1EA8 # LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Circumflex), 0x0045, 0, 0, 0}, 0x1ec2 }, // U1EC2 # LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Circumflex), 0x004f, 0, 0, 0}, 0x1ed4 }, // U1ED4 # LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Circumflex), 0x0061, 0, 0, 0}, 0x1ea9 }, // U1EA9 # LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Circumflex), 0x0065, 0, 0, 0}, 0x1ec3 }, // U1EC3 # LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Circumflex), 0x006f, 0, 0, 0}, 0x1ed5 }, // U1ED5 # LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Breve), 0x0041, 0, 0, 0}, 0x1eb2 }, // U1EB2 # LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Breve), 0x0061, 0, 0, 0}, 0x1eb3 }, // U1EB3 # LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0}, 0x1ede }, // U1EDE # LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0}, 0x1eec }, // U1EEC # LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0}, 0x1edf }, // U1EDF # LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Hook), UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0}, 0x1eed }, // U1EED # LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE + { {UNITIZE(TQt::Key_Dead_Horn), 0x004f, 0, 0, 0, 0}, 0x01a0 }, // U01A0 # LATIN CAPITAL LETTER O WITH HORN + { {UNITIZE(TQt::Key_Dead_Horn), 0x0055, 0, 0, 0, 0}, 0x01af }, // U01AF # LATIN CAPITAL LETTER U WITH HORN + { {UNITIZE(TQt::Key_Dead_Horn), 0x006f, 0, 0, 0, 0}, 0x01a1 }, // U01A1 # LATIN SMALL LETTER O WITH HORN + { {UNITIZE(TQt::Key_Dead_Horn), 0x0075, 0, 0, 0, 0}, 0x01b0 } // U01B0 # LATIN SMALL LETTER U WITH HORN +}; + +const TQComposeTable TQSimpleInputContext::defaultComposeTable = { + defaultTable, + ( sizeof(defaultTable) / sizeof(TQComposeTableElement) ) +}; diff --git a/tqtinterface/qt4/plugins/src/inputmethods/simple/simple.pro b/tqtinterface/qt4/plugins/src/inputmethods/simple/simple.pro new file mode 100644 index 0000000..f60489e --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/simple/simple.pro @@ -0,0 +1,15 @@ +TEMPLATE = lib +TARGET = qsimple +DESTDIR = ../../../inputmethods + +INCLUDEPATH += . +CONFIG += qt warn_on debug plugin +target.path += $$plugins.path/inputmethods +INSTALLS += target + +# Input +HEADERS += qsimpleinputcontext.h \ + qsimpleinputcontextplugin.h +SOURCES += qsimpleinputcontext.cpp \ + qsimpleinputcontextplugin.cpp \ + composetable.cpp diff --git a/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp b/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp new file mode 100644 index 0000000..d717d74 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontext.cpp @@ -0,0 +1,285 @@ +/**************************************************************************** +** $Id$ +** +** Implementation of TQSimpleInputContext class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#include "tqsimpleinputcontext.h" + +#include +#include +#include +#include + +static const int ignoreKeys[] = { + TQt::Key_Shift, + TQt::Key_Control, + TQt::Key_Meta, + TQt::Key_Alt, + TQt::Key_CapsLock, + TQt::Key_Super_L, + TQt::Key_Super_R, + TQt::Key_Hyper_L, + TQt::Key_Hyper_R, + TQt::Key_Mode_switch +}; + +static const int composingKeys[] = { + TQt::Key_Multi_key, + TQt::Key_Dead_Grave, + TQt::Key_Dead_Acute, + TQt::Key_Dead_Circumflex, + TQt::Key_Dead_Tilde, + TQt::Key_Dead_Macron, + TQt::Key_Dead_Breve, + TQt::Key_Dead_Abovedot, + TQt::Key_Dead_Diaeresis, + TQt::Key_Dead_Abovering, + TQt::Key_Dead_Doubleacute, + TQt::Key_Dead_Caron, + TQt::Key_Dead_Cedilla, + TQt::Key_Dead_Ogonek, + TQt::Key_Dead_Iota, + TQt::Key_Dead_Voiced_Sound, + TQt::Key_Dead_Semivoiced_Sound, + TQt::Key_Dead_Belowdot, + TQt::Key_Dead_Hook, + TQt::Key_Dead_Horn +}; + +class Cmp +{ +public: + bool operator () (const TQComposeTableElement &lhs, const TQComposeTableElement &rhs) const { + for ( size_t i=0; i < TQT_KEYSEQUENCE_MAX_LEN; i++ ) { + if ( lhs.keys[i] < rhs.keys[i] ) return TRUE; + else + if ( lhs.keys[i] > rhs.keys[i] ) return FALSE; + } + return FALSE; + } + + bool operator () (const TQComposeTableElement &lhs, const uint rhs[TQT_KEYSEQUENCE_MAX_LEN]) const { + for ( size_t i=0; i < TQT_KEYSEQUENCE_MAX_LEN; i++ ) { + if ( lhs.keys[i] < rhs[i] ) return TRUE; + else + if ( lhs.keys[i] > rhs[i] ) return FALSE; + } + return FALSE; + } +}; + +TQSimpleInputContext::TQSimpleInputContext() + : TQInputContext() +{ + clearComposeBuffer(); +} + +TQSimpleInputContext::~TQSimpleInputContext() +{ + clearComposeBuffer(); +} + +bool TQSimpleInputContext::filterEvent( const TQEvent *event ) +{ + if ( event->type() != TQEvent::KeyPress ) + return FALSE; + + TQKeyEvent *keyevent = (TQKeyEvent *)event; + int keyval = keyevent->key(); + int val = 0; + + if ( isIgnoreKeys( keyval ) ) + return FALSE; + + if ( isComposingKeys( keyval ) ) { + // If composing keys are pressed, use keyval directly + val = UNITIZE( keyval ); + } else { + TQString text = keyevent->text(); + if ( text.isEmpty() ) + return FALSE; + + // If not composing keys are pressed, use the character's tqunicode value + // NOTE : The contents of TQKeyEvent::text() is restricted to + // only one character. See description of + // TQInputContext::filterEvent() about key compression. + val = text[0].tqunicode(); + // qDebug( "str = %s", (const char*)keyevent->text().local8Bit() ); + } + + // Store value + int nCompose = 0; + while ( composeBuffer[nCompose] != 0 && nCompose < TQT_KEYSEQUENCE_MAX_LEN ) + nCompose++; + + if ( nCompose == TQT_KEYSEQUENCE_MAX_LEN ) { + clearComposeBuffer(); + nCompose = 0; + } + + composeBuffer[nCompose] = val; + + // check sequence + if( checkComposeTable( composeBuffer, &defaultComposeTable ) ) + return TRUE; + + return FALSE; +} + +void TQSimpleInputContext::setFocus() +{ + //qDebug( "TQSimpleInputContext: %p->setFocus(), tqfocusWidget()=%p", + //this, tqfocusWidget() ); +} + +void TQSimpleInputContext::unsetFocus() +{ + //qDebug( "TQSimpleInputContext: %p->unsetFocus(), tqfocusWidget()=%p", + //this, tqfocusWidget() ); + reset(); +} + +void TQSimpleInputContext::setMicroFocus( int x, int y, int w, int h, TQFont *f ) +{ +} + +void TQSimpleInputContext::mouseHandler( int x, TQEvent::Type type, + TQt::ButtonState button, + TQt::ButtonState state ) +{ + switch ( type ) { + case TQEvent::MouseButtonPress: + case TQEvent::MouseButtonRelease: + case TQEvent::MouseButtonDblClick: + case TQEvent::MouseMove: + // qDebug( "TQSimpleInputContext::mouseHandler: " + // "x=%d, type=%d, button=%d, state=%d", x, type, button, state ); + break; + default: + break; + } +} + + +void TQSimpleInputContext::reset() +{ + clearComposeBuffer(); + TQInputContext::reset(); +} + +TQString TQSimpleInputContext::identifierName() +{ + return "simple"; +} + +TQString TQSimpleInputContext::language() +{ + return ""; // FIXME +} + +bool TQSimpleInputContext::isIgnoreKeys( int keyval ) +{ + for ( uint i = 0; i < (sizeof(ignoreKeys)/sizeof(ignoreKeys[0])); i++ ) + if ( keyval == ignoreKeys[i] ) + return TRUE; + + return FALSE; +} + +bool TQSimpleInputContext::isComposingKeys( int keyval ) +{ + for ( uint i = 0; i < (sizeof(composingKeys)/sizeof(composingKeys[0])); i++ ) + if ( keyval == composingKeys[i] ) + return TRUE; + + return FALSE; +} + +bool TQSimpleInputContext::checkComposeTable( uint* composeBuffer, const TQComposeTable *composeTable ) +{ + const TQComposeTableElement *p = std::lower_bound( composeTable->data, + composeTable->data + composeTable->size, + composeBuffer, + Cmp() ); + + // no entries were found + if ( p == composeTable->data + composeTable->size ) { + // qDebug( "no match" ); + clearComposeBuffer(); + return FALSE; + } + + // check if compose buffer is matched + for ( int i=0; i < TQT_KEYSEQUENCE_MAX_LEN; i++ ) { + + // check if partial match + if ( composeBuffer[i] == 0 && p->keys[i] ) { + // qDebug("partial match"); + return TRUE; + } + + if ( composeBuffer[i] != p->keys[i] ) { + // qDebug("different entry"); + clearComposeBuffer(); + return i!=0; + } + } + + // qDebug("match exactly"); + + // match exactly + commitChar( p->value ); + clearComposeBuffer(); + + return TRUE; +} + +void TQSimpleInputContext::commitChar( uint c ) +{ + sendIMEvent( TQEvent::IMStart ); + sendIMEvent( TQEvent::IMEnd, TQString(TQChar(c)) ); +} + +void TQSimpleInputContext::clearComposeBuffer(void) +{ + for ( uint i=0; i < (sizeof(composeBuffer)/sizeof(int)); i++ ) + composeBuffer[i] = 0; +} + diff --git a/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontext.h b/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontext.h new file mode 100644 index 0000000..12827a8 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontext.h @@ -0,0 +1,93 @@ +/**************************************************************************** +** $Id$ +** +** Definition of TQSimpleInputContext class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQSIMPLEINPUT_CONTEXT_H +#define TQSIMPLEINPUT_CONTEXT_H + +#include +#include + +#define TQT_KEYSEQUENCE_MAX_LEN 6 +#define UNITIZE(qkey) (0x02000000|qkey) + +struct TQComposeTableElement { + uint keys[TQT_KEYSEQUENCE_MAX_LEN]; + uint value; +}; + +struct TQComposeTable { + const TQComposeTableElement *data; + uint size; +}; + + +class TQSimpleInputContext : public TQInputContext { + TQ_OBJECT +public: + TQSimpleInputContext(); + ~TQSimpleInputContext(); + + virtual TQString identifierName(); + virtual TQString language(); + + virtual bool filterEvent( const TQEvent *event ); + virtual void reset(); + virtual void setFocus(); + virtual void unsetFocus(); + virtual void setMicroFocus( int x, int y, int w, int h, TQFont *f = 0 ); + virtual void mouseHandler( int x, TQEvent::Type type, + TQt::ButtonState button, TQt::ButtonState state ); + +protected: + bool isIgnoreKeys(int keyval ); + bool isComposingKeys( int keyval ); + bool checkComposeTable( uint composeBuffer[], const TQComposeTable *composeTable ); + void commitChar( uint c ); + + void clearComposeBuffer(void); + +protected: + uint composeBuffer[TQT_KEYSEQUENCE_MAX_LEN + 1]; + static const TQComposeTable defaultComposeTable; +}; + +#endif // TQSIMPLEINPUT_CONTEXT_H diff --git a/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.cpp b/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.cpp new file mode 100644 index 0000000..7ac4ede --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.cpp @@ -0,0 +1,86 @@ +/**************************************************************************** +** $Id$ +** +** Implementation of TQSimpleInputContextPlugin class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQT_NO_IM +#include "tqsimpleinputcontext.h" +#include "tqsimpleinputcontextplugin.h" +#include +#include + + +TQSimpleInputContextPlugin::TQSimpleInputContextPlugin() +{ +} + +TQSimpleInputContextPlugin::~TQSimpleInputContextPlugin() +{ +} + +TQStringList TQSimpleInputContextPlugin::keys() const +{ + return TQStringList( "simple" ); +} + +TQInputContext *TQSimpleInputContextPlugin::create( const TQString & ) +{ + return new TQSimpleInputContext; +} + +TQStringList TQSimpleInputContextPlugin::languages( const TQString & ) +{ + return TQStringList( "" ); +} + +TQString TQSimpleInputContextPlugin::displayName( const TQString & ) +{ + return tr( "Simple Composing Input Method" ); +} + +TQString TQSimpleInputContextPlugin::description( const TQString & ) +{ + return tr( "Simple composing input method" ); +} + + +TQ_EXPORT_PLUGIN( TQSimpleInputContextPlugin ) + +#endif diff --git a/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.h b/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.h new file mode 100644 index 0000000..74fd3e7 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/simple/tqsimpleinputcontextplugin.h @@ -0,0 +1,63 @@ +/**************************************************************************** +** $Id$ +** +** Definition of TQSimpleInputContextPlugin class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQT_NO_IM +#include "tqsimpleinputcontext.h" +#include +#include + + +class TQSimpleInputContextPlugin : public TQInputContextPlugin +{ + TQ_OBJECT +public: + TQSimpleInputContextPlugin(); + ~TQSimpleInputContextPlugin(); + + TQStringList keys() const; + TQInputContext *create( const TQString &key ); + TQStringList languages( const TQString &key ); + TQString displayName( const TQString &key ); + TQString description( const TQString &key ); +}; + +#endif diff --git a/tqtinterface/qt4/plugins/src/inputmethods/simple/xcompose2q.rb b/tqtinterface/qt4/plugins/src/inputmethods/simple/xcompose2q.rb new file mode 100644 index 0000000..e71c557 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/simple/xcompose2q.rb @@ -0,0 +1,450 @@ +#!/usr/bin/env ruby + +# xcompose2q.rb: X Compose table to TQSimpleInputContext table translator +# Copyright (C) 2004 immodule for TQt Project. All rights reserved. +# +# This file is written to contribute to Trolltech AS under their own +# licence. You may use this file under your TQt license. Following +# description is copied from their original file headers. Contact +# immodule-qt@freedesktop.org if any conditions of this licensing are +# not clear to you. + +# This file may be distributed under the terms of the Q Public License +# as defined by Trolltech AS of Norway and appearing in the file +# LICENSE.TQPL included in the packaging of this file. +# +# This file may be distributed and/or modified under the terms of the +# GNU General Public License version 2 as published by the Free Software +# Foundation and appearing in the file LICENSE.GPL included in the +# packaging of this file. +# +# Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +# licenses may use this file in accordance with the TQt Commercial License +# Agreement provided with the Software. +# +# This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +# WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +# +# See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +# information about TQt Commercial License Agreements. +# See http://www.trolltech.com/qpl/ for TQPL licensing information. +# See http://www.trolltech.com/gpl/ for GPL licensing information. +# +# Contact info@trolltech.com if any conditions of this licensing are +# not clear to you. + + +# Usage: +# xcompose2q.rb /usr/X11R6/lib/X11/locale/en_US.UTF-8/Compose + +require 'uconv' + +# translation table for lazy sorting +raw2key = { + "0y1120" => "UNITIZE(TQt::Key_Multi_key)", + "0y1250" => "UNITIZE(TQt::Key_Dead_Grave)", + "0y1251" => "UNITIZE(TQt::Key_Dead_Acute)", + "0y1252" => "UNITIZE(TQt::Key_Dead_Circumflex)", + "0y1253" => "UNITIZE(TQt::Key_Dead_Tilde)", + "0y1254" => "UNITIZE(TQt::Key_Dead_Macron)", + "0y1255" => "UNITIZE(TQt::Key_Dead_Breve)", + "0y1256" => "UNITIZE(TQt::Key_Dead_Abovedot)", + "0y1257" => "UNITIZE(TQt::Key_Dead_Diaeresis)", + "0y1258" => "UNITIZE(TQt::Key_Dead_Abovering)", + "0y1259" => "UNITIZE(TQt::Key_Dead_Doubleacute)", + "0y125a" => "UNITIZE(TQt::Key_Dead_Caron)", + "0y125b" => "UNITIZE(TQt::Key_Dead_Cedilla)", + "0y125c" => "UNITIZE(TQt::Key_Dead_Ogonek)", + "0y125d" => "UNITIZE(TQt::Key_Dead_Iota)", + "0y125e" => "UNITIZE(TQt::Key_Dead_Voiced_Sound)", + "0y125f" => "UNITIZE(TQt::Key_Dead_Semivoiced_Sound)", + "0y1260" => "UNITIZE(TQt::Key_Dead_Belowdot)", + "0y1261" => "UNITIZE(TQt::Key_Dead_Hook)", + "0y1262" => "UNITIZE(TQt::Key_Dead_Horn)", +} + +# X's KeySym to Unicode translation table. The tqunicode value is +# extracted from +# TQETWidget::translateKeyEventInternal(). Translation for some +# keys are not available +x2q = { + "Multi_key" => "0y1120", + "dead_grave" => "0y1250", + "dead_acute" => "0y1251", + "dead_circumflex" => "0y1252", + "dead_tilde" => "0y1253", + "dead_macron" => "0y1254", + "dead_breve" => "0y1255", + "dead_abovedot" => "0y1256", + "dead_diaeresis" => "0y1257", + "dead_abovering" => "0y1258", + "dead_doubleacute" => "0y1259", + "dead_caron" => "0y125a", + "dead_cedilla" => "0y125b", + "dead_ogonek" => "0y125c", + "dead_iota" => "0y125d", + "dead_voiced_sound" => "0y125e", + "dead_semivoiced_sound" => "0y125f", + "dead_belowdot" => "0y1260", + "dead_hook" => "0y1261", + "dead_horn" => "0y1262", + + "0" => "0x0030", + "1" => "0x0031", + "2" => "0x0032", + "3" => "0x0033", + "4" => "0x0034", + "5" => "0x0035", + "6" => "0x0036", + "7" => "0x0037", + "8" => "0x0038", + "9" => "0x0039", + "A" => "0x0041", + "AE" => "0x00c6", + "Abreve" => "0x0102", + "Acircumflex" => "0x00c2", + "Adiaeresis" => "0x00c4", + "Arabic_alef" => "0x0627", + "Arabic_waw" => "0x0648", + "Arabic_yeh" => "0x064a", + "Aring" => "0x00c5", + "B" => "0x0042", + "C" => "0x0043", + "Ccedilla" => "0x00c7", + "Cyrillic_A" => "0x0410", + "Cyrillic_CHE" => "0x0427", + "Cyrillic_E" => "0x042d", + "Cyrillic_GHE" => "0x0413", + "Cyrillic_I" => "0x0418", + "Cyrillic_IE" => "0x0415", + "Cyrillic_KA" => "0x041a", + "Cyrillic_O" => "0x041e", + "Cyrillic_U" => "0x0423", + "Cyrillic_YERU" => "0x042b", + "Cyrillic_ZE" => "0x0417", + "Cyrillic_ZHE" => "0x0416", + "Cyrillic_a" => "0x0430", + "Cyrillic_che" => "0x0447", + "Cyrillic_e" => "0x044d", + "Cyrillic_ghe" => "0x0433", + "Cyrillic_i" => "0x0438", + "Cyrillic_ie" => "0x0435", + "Cyrillic_ka" => "0x043a", + "Cyrillic_o" => "0x043e", + "Cyrillic_u" => "0x0443", + "Cyrillic_yeru" => "0x044b", + "Cyrillic_ze" => "0x0437", + "Cyrillic_zhe" => "0x0436", + "D" => "0x0044", + "E" => "0x0045", + "Ecircumflex" => "0x00ca", + "Emacron" => "0x0112", + "F" => "0x0046", + "G" => "0x0047", + "Greek_ALPHA" => "0x0391", + "Greek_EPSILON" => "0x0395", + "Greek_ETA" => "0x0397", + "Greek_IOTA" => "0x0399", + "Greek_OMEGA" => "0x03a9", + "Greek_OMICRON" => "0x039f", + "Greek_RHO" => "0x03a1", + "Greek_UPSILON" => "0x03a5", + "Greek_alpha" => "0x03b1", + "Greek_alphaaccent" => "0x03ac", + "Greek_epsilon" => "0x03b5", + "Greek_eta" => "0x03b7", + "Greek_etaaccent" => "0x03ae", + "Greek_iota" => "0x03b9", + "Greek_iotadieresis" => "0x03ca", + "Greek_omega" => "0x03c9", + "Greek_omegaaccent" => "0x03ce", + "Greek_omicron" => "0x03bf", + "Greek_rho" => "0x03c1", + "Greek_upsilon" => "0x03c5", + "Greek_upsilondieresis" => "0x03cb", + "H" => "0x0048", + "I" => "0x0049", + "Idiaeresis" => "0x00cf", + "J" => "0x004a", + "K" => "0x004b", + "KP_0" => "0x0000", + "KP_1" => "0x0000", + "KP_2" => "0x0000", + "KP_3" => "0x0000", + "KP_4" => "0x0000", + "KP_5" => "0x0000", + "KP_6" => "0x0000", + "KP_7" => "0x0000", + "KP_8" => "0x0000", + "KP_9" => "0x0000", + "KP_Add" => "0x0000", + "KP_Divide" => "0x0000", + "KP_Equal" => "0x0000", + "KP_Space" => "0x0000", + "L" => "0x004c", + "M" => "0x004d", + "N" => "0x004e", + "O" => "0x004f", + "Ocircumflex" => "0x00d4", + "Odiaeresis" => "0x00d6", + "Ohorn" => "0x0000", + "Omacron" => "0x014c", + "Ooblique" => "0x00d8", + "Otilde" => "0x00d5", + "P" => "0x0050", + "Q" => "0x0051", + "R" => "0x0052", + "S" => "0x0053", + "Sacute" => "0x015a", + "Scaron" => "0x0160", + "T" => "0x0054", + "U" => "0x0055", + "Udiaeresis" => "0x00dc", + "Uhorn" => "0x0000", + "Ukrainian_I" => "0x0406", + "Ukrainian_i" => "0x0456", + "Umacron" => "0x016a", + "Utilde" => "0x0168", + "V" => "0x0056", + "W" => "0x0057", + "X" => "0x0058", + "Y" => "0x0059", + "Z" => "0x005a", + "a" => "0x0061", + "abreve" => "0x0103", + "acircumflex" => "0x00e2", + "acute" => "0x00b4", + "adiaeresis" => "0x00e4", + "ae" => "0x00e6", + "ampersand" => "0x0026", + "apostrophe" => "0x0027", + "approximate" => "0x223c", + "aring" => "0x00e5", + "asciicircum" => "0x005e", + "asciitilde" => "0x007e", + "asterisk" => "0x002a", + "at" => "0x0040", + "b" => "0x0062", + "backslash" => "0x005c", + "bar" => "0x007c", + "braceleft" => "0x007b", + "braceright" => "0x007d", + "bracketleft" => "0x005b", + "bracketright" => "0x005d", + "c" => "0x0063", + "ccedilla" => "0x00e7", + "colon" => "0x003a", + "combining_acute" => "0x0000", + "combining_belowdot" => "0x0000", + "combining_grave" => "0x0000", + "combining_hook" => "0x0000", + "combining_tilde" => "0x0000", + "comma" => "0x002c", + "d" => "0x0064", + "diaeresis" => "0x00a8", + "dollar" => "0x0024", + "e" => "0x0065", + "ecircumflex" => "0x00ea", + "emacron" => "0x0113", + "equal" => "0x003d", + "exclam" => "0x0021", + "f" => "0x0066", + "g" => "0x0067", + "grave" => "0x0060", + "greater" => "0x003e", + "greaterthanequal" => "0x2265", + "h" => "0x0068", + "hebrew_aleph" => "0x05d0", + "hebrew_bet" => "0x05d1", + "hebrew_beth" => "0x05d1", + "hebrew_dalet" => "0x05d3", + "hebrew_daleth" => "0x05d3", + "hebrew_finalkaph" => "0x05da", + "hebrew_finalpe" => "0x05e3", + "hebrew_gimel" => "0x05d2", + "hebrew_gimmel" => "0x05d2", + "hebrew_he" => "0x05d4", + "hebrew_kaph" => "0x05db", + "hebrew_kuf" => "0x05e7", + "hebrew_lamed" => "0x05dc", + "hebrew_mem" => "0x05de", + "hebrew_nun" => "0x05e0", + "hebrew_pe" => "0x05e4", + "hebrew_qoph" => "0x05e7", + "hebrew_resh" => "0x05e8", + "hebrew_samech" => "0x05e1", + "hebrew_samekh" => "0x05e1", + "hebrew_shin" => "0x05e9", + "hebrew_taf" => "0x05ea", + "hebrew_taw" => "0x05ea", + "hebrew_tet" => "0x05d8", + "hebrew_teth" => "0x05d8", + "hebrew_waw" => "0x05d5", + "hebrew_yod" => "0x05d9", + "hebrew_zade" => "0x05e6", + "hebrew_zadi" => "0x05e6", + "hebrew_zain" => "0x05d6", + "hebrew_zayin" => "0x05d6", + "i" => "0x0069", + "identical" => "0x2261", + "idiaeresis" => "0x00ef", + "includedin" => "0x2282", + "includes" => "0x2283", + "j" => "0x006a", + "k" => "0x006b", + "kana_A" => "0x30a2", + "kana_CHI" => "0x30c1", + "kana_E" => "0x30a8", + "kana_FU" => "0x30d5", + "kana_HA" => "0x30cf", + "kana_HE" => "0x30d8", + "kana_HI" => "0x30d2", + "kana_HO" => "0x30db", + "kana_I" => "0x30a4", + "kana_KA" => "0x30ab", + "kana_KE" => "0x30b1", + "kana_KI" => "0x30ad", + "kana_KO" => "0x30b3", + "kana_KU" => "0x30af", + "kana_MA" => "0x30de", + "kana_ME" => "0x30e1", + "kana_MI" => "0x30df", + "kana_MO" => "0x30e2", + "kana_MU" => "0x30e0", + "kana_NA" => "0x30ca", + "kana_NE" => "0x30cd", + "kana_NI" => "0x30cb", + "kana_NO" => "0x30ce", + "kana_NU" => "0x30cc", + "kana_O" => "0x30aa", + "kana_RA" => "0x30e9", + "kana_RE" => "0x30ec", + "kana_RI" => "0x30ea", + "kana_RO" => "0x30ed", + "kana_RU" => "0x30eb", + "kana_SA" => "0x30b5", + "kana_SE" => "0x30bb", + "kana_SHI" => "0x30b7", + "kana_SO" => "0x30bd", + "kana_SU" => "0x30b9", + "kana_TA" => "0x30bf", + "kana_TE" => "0x30c6", + "kana_TO" => "0x30c8", + "kana_TSU" => "0x30c4", + "kana_U" => "0x30a6", + "kana_WA" => "0x30ef", + "kana_WO" => "0x30f2", + "kana_YA" => "0x30e4", + "kana_YO" => "0x30e8", + "kana_YU" => "0x30e6", + "l" => "0x006c", + "leftarrow" => "0x2190", + "leftcaret" => "0x003c", + "leftshoe" => "0x2282", + "less" => "0x003c", + "lessthanequal" => "0x2264", + "m" => "0x006d", + "macron" => "0x00af", + "minus" => "0x002d", + "n" => "0x006e", + "numbersign" => "0x0023", + "o" => "0x006f", + "ocircumflex" => "0x00f4", + "odiaeresis" => "0x00f6", + "ohorn" => "0x0000", + "omacron" => "0x014d", + "oslash" => "0x00f8", + "otilde" => "0x00f5", + "p" => "0x0070", + "parenleft" => "0x0028", + "parenright" => "0x0029", + "percent" => "0x0025", + "period" => "0x002e", + "plus" => "0x002b", + "q" => "0x0071", + "question" => "0x003f", + "quotedbl" => "0x0022", + "r" => "0x0072", + "rightarrow" => "0x2192", + "rightcaret" => "0x003e", + "rightshoe" => "0x2283", + "righttack" => "0x22a3", + "s" => "0x0073", + "sacute" => "0x015b", + "scaron" => "0x0161", + "semicolon" => "0x003b", + "slash" => "0x002f", + "space" => "0x0020", + "t" => "0x0074", + "u" => "0x0075", + "udiaeresis" => "0x00fc", + "uhorn" => "0x0000", + "umacron" => "0x016b", + "underbar" => "0x005f", + "underscore" => "0x005f", + "utilde" => "0x0169", + "v" => "0x0076", + "w" => "0x0077", + "x" => "0x0078", + "y" => "0x0079", + "z" => "0x007a", +} + +readlines.collect { + |line| + + broken = "" + seq = ["0", "0", "0", "0", "0", "0"] + index = 0 + rhs = "0x0000" + comment = "" + + case line + when /^(#|XCOMM)(.*)$/ + comment = "// #{$2}\n" + rhs = :isCommentLine + when /^$/ + comment = "\n" + rhs = :isCommentLine + else + line.scan(/<([^>]+)>/) { + |args| + keysym = args[0] + unit = x2q[keysym] || keysym.sub(/^U([\da-fA-F]{4,5})$/, "0x\\1") + if (/^(0x(0000|[\da-fA-F]{5,})|dead_space)$/ =~ unit) + broken = "// /* broken */" + end + seq[index] = unit + index += 1 + } + + Regexp.new(':\s+"(.+)"\s+(.+)$', nil, 'u') =~ line + rhs = Uconv::u8tou16($1).unpack('v')[0] + rhs = format("0x%04x", rhs) + comment = $2 + end + + entry = { + :broken => broken, + :seq => seq, + :rhs => rhs, + :comment => comment + } +}.sort { + |entry_a, entry_b| + + entry_a[:seq] <=> entry_b[:seq] +}.each { + |entry| + + broken, seq, rhs, comment = entry.values_at(:broken, :seq, :rhs, :comment) + if (rhs == :isCommentLine) + print comment + else + seq = seq.collect { + |unit| + raw2key[unit] || unit + } + print "#{broken} { {#{seq.join(", ")}}, #{rhs} }, // #{comment}\n" + end +} diff --git a/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontext.h b/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontext.h new file mode 100644 index 0000000..e42c929 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontext.h @@ -0,0 +1,130 @@ +/**************************************************************************** +** $Id: qximinputcontext_p.h,v 1.6 2004/06/22 06:47:27 daisuke Exp $ +** +** Definition of TQXIMInputContext +** +** Copyright (C) 1992-2002 Trolltech AS. All rights reserved. +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQXIMINPUTCONTEXT_H +#define TQXIMINPUTCONTEXT_H + + +// +// W A R N I N G +// ------------- +// +// This file is not part of the TQt API. It exists for the convenience +// of internal files. This header file may change from version to version +// without notice, or even be removed. +// +// We mean it. +// +// + +#if !defined(TQ_NO_IM) + +#include "tqglobal.h" +#include +#include +#include + +class TQKeyEvent; +class TQWidget; +class TQFont; +class TQString; + + +#ifdef TQ_WS_X11 +#include "tqarray.h" +#include "tqwindowdefs.h" +#include +#endif + +class TQXIMInputContext : public TQInputContext +{ + TQ_OBJECT +public: +#ifdef TQ_WS_X11 + TQXIMInputContext(); + ~TQXIMInputContext(); + + TQString identifierName(); + TQString language(); + + bool x11FilterEvent( TQWidget *keywidget, XEvent *event ); + void reset(); + + void setFocus(); + void unsetFocus(); + void setMicroFocus( int x, int y, int w, int h, TQFont *f = 0 ); + void mouseHandler( int x, TQEvent::Type type, + TQt::ButtonState button, TQt::ButtonState state ); + bool isPreeditRelocationEnabled(); + + void setHolderWidget( TQWidget *widget ); + + bool hasFocus() const; + void resetClientState(); + void close( const TQString &errMsg ); + + void sendIMEvent( TQEvent::Type type, + const TQString &text = TQString(), + int cursorPosition = -1, int selLength = 0 ); + + static void init_xim(); + static void create_xim(); + static void close_xim(); + + void *ic; + TQString composingText; + TQFont font; + XFontSet fontset; + TQMemArray selectedChars; + +protected: + virtual bool isPreeditPreservationEnabled(); // not a TQInputContext func + + TQCString _language; + +private: + void setComposePosition(int, int); + void setComposeArea(int, int, int, int); + void setXFontSet(const TQFont &); + + int lookupString(XKeyEvent *, TQCString &, KeySym *, tqStatus *) const; + +#endif // TQ_WS_X11 +}; + + +#endif //TQ_NO_IM + +#endif // TQXIMINPUTCONTEXT_H diff --git a/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp b/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp new file mode 100644 index 0000000..412ece8 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontext_x11.cpp @@ -0,0 +1,930 @@ +/**************************************************************************** +** $Id: qximinputcontext_x11.cpp,v 1.10 2004/06/22 06:47:27 daisuke Exp $ +** +** Implementation of TQXIMInputContext class +** +** Copyright (C) 2000-2003 Trolltech AS. All rights reserved. +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses for Unix/X11 may use this file in accordance with the TQt Commercial +** License Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + + +#include "tqximinputcontext.h" + +const int XKeyPress = KeyPress; +const int XKeyRelease = KeyRelease; +#undef KeyPress +#undef KeyRelease + +#if !defined(TQT_NO_IM) + +#include "tqplatformdefs.h" + +#include "tqapplication.h" +#include "tqwidget.h" +#include "tqstring.h" +#include "tqptrlist.h" +#include "tqintdict.h" +#include "tqtextcodec.h" + +#include +#include + +#if !defined(TQT_NO_XIM) + +#define XK_MISCELLANY +#define XK_LATIN1 +#include + +// #define TQT_XIM_DEBUG + +// from qapplication_x11.cpp +static XIM qt_xim = 0; +extern XIMStyle qt_xim_style; +extern XIMStyle qt_xim_preferred_style; +extern char *qt_ximServer; +static bool isInitXIM = FALSE; +static TQPtrList *ximContextList = 0; +#endif +extern int qt_ximComposingKeycode; +extern TQTextCodec * qt_input_mapper; + + +#if !defined(TQT_NO_XIM) + +#if defined(TQ_C_CALLBACKS) +extern "C" { +#endif // TQ_C_CALLBACKS + +#ifdef USE_X11R6_XIM + static void xim_create_callback(XIM /*im*/, + XPointer /*client_data*/, + XPointer /*call_data*/) + { + // qDebug("xim_create_callback"); + TQXIMInputContext::create_xim(); + } + + static void xim_destroy_callback(XIM /*im*/, + XPointer /*client_data*/, + XPointer /*call_data*/) + { + // qDebug("xim_destroy_callback"); + TQXIMInputContext::close_xim(); + Display *dpy = TQPaintDevice::x11AppDisplay(); + XRegisterIMInstantiateCallback(dpy, 0, 0, 0, + (XIMProc) xim_create_callback, 0); + } + +#endif // USE_X11R6_XIM + +#if defined(TQ_C_CALLBACKS) +} +#endif // TQ_C_CALLBACKS + +#endif // TQT_NO_XIM + +#ifndef TQT_NO_XIM + +/* The cache here is needed, as X11 leaks a few kb for every + XFreeFontSet call, so we avoid creating and deletion of fontsets as + much as possible +*/ +static XFontSet fontsetCache[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; +static int fontsetRefCount = 0; + +static const char * const fontsetnames[] = { + "-*-fixed-medium-r-*-*-16-*,-*-*-medium-r-*-*-16-*", + "-*-fixed-medium-i-*-*-16-*,-*-*-medium-i-*-*-16-*", + "-*-fixed-bold-r-*-*-16-*,-*-*-bold-r-*-*-16-*", + "-*-fixed-bold-i-*-*-16-*,-*-*-bold-i-*-*-16-*", + "-*-fixed-medium-r-*-*-24-*,-*-*-medium-r-*-*-24-*", + "-*-fixed-medium-i-*-*-24-*,-*-*-medium-i-*-*-24-*", + "-*-fixed-bold-r-*-*-24-*,-*-*-bold-r-*-*-24-*", + "-*-fixed-bold-i-*-*-24-*,-*-*-bold-i-*-*-24-*" +}; + +static XFontSet getFontSet( const TQFont &f ) +{ + int i = 0; + if (f.italic()) + i |= 1; + if (f.bold()) + i |= 2; + + if ( f.pointSize() > 20 ) + i += 4; + + if ( !fontsetCache[i] ) { + Display* dpy = TQPaintDevice::x11AppDisplay(); + int missCount; + char** missList; + fontsetCache[i] = XCreateFontSet(dpy, fontsetnames[i], &missList, &missCount, 0); + if(missCount > 0) + XFreeStringList(missList); + if ( !fontsetCache[i] ) { + fontsetCache[i] = XCreateFontSet(dpy, "-*-fixed-*-*-*-*-16-*", &missList, &missCount, 0); + if(missCount > 0) + XFreeStringList(missList); + if ( !fontsetCache[i] ) + fontsetCache[i] = (XFontSet)-1; + } + } + return (fontsetCache[i] == (XFontSet)-1) ? 0 : fontsetCache[i]; +} + + +#ifdef TQ_C_CALLBACKS +extern "C" { +#endif // TQ_C_CALLBACKS + + // These static functions should be rewritten as member of + // TQXIMInputContext + + static int xic_start_callback(XIC, XPointer client_data, XPointer) { + TQXIMInputContext *qic = (TQXIMInputContext *) client_data; + if (! qic) { +#ifdef TQT_XIM_DEBUG + qDebug("compose start: no qic"); +#endif // TQT_XIM_DEBUG + + return 0; + } + + qic->resetClientState(); + qic->sendIMEvent( TQEvent::IMStart ); + +#ifdef TQT_XIM_DEBUG + qDebug("compose start"); +#endif // TQT_XIM_DEBUG + + return 0; + } + + static int xic_draw_callback(XIC, XPointer client_data, XPointer call_data) { + TQXIMInputContext *qic = (TQXIMInputContext *) client_data; + if (! qic) { +#ifdef TQT_XIM_DEBUG + qDebug("compose event: invalid compose event %p", qic); +#endif // TQT_XIM_DEBUG + + return 0; + } + + bool send_imstart = FALSE; + if( ! qic->isComposing() && qic->hasFocus() ) { + qic->resetClientState(); + send_imstart = TRUE; + } else if ( ! qic->isComposing() || ! qic->hasFocus() ) { +#ifdef TQT_XIM_DEBUG + qDebug( "compose event: invalid compose event composing=%d hasFocus=%d", + qic->isComposing(), qic->hasFocus() ); +#endif // TQT_XIM_DEBUG + + return 0; + } + + if ( send_imstart ) + qic->sendIMEvent( TQEvent::IMStart ); + + XIMPreeditDrawCallbackStruct *drawstruct = + (XIMPreeditDrawCallbackStruct *) call_data; + XIMText *text = (XIMText *) drawstruct->text; + int cursor = drawstruct->caret, sellen = 0; + + if ( ! drawstruct->caret && ! drawstruct->chg_first && + ! drawstruct->chg_length && ! text ) { + if( qic->composingText.isEmpty() ) { +#ifdef TQT_XIM_DEBUG + qDebug( "compose emptied" ); +#endif // TQT_XIM_DEBUG + // if the composition string has been emptied, we need + // to send an IMEnd event + qic->sendIMEvent( TQEvent::IMEnd ); + qic->resetClientState(); + // if the commit string has coming after here, IMStart + // will be sent dynamically + } + return 0; + } + + if (text) { + char *str = 0; + if (text->encoding_is_wchar) { + int l = wcstombs(NULL, text->string.wide_char, text->length); + if (l != -1) { + str = new char[l + 1]; + wcstombs(str, text->string.wide_char, l); + str[l] = 0; + } + } else + str = text->string.multi_byte; + + if (! str) + return 0; + + TQString s = TQString::fromLocal8Bit(str); + + if (text->encoding_is_wchar) + delete [] str; + + if (drawstruct->chg_length < 0) + qic->composingText.tqreplace(drawstruct->chg_first, UINT_MAX, s); + else + qic->composingText.tqreplace(drawstruct->chg_first, drawstruct->chg_length, s); + + if ( qic->selectedChars.size() < qic->composingText.length() ) { + // expand the selectedChars array if the compose string is longer + uint from = qic->selectedChars.size(); + qic->selectedChars.resize( qic->composingText.length() ); + for ( uint x = from; from < qic->selectedChars.size(); ++x ) + qic->selectedChars[x] = 0; + } + + uint x; + bool *p = qic->selectedChars.data() + drawstruct->chg_first; + // determine if the changed chars are selected based on text->feedback + for ( x = 0; x < s.length(); ++x ) + *p++ = ( text->feedback ? ( text->feedback[x] & XIMReverse ) : 0 ); + + // figure out where the selection starts, and how long it is + p = qic->selectedChars.data(); + bool started = FALSE; + for ( x = 0; x < TQMIN(qic->composingText.length(), qic->selectedChars.size()); ++x ) { + if ( started ) { + if ( *p ) ++sellen; + else break; + } else { + if ( *p ) { + cursor = x; + started = TRUE; + sellen = 1; + } + } + ++p; + } + } else { + if (drawstruct->chg_length == 0) + drawstruct->chg_length = -1; + + qic->composingText.remove(drawstruct->chg_first, drawstruct->chg_length); + bool qt_compose_emptied = qic->composingText.isEmpty(); + if ( qt_compose_emptied ) { +#ifdef TQT_XIM_DEBUG + qDebug( "compose emptied" ); +#endif // TQT_XIM_DEBUG + // if the composition string has been emptied, we need + // to send an IMEnd event + qic->sendIMEvent( TQEvent::IMEnd ); + qic->resetClientState(); + // if the commit string has coming after here, IMStart + // will be sent dynamically + return 0; + } + } + + qic->sendIMEvent( TQEvent::IMCompose, + qic->composingText, cursor, sellen ); + + return 0; + } + + static int xic_done_callback(XIC, XPointer client_data, XPointer) { + TQXIMInputContext *qic = (TQXIMInputContext *) client_data; + if (! qic) + return 0; + + // Don't send IMEnd here. TQXIMInputContext::x11FilterEvent() + // handles IMEnd with commit string. +#if 0 + if ( qic->isComposing() ) + qic->sendIMEvent( TQEvent::IMEnd ); + qic->resetClientState(); +#endif + + return 0; + } + +#ifdef TQ_C_CALLBACKS +} +#endif // TQ_C_CALLBACKS + +#endif // !TQT_NO_XIM + + + +TQXIMInputContext::TQXIMInputContext() + : TQInputContext(), ic(0), fontset(0) +{ + if(!isInitXIM) + TQXIMInputContext::init_xim(); +} + + +void TQXIMInputContext::setHolderWidget( TQWidget *widget ) +{ + if ( ! widget ) + return; + + TQInputContext::setHolderWidget( widget ); + +#if !defined(TQT_NO_XIM) + fontsetRefCount++; + if (! qt_xim) { + qWarning("TQInputContext: no input method context available"); + return; + } + + if (! widget->isTopLevel()) { + // qWarning("TQInputContext: cannot create input context for non-toplevel widgets"); + return; + } + + XPoint spot; + XRectangle rect; + XVaNestedList preedit_attr = 0; + XIMCallback startcallback, drawcallback, donecallback; + + font = widget->font(); + fontset = getFontSet( font ); + + if (qt_xim_style & XIMPreeditArea) { + rect.x = 0; + rect.y = 0; + rect.width = widget->width(); + rect.height = widget->height(); + + preedit_attr = XVaCreateNestedList(0, + XNArea, &rect, + XNFontSet, fontset, + (char *) 0); + } else if (qt_xim_style & XIMPreeditPosition) { + spot.x = 1; + spot.y = 1; + + preedit_attr = XVaCreateNestedList(0, + XNSpotLocation, &spot, + XNFontSet, fontset, + (char *) 0); + } else if (qt_xim_style & XIMPreeditCallbacks) { + startcallback.client_data = (XPointer) this; + startcallback.callback = (XIMProc) xic_start_callback; + drawcallback.client_data = (XPointer) this; + drawcallback.callback = (XIMProc)xic_draw_callback; + donecallback.client_data = (XPointer) this; + donecallback.callback = (XIMProc) xic_done_callback; + + preedit_attr = XVaCreateNestedList(0, + XNPreeditStartCallback, &startcallback, + XNPreeditDrawCallback, &drawcallback, + XNPreeditDoneCallback, &donecallback, + (char *) 0); + } + + if (preedit_attr) { + ic = XCreateIC(qt_xim, + XNInputStyle, qt_xim_style, + XNClientWindow, widget->winId(), + XNPreeditAttributes, preedit_attr, + (char *) 0); + XFree(preedit_attr); + } else + ic = XCreateIC(qt_xim, + XNInputStyle, qt_xim_style, + XNClientWindow, widget->winId(), + (char *) 0); + + if (! ic) + qFatal("Failed to create XIM input context!"); + + // when resetting the input context, preserve the input state + (void) XSetICValues((XIC) ic, XNResetState, XIMPreserveState, (char *) 0); + + if( ! ximContextList ) + ximContextList = new TQPtrList; + ximContextList->append( this ); +#endif // !TQT_NO_XIM +} + + +TQXIMInputContext::~TQXIMInputContext() +{ + +#if !defined(TQT_NO_XIM) + if (ic) + XDestroyIC((XIC) ic); + + if ( --fontsetRefCount == 0 ) { + Display *dpy = TQPaintDevice::x11AppDisplay(); + for ( int i = 0; i < 8; i++ ) { + if ( fontsetCache[i] && fontsetCache[i] != (XFontSet)-1 ) { + XFreeFontSet(dpy, fontsetCache[i]); + fontsetCache[i] = 0; + } + } + } + + if( ximContextList ) { + ximContextList->remove( this ); + if(ximContextList->isEmpty()) { + // Calling XCloseIM gives a Purify FMR error + // XCloseIM( qt_xim ); + // We prefer a less serious memory leak + if( qt_xim ) { + qt_xim = 0; + isInitXIM = FALSE; + } + + delete ximContextList; + ximContextList = 0; + } + } +#endif // !TQT_NO_XIM + + ic = 0; +} + +void TQXIMInputContext::init_xim() +{ +#ifndef TQT_NO_XIM + if(!isInitXIM) + isInitXIM = TRUE; + + qt_xim = 0; + TQString ximServerName(qt_ximServer); + if (qt_ximServer) + ximServerName.prepend("@im="); + else + ximServerName = ""; + + if ( !XSupportsLocale() ) + qWarning("TQt: Locales not supported on X server"); + +#ifdef USE_X11R6_XIM + else if ( XSetLocaleModifiers (ximServerName.ascii()) == 0 ) + qWarning( "TQt: Cannot set locale modifiers: %s", + ximServerName.ascii()); + else { + Display *dpy = TQPaintDevice::x11AppDisplay(); + XWindowAttributes attr; // XIM unselects all events on the root window + XGetWindowAttributes( dpy, TQPaintDevice::x11AppRootWindow(),&attr ); + XRegisterIMInstantiateCallback(dpy, 0, 0, 0, + (XIMProc) xim_create_callback, 0); + XSelectInput( dpy, TQPaintDevice::x11AppRootWindow(), attr.your_event_tqmask ); + } +#else // !USE_X11R6_XIM + else if ( XSetLocaleModifiers ("") == 0 ) + qWarning("TQt: Cannot set locale modifiers"); + else + TQXIMInputContext::create_xim(); +#endif // USE_X11R6_XIM +#endif // TQT_NO_XIM +} + + +/*! \internal + Creates the application input method. + */ +void TQXIMInputContext::create_xim() +{ +#ifndef TQT_NO_XIM + Display *appDpy = TQPaintDevice::x11AppDisplay(); + qt_xim = XOpenIM( appDpy, 0, 0, 0 ); + if ( qt_xim ) { + +#ifdef USE_X11R6_XIM + XIMCallback destroy; + destroy.callback = (XIMProc) xim_destroy_callback; + destroy.client_data = 0; + if ( XSetIMValues( qt_xim, XNDestroyCallback, &destroy, (char *) 0 ) != 0 ) + qWarning( "Xlib doesn't support destroy callback"); +#endif // USE_X11R6_XIM + + XIMStyles *styles = 0; + XGetIMValues(qt_xim, XNQueryInputStyle, &styles, (char *) 0, (char *) 0); + if ( styles ) { + int i; + for ( i = 0; !qt_xim_style && i < styles->count_styles; i++ ) { + if ( styles->supported_styles[i] == qt_xim_preferred_style ) { + qt_xim_style = qt_xim_preferred_style; + break; + } + } + // if the preferred input style couldn't be found, look for + // Nothing + for ( i = 0; !qt_xim_style && i < styles->count_styles; i++ ) { + if ( styles->supported_styles[i] == (XIMPreeditNothing | + XIMStatusNothing) ) { + qt_xim_style = XIMPreeditNothing | XIMStatusNothing; + break; + } + } + // ... and failing that, None. + for ( i = 0; !qt_xim_style && i < styles->count_styles; i++ ) { + if ( styles->supported_styles[i] == (XIMPreeditNone | + XIMStatusNone) ) { + qt_xim_style = XIMPreeditNone | XIMStatusNone; + break; + } + } + + // qDebug("TQApplication: using im style %lx", qt_xim_style); + XFree( (char *)styles ); + } + + if ( qt_xim_style ) { + +#ifdef USE_X11R6_XIM + XUnregisterIMInstantiateCallback(appDpy, 0, 0, 0, + (XIMProc) xim_create_callback, 0); +#endif // USE_X11R6_XIM + + } else { + // Give up + qWarning( "No supported input style found." + " See InputMethod documentation."); + TQXIMInputContext::close_xim(); + } + } +#endif // TQT_NO_XIM +} + + +/*! \internal + Closes the application input method. +*/ +void TQXIMInputContext::close_xim() +{ +#ifndef TQT_NO_XIM + TQString errMsg( "TQXIMInputContext::close_xim() has been called" ); + + // Calling XCloseIM gives a Purify FMR error + // XCloseIM( qt_xim ); + // We prefer a less serious memory leak + + qt_xim = 0; + if( ximContextList ) { + TQPtrList contexts( *ximContextList ); + TQPtrList::Iterator it = contexts.begin(); + while( it != contexts.end() ) { + (*it)->close( errMsg ); + ++it; + } + // ximContextList will be deleted in ~TQXIMInputContext + } +#endif // TQT_NO_XIM +} + + +bool TQXIMInputContext::x11FilterEvent( TQWidget *keywidget, XEvent *event ) +{ +#ifndef TQT_NO_XIM + int xkey_keycode = event->xkey.keycode; + if ( XFilterEvent( event, keywidget->tqtopLevelWidget()->winId() ) ) { + qt_ximComposingKeycode = xkey_keycode; // ### not documented in xlib + + // Cancel of the composition is realizable even if + // follwing codes don't exist +#if 0 + if ( event->type != XKeyPress || ! (qt_xim_style & XIMPreeditCallbacks) ) + return TRUE; + + /* + * The Solaris htt input method will transform a ClientMessage + * event into a filtered KeyPress event, in which case our + * keywidget is still zero. + */ + TQETWidget *widget = (TQETWidget*)TQWidget::tqfind( (WId)event->xany.window ); + if ( ! keywidget ) { + keywidget = (TQETWidget*)TQWidget::keyboardGrabber(); + if ( keywidget ) { + grabbed = TRUE; + } else { + if ( focus_widget ) + keywidget = (TQETWidget*)focus_widget; + if ( !keywidget ) { + if ( tqApp->inPopupMode() ) // no focus widget, see if we have a popup + keywidget = (TQETWidget*) tqApp->activePopupWidget(); + else if ( widget ) + keywidget = (TQETWidget*)widget->tqtopLevelWidget(); + } + } + } + + /* + if the composition string has been emptied, we need to send + an IMEnd event. however, we have no way to tell if the user + has cancelled input, or if the user has accepted the + composition. + + so, we have to look for the next keypress and see if it is + the 'commit' key press (keycode == 0). if it is, we deliver + an IMEnd event with the final text, otherwise we deliver an + IMEnd with empty text (meaning the user has cancelled the + input). + */ + if ( composing && tqfocusWidget && qt_compose_emptied ) { + XEvent event2; + bool found = FALSE; + if ( XCheckTypedEvent( TQPaintDevice::x11AppDisplay(), + XKeyPress, &event2 ) ) { + if ( event2.xkey.keycode == 0 ) { + // found a key event with the 'commit' string + found = TRUE; + XPutBackEvent( TQPaintDevice::x11AppDisplay(), &event2 ); + } + } + + if ( !found ) { + // no key event, so the user must have cancelled the composition + TQIMEvent endevent( TQEvent::IMEnd, TQString(), -1 ); + TQApplication::sendEvent( tqfocusWidget, &endevent ); + + tqfocusWidget = 0; + } + + qt_compose_emptied = FALSE; + } +#endif + return TRUE; + } else if ( tqfocusWidget() ) { + if ( event->type == XKeyPress && event->xkey.keycode == 0 ) { + // input method has sent us a commit string + TQCString data(513); + KeySym sym; // unused + tqStatus status; // unused + TQString inputText; + int count = lookupString( &(event->xkey), data, &sym, &status ); + if ( count > 0 ) + inputText = qt_input_mapper->toUnicode( data, count ); + + if ( ! ( qt_xim_style & XIMPreeditCallbacks ) || ! isComposing() ) { + // there is no composing state + sendIMEvent( TQEvent::IMStart ); + } + + sendIMEvent( TQEvent::IMEnd, inputText ); + resetClientState(); + + return TRUE; + } + } +#endif // !TQT_NO_XIM + + return FALSE; +} + + +void TQXIMInputContext::sendIMEvent( TQEvent::Type type, const TQString &text, + int cursorPosition, int selLength ) +{ + TQInputContext::sendIMEvent( type, text, cursorPosition, selLength ); + if ( type == TQEvent::IMCompose ) + composingText = text; +} + + +void TQXIMInputContext::reset() +{ +#if !defined(TQT_NO_XIM) + if ( tqfocusWidget() && isComposing() && ! composingText.isNull() ) { +#ifdef TQT_XIM_DEBUG + qDebug("TQXIMInputContext::reset: composing - sending IMEnd (empty) to %p", + tqfocusWidget() ); +#endif // TQT_XIM_DEBUG + + TQInputContext::reset(); + resetClientState(); + + char *mb = XmbResetIC((XIC) ic); + if (mb) + XFree(mb); + } +#endif // !TQT_NO_XIM +} + + +void TQXIMInputContext::resetClientState() +{ +#if !defined(TQT_NO_XIM) + composingText = TQString(); + if ( selectedChars.size() < 128 ) + selectedChars.resize( 128 ); + selectedChars.fill( 0 ); +#endif // !TQT_NO_XIM +} + + +void TQXIMInputContext::close( const TQString &errMsg ) +{ + qDebug( errMsg ); + emit deletionRequested(); +} + + +bool TQXIMInputContext::hasFocus() const +{ + return ( tqfocusWidget() != 0 ); +} + + +void TQXIMInputContext::setMicroFocus(int x, int y, int, int h, TQFont *f) +{ + TQWidget *widget = tqfocusWidget(); + if ( qt_xim && widget ) { + TQPoint p( x, y ); + TQPoint p2 = widget->mapTo( widget->tqtopLevelWidget(), TQPoint( 0, 0 ) ); + p = widget->tqtopLevelWidget()->mapFromGlobal( p ); + setXFontSet( f ? *f : widget->font() ); + setComposePosition(p.x(), p.y() + h); + setComposeArea(p2.x(), p2.y(), widget->width(), widget->height()); + } + +} + +void TQXIMInputContext::mouseHandler( int , TQEvent::Type type, + TQt::ButtonState button, + TQt::ButtonState) +{ + if ( type == TQEvent::MouseButtonPress || + type == TQEvent::MouseButtonDblClick ) { + // Don't reset Japanese input context here. Japanese input + // context sometimes contains a whole paragraph and has + // minutes of lifetime different to ephemeral one in other + // languages. The input context should be survived until + // focused again. + if ( ! isPreeditPreservationEnabled() ) + reset(); + } +} + +void TQXIMInputContext::setComposePosition(int x, int y) +{ +#if !defined(TQT_NO_XIM) + if (qt_xim && ic) { + XPoint point; + point.x = x; + point.y = y; + + XVaNestedList preedit_attr = + XVaCreateNestedList(0, + XNSpotLocation, &point, + + (char *) 0); + XSetICValues((XIC) ic, XNPreeditAttributes, preedit_attr, (char *) 0); + XFree(preedit_attr); + } +#endif // !TQT_NO_XIM +} + + +void TQXIMInputContext::setComposeArea(int x, int y, int w, int h) +{ +#if !defined(TQT_NO_XIM) + if (qt_xim && ic) { + XRectangle rect; + rect.x = x; + rect.y = y; + rect.width = w; + rect.height = h; + + XVaNestedList preedit_attr = XVaCreateNestedList(0, + XNArea, &rect, + + (char *) 0); + XSetICValues((XIC) ic, XNPreeditAttributes, preedit_attr, (char *) 0); + XFree(preedit_attr); + } +#endif +} + + +void TQXIMInputContext::setXFontSet(const TQFont &f) +{ +#if !defined(TQT_NO_XIM) + if (font == f) return; // nothing to do + font = f; + + XFontSet fs = getFontSet(font); + if (fontset == fs) return; // nothing to do + fontset = fs; + + XVaNestedList preedit_attr = XVaCreateNestedList(0, XNFontSet, fontset, (char *) 0); + XSetICValues((XIC) ic, XNPreeditAttributes, preedit_attr, (char *) 0); + XFree(preedit_attr); +#else + Q_UNUSED( f ); +#endif +} + + +int TQXIMInputContext::lookupString(XKeyEvent *event, TQCString &chars, + KeySym *key, tqStatus *status) const +{ + int count = 0; + +#if !defined(TQT_NO_XIM) + if (qt_xim && ic) { + count = XmbLookupString((XIC) ic, event, chars.data(), + chars.size(), key, status); + + if ((*status) == XBufferOverflow ) { + chars.resize(count + 1); + count = XmbLookupString((XIC) ic, event, chars.data(), + chars.size(), key, status); + } + } + +#endif // TQT_NO_XIM + + return count; +} + +void TQXIMInputContext::setFocus() +{ +#if !defined(TQT_NO_XIM) + if ( qt_xim && ic ) + XSetICFocus((XIC) ic); +#endif // !TQT_NO_XIM +} + +void TQXIMInputContext::unsetFocus() +{ +#if !defined(TQT_NO_XIM) + if (qt_xim && ic) + XUnsetICFocus((XIC) ic); +#endif // !TQT_NO_XIM + + // Don't reset Japanese input context here. Japanese input context + // sometimes contains a whole paragraph and has minutes of + // lifetime different to ephemeral one in other languages. The + // input context should be survived until focused again. + if ( ! isPreeditPreservationEnabled() ) + reset(); +} + + +bool TQXIMInputContext::isPreeditRelocationEnabled() +{ + return ( language() == "ja" ); +} + + +bool TQXIMInputContext::isPreeditPreservationEnabled() +{ + return ( language() == "ja" ); +} + + +TQString TQXIMInputContext::identifierName() +{ + // the name should be "xim" rather than "XIM" to be consistent + // with corresponding immodule of GTK+ + return "xim"; +} + + +TQString TQXIMInputContext::language() +{ +#if !defined(TQT_NO_XIM) + if ( qt_xim ) { + TQString locale( XLocaleOfIM( qt_xim ) ); + + if ( locale.startsWith( "zh" ) ) { + // Chinese language should be formed as "zh_CN", "zh_TW", "zh_HK" + _language = locale.left( 5 ); + } else { + // other languages should be two-letter ISO 639 language code + _language = locale.left( 2 ); + } + } +#endif + return _language; +} + +#endif //TQT_NO_IM diff --git a/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontextplugin.cpp b/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontextplugin.cpp new file mode 100644 index 0000000..b56de85 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontextplugin.cpp @@ -0,0 +1,86 @@ +/**************************************************************************** +** $Id$ +** +** Implementation of TQXIMInputContextPlugin class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQT_NO_IM +#include "tqximinputcontext.h" +#include "tqximinputcontextplugin.h" +#include +#include + + +TQXIMInputContextPlugin::TQXIMInputContextPlugin() +{ +} + +TQXIMInputContextPlugin::~TQXIMInputContextPlugin() +{ +} + +TQStringList TQXIMInputContextPlugin::keys() const +{ + return TQStringList( "xim" ); +} + +TQInputContext *TQXIMInputContextPlugin::create( const TQString & ) +{ + return new TQXIMInputContext; +} + +TQStringList TQXIMInputContextPlugin::languages( const TQString & ) +{ + return TQStringList( "" ); +} + +TQString TQXIMInputContextPlugin::displayName( const TQString & ) +{ + return tr( "XIM" ); +} + +TQString TQXIMInputContextPlugin::description( const TQString & ) +{ + return tr( "XIM input method" ); +} + + +TQ_EXPORT_PLUGIN( TQXIMInputContextPlugin ) + +#endif diff --git a/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontextplugin.h b/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontextplugin.h new file mode 100644 index 0000000..44b7465 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/xim/tqximinputcontextplugin.h @@ -0,0 +1,63 @@ +/**************************************************************************** +** $Id$ +** +** Definition of TQXIMInputContextPlugin class +** +** Copyright (C) 2004 immodule for TQt Project. All rights reserved. +** +** This file is written to contribute to Trolltech AS under their own +** licence. You may use this file under your TQt license. Following +** description is copied from their original file headers. Contact +** immodule-qt@freedesktop.org if any conditions of this licensing are +** not clear to you. +** +** +** This file is part of the input method module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQT_NO_IM +#include "tqximinputcontext.h" +#include +#include + + +class TQXIMInputContextPlugin : public TQInputContextPlugin +{ + TQ_OBJECT +public: + TQXIMInputContextPlugin(); + ~TQXIMInputContextPlugin(); + + TQStringList keys() const; + TQInputContext *create( const TQString &key ); + TQStringList languages( const TQString &key ); + TQString displayName( const TQString &key ); + TQString description( const TQString &key ); +}; + +#endif diff --git a/tqtinterface/qt4/plugins/src/inputmethods/xim/xim.pro b/tqtinterface/qt4/plugins/src/inputmethods/xim/xim.pro new file mode 100644 index 0000000..9a65291 --- /dev/null +++ b/tqtinterface/qt4/plugins/src/inputmethods/xim/xim.pro @@ -0,0 +1,14 @@ +TEMPLATE = lib +TARGET = qxim +DESTDIR = ../../../inputmethods + +INCLUDEPATH += . +CONFIG += qt warn_on debug plugin +target.path += $$plugins.path/inputmethods +INSTALLS += target + +# Input +HEADERS += qximinputcontext.h \ + qximinputcontextplugin.h +SOURCES += qximinputcontext_x11.cpp \ + qximinputcontextplugin.cpp diff --git a/tqtinterface/qt4/plugins/src/sqldrivers/ibase/ibase.pro b/tqtinterface/qt4/plugins/src/sqldrivers/ibase/ibase.pro index 30ae63e..ed1cd58 100644 --- a/tqtinterface/qt4/plugins/src/sqldrivers/ibase/ibase.pro +++ b/tqtinterface/qt4/plugins/src/sqldrivers/ibase/ibase.pro @@ -12,7 +12,7 @@ unix { OBJECTS_DIR = .obj !tqcontains( LIBS, .*gds.* ):!tqcontains( LIBS, .*libfb.* ) { - LIBS *= -lgds + LIBS *= -lfbclient } } win32 { diff --git a/tqtinterface/qt4/plugins/src/src.pro b/tqtinterface/qt4/plugins/src/src.pro index 4c41b44..98fa964 100644 --- a/tqtinterface/qt4/plugins/src/src.pro +++ b/tqtinterface/qt4/plugins/src/src.pro @@ -1,10 +1,10 @@ TEMPLATE = subdirs shared { - SUBDIRS *= accessible codecs imageformats sqldrivers styles + SUBDIRS *= accessible codecs imageformats inputmethods sqldrivers styles embedded:SUBDIRS *= gfxdrivers } dll { - SUBDIRS *= accessible codecs imageformats sqldrivers styles + SUBDIRS *= accessible codecs imageformats inputmethods sqldrivers styles embedded:SUBDIRS *= gfxdrivers } diff --git a/tqtinterface/qt4/qmake/option.cpp b/tqtinterface/qt4/qmake/option.cpp index e4d63e4..1d44b72 100644 --- a/tqtinterface/qt4/qmake/option.cpp +++ b/tqtinterface/qt4/qmake/option.cpp @@ -67,7 +67,7 @@ Option::TQMAKE_MODE Option::qmake_mode = Option::TQMAKE_GENERATE_NOTHING; //all modes int Option::warn_level = WarnLogic; int Option::debug_level = 0; -TQFile Option::output; +TQFile Option::output(""); TQString Option::output_dir; TQStringList Option::before_user_vars; TQStringList Option::after_user_vars; diff --git a/tqtinterface/qt4/src/__debian_export_symbols.cpp b/tqtinterface/qt4/src/__debian_export_symbols.cpp new file mode 100644 index 0000000..71e30ad --- /dev/null +++ b/tqtinterface/qt4/src/__debian_export_symbols.cpp @@ -0,0 +1,63 @@ +// Use the __NO_INLINE__ hack below to prevent sys/stat.h from +// exporting __extern_inline definitions of the symbols [fl]?stat64 +// with g++-4.3 or later and glibc6 >= 2.7 or later. This flag has no +// impact on [fl]?stat(64)? symbol export for glibc6 << 2.7 +// +#ifndef __NO_INLINE__ +# define __NO_INLINE__ +# define INLINE_ENABLED +#endif + +#include + +#if defined(__GLIBC_PREREQ) && __GLIBC_PREREQ(2, 7) + +// We must ensure that [fl]?stat64 are exported in the dynamic symbol +// table of libqt-mt.so.3 as weak symbols to preserve ABI. +int stat64 (__const char *__path, struct stat64 *__statbuf) __attribute__((weak)); +int lstat64 (__const char *__path, struct stat64 *__statbuf) __attribute__((weak)); +int fstat64 (int __fd, struct stat64 *__statbuf) __attribute__((weak)); + +int stat64 (__const char *__path, struct stat64 *__statbuf) +{ + return __xstat64 (_STAT_VER, __path, __statbuf); +} + +int lstat64 (__const char *__path, struct stat64 *__statbuf) +{ + return __lxstat64 (_STAT_VER, __path, __statbuf); +} + +int fstat64 (int __fd, struct stat64 *__statbuf) +{ + return __fxstat64 (_STAT_VER, __fd, __statbuf); +} + +#else +# ifndef INLINE_ENABLED +/* + * Trigger export of the extern __inline [fl]?stat64 symbols + * (defined at ) by referencing them in the dummy + * hidden function below. It's very important to reference + * [fl]?stat64 via their [fl]?stat aliases (because LARGEFILE + * is enabled) for these weak symbols to get exported. + * + * This hack is compatible with libc6-dev << 2.7 headers. + * + * This source file must be compiled with -fno-inline to have + * expected effect. + **/ +void __stat_extern_inline_export_hack() + __attribute__((visibility("hidden"))); + +void __stat_extern_inline_export_hack() { + struct stat buf; + stat("", &buf); + lstat("", &buf); + fstat(0, &buf); +} +# else +# error "This file must be compiled with inline disabled for the hack to be effective." +# endif /* INLINES_ENABLED */ + +#endif diff --git a/tqtinterface/qt4/src/codecs/tqutfcodec.cpp b/tqtinterface/qt4/src/codecs/tqutfcodec.cpp index 5b263e9..3a80d31 100644 --- a/tqtinterface/qt4/src/codecs/tqutfcodec.cpp +++ b/tqtinterface/qt4/src/codecs/tqutfcodec.cpp @@ -303,7 +303,7 @@ public: TQString toUnicode(const char* chars, int len) { TQString result; - result.setLength( len ); // worst case + result.setLength( len + 1 ); // worst case TQChar *qch = (TQChar *)result.tqunicode(); TQChar ch; while ( len-- ) { diff --git a/tqtinterface/qt4/src/dialogs/tqdialog.cpp b/tqtinterface/qt4/src/dialogs/tqdialog.cpp index 43db3ca..58093f1 100644 --- a/tqtinterface/qt4/src/dialogs/tqdialog.cpp +++ b/tqtinterface/qt4/src/dialogs/tqdialog.cpp @@ -681,6 +681,11 @@ bool TQDialog::event( TQEvent *e ) #if defined(TQ_WS_X11) extern "C" { int XSetTransientForHint( Display *, unsigned long, unsigned long ); } +#include +#undef FocusIn +// defined in qapplication_x11.cpp +extern Atom qt_net_wm_full_placement; +extern bool qt_net_supports(Atom atom); #endif // TQ_WS_X11 /*! @@ -702,10 +707,12 @@ void TQDialog::show() if ( !did_resize ) adjustSize(); - if ( has_relpos && !did_move ) { - adjustPositionInternal( parentWidget(), TRUE ); - } else if ( !did_move ) { - adjustPositionInternal( parentWidget() ); + if( !qt_net_supports( qt_net_wm_full_placement )) { + if ( has_relpos && !did_move ) { + adjustPositionInternal( parentWidget(), TRUE ); + } else if ( !did_move ) { + adjustPositionInternal( parentWidget() ); + } } if (windowState() != state) @@ -716,7 +723,7 @@ void TQDialog::show() && tqApp->mainWidget() && tqApp->mainWidget()->isVisible() && !tqApp->mainWidget()->isMinimized()) { // make sure the transient for hint is set properly for modal dialogs - XSetTransientForHint( x11Display(), winId(), tqApp->mainWidget()->winId() ); + x11SetWindowTransient( tqApp->mainWidget()); } #endif // TQ_WS_X11 @@ -811,7 +818,9 @@ void TQDialog::adjustPositionInternal( TQWidget*w, bool useRelPos) w = w->tqtopLevelWidget(); TQRect desk; if ( w ) { - scrn = TQApplication::desktop()->screenNumber( w ); + // Use mapToGlobal rather than tqgeometry() in case w might + // be embedded in another application + scrn = TQApplication::desktop()->screenNumber( w->mapToGlobal( TQPoint(0,0) ) ); } else if ( TQApplication::desktop()->isVirtualDesktop() ) { scrn = TQApplication::desktop()->screenNumber( TQCursor::pos() ); } else { diff --git a/tqtinterface/qt4/src/iconview/tqiconview.cpp b/tqtinterface/qt4/src/iconview/tqiconview.cpp index e95ff47..08ab4bd 100644 --- a/tqtinterface/qt4/src/iconview/tqiconview.cpp +++ b/tqtinterface/qt4/src/iconview/tqiconview.cpp @@ -264,6 +264,7 @@ public: TQIconViewToolTip *toolTip; TQPixmapCache maskCache; + TQPixmap *backrubber; TQPtrDict selectedItems; struct ItemContainer { @@ -1998,14 +1999,27 @@ void TQIconViewItem::paintItem( TQPainter *p, const TQColorGroup &cg ) if ( picture() ) { TQPicture *pic = picture(); if ( isSelected() ) { - p->fillRect( pixmapRect( FALSE ), TQBrush( cg.highlight(), Qt::Dense4Pattern) ); + p->setBrush( TQBrush( cg.highlight(), TQBrush::Dense4Pattern ) ); + p->setPen( TQPen( cg.highlight(), TQBrush::Dense4Pattern ) ); + p->drawRoundRect( pixmapRect( FALSE ), + 1000 / pixmapRect( FALSE ).width(), + 1000 / pixmapRect( FALSE ).height() ); } p->drawPicture( x()-pic->boundingRect().x(), y()-pic->boundingRect().y(), *pic ); if ( isSelected() ) { - p->fillRect( textRect( FALSE ), cg.highlight() ); + p->setBrush( TQBrush( cg.highlight() ) ); + p->setPen( TQPen( cg.highlight() ) ); + p->drawRoundRect( textRect( FALSE ), + 1000 / textRect( FALSE ).width(), + 1000 / textRect( FALSE ).height() ); p->setPen( TQPen( cg.highlightedText() ) ); - } else if ( view->d->itemTextBrush != Qt::NoBrush ) - p->fillRect( textRect( FALSE ), view->d->itemTextBrush ); + } else if ( view->d->itemTextBrush != Qt::NoBrush ) { + p->setBrush( view->d->itemTextBrush ); + p->setPen( TQPen( view->d->itemTextBrush.color() ) ); + p->drawRoundRect( textRect( FALSE ), + 1000 / textRect( FALSE ).width(), + 1000 / textRect( FALSE ).height() ); + } int align = view->itemTextPos() == TQIconView::Bottom ? AlignHCenter : AlignAuto; if ( view->d->wordWrapIconText ) @@ -2063,10 +2077,19 @@ void TQIconViewItem::paintItem( TQPainter *p, const TQColorGroup &cg ) p->save(); if ( isSelected() ) { - p->fillRect( textRect( FALSE ), cg.highlight() ); + p->setBrush( TQBrush( cg.highlight() ) ); + p->setPen( TQPen( cg.highlight() ) ); + p->drawRoundRect( textRect( FALSE ), + 1000 / textRect( FALSE ).width(), + 1000 / textRect( FALSE ).height() ); p->setPen( TQPen( cg.highlightedText() ) ); - } else if ( view->d->itemTextBrush != Qt::NoBrush ) - p->fillRect( textRect( FALSE ), view->d->itemTextBrush ); + } else if ( view->d->itemTextBrush != Qt::NoBrush ) { + p->setBrush( view->d->itemTextBrush ); + p->setPen( TQPen( view->d->itemTextBrush.color() ) ); + p->drawRoundRect( textRect( FALSE ), + 1000 / textRect( FALSE ).width(), + 1000 / textRect( FALSE ).height() ); + } int align = AlignHCenter; if ( view->d->wordWrapIconText ) @@ -2082,31 +2105,14 @@ void TQIconViewItem::paintItem( TQPainter *p, const TQColorGroup &cg ) /*! Paints the focus rectangle of the item using the painter \a p and the color group \a cg. + + The default implementation does nothing; subclasses may + reimplement this function. */ -void TQIconViewItem::paintFocus( TQPainter *p, const TQColorGroup &cg ) +void TQIconViewItem::paintFocus( TQPainter *p, const TQColorGroup & ) { - if ( !view ) - return; - view->tqstyle().tqdrawPrimitive(TQStyle::PE_FocusRect, p, - TQRect( textRect( FALSE ).x(), textRect( FALSE ).y(), - textRect( FALSE ).width(), - textRect( FALSE ).height() ), cg, - (isSelected() ? - TQStyle::Style_FocusAtBorder : - TQStyle::Style_Default), - TQStyleOption(isSelected() ? cg.highlight() : cg.base())); - - if ( this != view->d->currentItem ) { - view->tqstyle().tqdrawPrimitive(TQStyle::PE_FocusRect, p, - TQRect( pixmapRect( FALSE ).x(), - pixmapRect( FALSE ).y(), - pixmapRect( FALSE ).width(), - pixmapRect( FALSE ).height() ), - cg, TQStyle::Style_Default, - TQStyleOption(cg.base())); - } } /*! @@ -2804,6 +2810,7 @@ TQIconView::TQIconView( TQWidget *tqparent, const char *name, WFlags f ) d->renamingItem = 0; d->drawActiveSelection = TRUE; d->drawDragShapes = FALSE; + d->backrubber = 0; connect( d->adjustTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( adjustItems() ) ); @@ -3288,7 +3295,7 @@ uint TQIconView::count() const void TQIconView::doAutoScroll() { - TQRect oldRubber = TQRect( *d->rubber ); + TQRect oldRubber = *d->rubber; TQPoint vp = viewport()->mapFromGlobal( TQCursor::pos() ); TQPoint pos = viewportToContents( vp ); @@ -3305,7 +3312,6 @@ void TQIconView::doAutoScroll() bool block = tqsignalsBlocked(); TQRect rr; - TQRegion region( 0, 0, visibleWidth(), visibleHeight() ); blockSignals( TRUE ); viewport()->setUpdatesEnabled( FALSE ); @@ -3331,9 +3337,6 @@ void TQIconView::doAutoScroll() item->setSelected( TRUE, TRUE ); changed = TRUE; rr = rr.unite( item->rect() ); - } else { - region = region.subtract( TQRect( contentsToViewport( item->pos() ), - item->size() ) ); } minx = TQMIN( minx, item->x() - 1 ); @@ -3350,37 +3353,72 @@ void TQIconView::doAutoScroll() viewport()->setUpdatesEnabled( TRUE ); blockSignals( block ); - TQRect r = *d->rubber; - *d->rubber = oldRubber; - - TQPainter p; - p.begin( viewport() ); - p.setRasterOp( TQt::NotROP ); - p.setPen( TQPen( Qt::color0, 1 ) ); - p.setBrush( Qt::NoBrush ); - drawRubber( &p ); - d->dragging = FALSE; - p.end(); - - *d->rubber = r; - - if ( changed ) { - d->drawAllBack = FALSE; - d->clipRegion = region; - repaintContents( rr, FALSE ); - d->drawAllBack = TRUE; + // static bool drawAll; + if ( d->backrubber == 0 ) { + d->backrubber = new TQPixmap( viewport()->rect().size() ); + d->backrubber->fill( viewport(), viewport()->rect().topLeft() ); + // drawAll = true; } + // int oldX = 0, oldY = 0; + // if ( !drawAll && d->scrollTimer ) { + // oldX = contentsX(); + // oldY = contentsY(); + // } ensureVisible( pos.x(), pos.y() ); + // if ( !drawAll && d->scrollTimer && ( oldX != contentsX() || oldY != contentsY() ) ) + // drawAll = true; - p.begin( viewport() ); - p.setRasterOp( TQt::NotROP ); - p.setPen( TQPen( Qt::color0, 1 ) ); - p.setBrush( Qt::NoBrush ); - drawRubber( &p ); - d->dragging = TRUE; + TQRect allRect = oldRubber.normalize(); + if ( changed ) + allRect |= rr.normalize(); + allRect |= d->rubber->normalize(); + TQPoint point = contentsToViewport( allRect.topLeft() ); + allRect = TQRect( point.x(), point.y(), allRect.width(), allRect.height() ); + allRect &= viewport()->rect(); + + d->dragging = FALSE; + + TQPainter p( d->backrubber ); + p.translate( -contentsX(), -contentsY() ); +#if 0 + if ( !drawAll ) { + oldRubber = oldRubber.normalize(); + point = contentsToViewport( oldRubber.topLeft() ); + oldRubber = TQRect( point.x(), point.y(), oldRubber.width(), oldRubber.height() ); + oldRubber &= viewport()->rect(); + + point = contentsToViewport( nr.topLeft() ); + nr = TQRect( point.x(), point.y(), nr.width(), nr.height() ); + nr &= viewport()->rect(); + + TQRegion region; + if ( allRect != nr ) + region = TQRegion(allRect).subtract( TQRegion( nr ) ); + if ( allRect != oldRubber ) + region += TQRegion(allRect).subtract( TQRegion( oldRubber ) ); + + TQMemArray< TQRect > ar = region.rects(); + for ( uint i = 0; i < ar.size(); ++i ) { + ar[i].addCoords( -2, -2, 4, 4 ); + ar[i] = ar[i].normalize(); + + p.setClipRect( ar[i] ); + drawContents( &p, contentsX() + ar[i].left(), contentsY() + ar[i].top(), ar[i].width(), ar[i].height() ); + } + } + else +#endif + { + drawContents( &p, + contentsX() + allRect.left(), contentsY() + allRect.top(), + allRect.width(), allRect.height() ); + } p.end(); + // drawAll = false; + d->dragging = TRUE; + bitBlt( viewport(), allRect.topLeft(), d->backrubber, allRect ); if ( changed ) { emit selectionChanged(); @@ -3412,9 +3450,7 @@ void TQIconView::doAutoScroll() void TQIconView::drawContents( TQPainter *p, int cx, int cy, int cw, int ch ) { - if ( d->dragging && d->rubber ) - drawRubber( p ); - + p->save(); TQRect r = TQRect( cx, cy, cw, ch ); TQIconViewPrivate::ItemContainer *c = d->firstContainer; @@ -3488,8 +3524,16 @@ void TQIconView::drawContents( TQPainter *p, int cx, int cy, int cw, int ch ) d->currentItem->paintFocus( p, tqcolorGroup() ); } - if ( d->dragging && d->rubber ) - drawRubber( p ); + p->restore(); + if ( d->rubber ) { + p->save(); + p->translate( contentsX(), contentsY() ); + p->setRasterOp( NotROP ); + p->setPen( TQPen( color0, 1 ) ); + p->setBrush( NoBrush ); + drawRubber( p ); + p->restore(); + } } /*! @@ -4388,17 +4432,15 @@ void TQIconView::contentsMousePressEvent( TQMouseEvent *e ) void TQIconView::contentsMousePressEventEx( TQMouseEvent *e ) { if ( d->rubber ) { - TQPainter p; - p.begin( viewport() ); - p.setRasterOp( TQt::NotROP ); - p.setPen( TQPen( Qt::color0, 1 ) ); - p.setBrush( Qt::NoBrush ); + TQRect r( d->rubber->normalize() ); + delete d->rubber; + d->rubber = 0; + + repaintContents( r, FALSE ); + d->dragging = FALSE; - drawRubber( &p ); - d->dragging = FALSE; - p.end(); - delete d->rubber; - d->rubber = 0; + delete d->backrubber; + d->backrubber = 0; if ( d->scrollTimer ) { disconnect( d->scrollTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( doAutoScroll() ) ); @@ -4583,21 +4625,17 @@ void TQIconView::contentsMouseReleaseEvent( TQMouseEvent *e ) d->startDragItem = 0; if ( d->rubber ) { - TQPainter p; - p.begin( viewport() ); - p.setRasterOp( TQt::NotROP ); - p.setPen( TQPen( Qt::color0, 1 ) ); - p.setBrush( Qt::NoBrush ); - - drawRubber( &p ); - d->dragging = FALSE; - p.end(); + TQRect r(d->rubber->normalize()); if ( ( d->rubber->topLeft() - d->rubber->bottomRight() ).manhattanLength() > TQApplication::startDragDistance() ) emitClicked = FALSE; delete d->rubber; d->rubber = 0; + repaintContents(r, FALSE); + d->dragging = FALSE; + delete d->backrubber; + d->backrubber = 0; d->currentItem = d->tmpCurrentItem; d->tmpCurrentItem = 0; if ( d->currentItem ) @@ -5365,9 +5403,9 @@ void TQIconView::drawRubber( TQPainter *p ) TQPoint pnt( d->rubber->x(), d->rubber->y() ); pnt = contentsToViewport( pnt ); - tqstyle().tqdrawPrimitive(TQStyle::PE_RubberBand, p, - TQRect(pnt.x(), pnt.y(), d->rubber->width(), d->rubber->height()), - tqcolorGroup(), TQStyle::Style_Default, TQStyleOption(tqcolorGroup().base())); + tqstyle().tqdrawPrimitive( TQStyle::PE_RubberBand, p, + TQRect( pnt.x(), pnt.y(), d->rubber->width(), d->rubber->height() ).normalize(), + tqcolorGroup(), TQStyle::Style_Default, TQStyleOption(tqcolorGroup().base()) ); } /*! diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.cpp b/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.cpp new file mode 100644 index 0000000..276085d --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.cpp @@ -0,0 +1,186 @@ +/**************************************************************************** +** $Id: qinputcontextfactory.cpp,v 1.2 2004/06/20 18:43:11 daisuke Exp $ +** +** Implementation of TQInputContextFactory class +** +** Created : 001103 +** +** Copyright (C) 1992-2002 Trolltech AS. All rights reserved. +** +** This file is part of the widgets module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition licenses may use this +** file in accordance with the TQt Commercial License Agreement provided +** with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#include "tqinputcontextinterface_p.h" // up here for GCC 2.7.* compatibility +#include "tqinputcontextfactory.h" +#include "tqinputcontext.h" + +#ifndef TQT_NO_IM + +#include "tqapplication.h" + +#ifdef TQT_THREAD_SUPPORT +#include +#endif // TQT_THREAD_SUPPORT + +#include + +#include "tqcleanuphandler.h" +#include +#ifndef TQT_NO_COMPONENT + + +static TQPluginManager *manager = 0; +static TQSingleCleanupHandler< TQPluginManager > cleanup_manager; + +static void create_manager() +{ + if( manager ) // already created + return; + +#ifdef TQT_THREAD_SUPPORT + // protect manager creation + TQMutexLocker locker( qt_global_mutexpool ? + qt_global_mutexpool->get( &manager ) : 0); + + // we check the manager pointer again to make sure that another thread + // has not created the manager before us. + + if ( manager ) // already created + return; +#endif + + manager = new TQPluginManager( IID_TQInputContextFactory, TQApplication::libraryPaths(), "/inputmethods", FALSE ); + + Q_CHECK_PTR( manager ); + cleanup_manager.set( &manager ); +} + +#endif //TQT_NO_COMPONENT + + +/*! + This function generates the input context that has the identifier + name which is in agreement with \a key. \a widget is the client + widget of TQInputContext. \a widget may be null. +*/ +TQInputContext *TQInputContextFactory::create( const TQString& key, TQWidget *widget ) +{ + TQInputContext *ret = 0; + TQString inputcontext = key; +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + TQInterfacePtr iface; + manager->queryInterface( inputcontext, &iface ); + + if ( iface ) { + ret = iface->create( inputcontext ); +#ifdef TQ_WS_X11 + if ( ret ) + ret->setHolderWidget( widget ); +#endif + } +#endif + return ret; +} + + +/*! + This function returns the list of the names input methods. + Only input methods included in default and placed under + $TQTDIR/plugins/inputmethods are listed. +*/ +TQStringList TQInputContextFactory::keys() +{ + TQStringList list; +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + list = manager->featureList(); +#endif //TQT_NO_COMPONENT + + return list; +} + + +TQStringList TQInputContextFactory::languages( const TQString &key ) +{ + TQStringList result; +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + TQInterfacePtr iface; + manager->queryInterface( key, &iface ); + + if ( iface ) + result = iface->languages( key ); +#endif //TQT_NO_COMPONENT + + return result; +} + + +TQString TQInputContextFactory::displayName( const TQString &key ) +{ + TQString result( "" ); +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + TQInterfacePtr iface; + manager->queryInterface( key, &iface ); + + if ( iface ) + result = iface->displayName( key ); +#endif //TQT_NO_COMPONENT + + return result; +} + + +TQString TQInputContextFactory::description( const TQString &key ) +{ + TQString result( "" ); +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + TQInterfacePtr iface; + manager->queryInterface( key, &iface ); + + if ( iface ) + result = iface->description( key ); +#endif //TQT_NO_COMPONENT + + return result; +} + +#endif // TQT_NO_IM diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.h b/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.h new file mode 100644 index 0000000..ea97f83 --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.h @@ -0,0 +1,59 @@ +/**************************************************************************** +** $Id: qinputcontextfactory.h,v 1.1.1.1 2004/05/11 11:16:49 daisuke Exp $ +** +** Definition of TQInputContextFactory class +** +** Copyright (C) 2000-2002 Trolltech AS. All rights reserved. +** +** This file is part of the widgets module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQINPUTCONTEXTFACTORY_H +#define TQINPUTCONTEXTFACTORY_H + +#ifndef TQT_H +#include "tqstringlist.h" +#endif // TQT_H + +#ifndef TQT_NO_IM + +class TQInputContext; +class TQWidget; + +class TQ_EXPORT TQInputContextFactory +{ +public: + static TQStringList keys(); + static TQInputContext *create( const TQString &key, TQWidget *widget ); // should be a toplevel widget + static TQStringList languages( const TQString &key ); + static TQString displayName( const TQString &key ); + static TQString description( const TQString &key ); +}; +#endif //TQT_NO_IM + +#endif //TQINPUTCONTEXTFACTORY_H diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextinterface_p.h b/tqtinterface/qt4/src/inputmethod/tqinputcontextinterface_p.h new file mode 100644 index 0000000..be91171 --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextinterface_p.h @@ -0,0 +1,87 @@ +/**************************************************************************** +** $Id: qinputcontextinterface_p.h,v 1.2 2004/06/20 18:43:11 daisuke Exp $ +** +** ... +** +** Copyright (C) 2000-2002 Trolltech AS. All rights reserved. +** +** This file is part of the widgets module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQINPUTCONTEXTINTERFACE_P_H +#define TQINPUTCONTEXTINTERFACE_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the TQt API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef TQT_H +#include +#endif // TQT_H + +#ifndef TQT_NO_IM +#ifndef TQT_NO_COMPONENT + +class TQWidget; +class TQInputContext; + +// old version interface in qt-x11-immodule-bc-qt3.3.2-20040623.diff: +// {6C2B9EDE-B63C-14c9-A729-3C7643739C4C} +// +// new version interface: +// {a5f5c63d-e044-11d8-9718-000d6077a78d} +// {b0bf3e59-e526-11d8-80da-000d6077a78d} +// {9ef05c7f-0272-11d9-846c-000d6077a78d} + +#ifndef IID_TQInputContextFactory +//#define IID_TQInputContextFactory TQUuid(0x6c2b9ede, 0xb63c, 0x14c9, 0xa7, 0x29, 0x3c, 0x76, 0x43, 0x73, 0x9c, 0x4c) +//#define IID_TQInputContextFactory TQUuid(0xa5f5c63d, 0xe044, 0x11d8, 0x97, 0x18, 0x00, 0x0d, 0x60, 0x77, 0xa7, 0x8d) +//#define IID_TQInputContextFactory TQUuid(0xb0bf3e59, 0xe526, 0x11d8, 0x80, 0xda, 0x00, 0x0d, 0x60, 0x77, 0xa7, 0x8d) +#define IID_TQInputContextFactory TQUuid(0x9ef05c7f, 0x0272, 0x11d9, 0x84, 0x6c, 0x00, 0x0d, 0x60, 0x77, 0xa7, 0x8d) +#endif + +struct TQ_EXPORT TQInputContextFactoryInterface : public TQFeatureListInterface +{ + virtual TQInputContext *create( const TQString &key ) = 0; + virtual TQStringList languages( const TQString &key ) = 0; + virtual TQString displayName( const TQString &key ) = 0; + virtual TQString description( const TQString &key ) = 0; +}; + +#endif //TQT_NO_COMPONENT +#endif //TQT_NO_IM + +#endif //TQINPUTCONTEXTINTERFACE_P_H diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.cpp b/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.cpp new file mode 100644 index 0000000..d8a728e --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.cpp @@ -0,0 +1,231 @@ +/**************************************************************************** +** $Id: qinputcontextplugin.cpp,v 1.2 2004/06/20 18:43:11 daisuke Exp $ +** +** Implementation of TQInputContextPlugin class +** +** Created : 010920 +** +** Copyright (C) 2001 Trolltech AS. All rights reserved. +** +** This file is part of the widgets module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#include "tqinputcontextplugin.h" + +#ifndef TQT_NO_IM +#ifndef TQT_NO_COMPONENT + +#include "tqinputcontextinterface_p.h" + +/*! + \class TQInputContextPlugin qinputcontextplugin.h + \brief The TQInputContextPlugin class provides an abstract base for custom TQInputContext plugins. + \reentrant + \ingroup plugins + + The input context plugin is a simple plugin interface that makes it + easy to create custom input contexts that can be loaded dynamically + into applications. + + Writing a input context plugin is achieved by subclassing this + base class, reimplementing the pure virtual functions keys(), + create(), languages(), displayName() description() and exporting + the class with the \c TQ_EXPORT_PLUGIN macro. See the \link + plugins-howto.html TQt Plugins documentation \endlink for details. + + \sa TQInputContext +*/ + +/*! + \fn TQStringList TQInputContextPlugin::keys() const + + Returns the list of TQInputContext keys this plugin provides. + + These keys are usually the class names of the custom input context + that are implemented in the plugin. + + Return value is the names to identify and specify input methods + for the input method switching mechanism and so on. The names have + to be consistent with TQInputContext::identifierName(). The names + have to consist of ASCII characters only. See also + TQInputContext::identifierName() for further information. + + \sa create(), displayName(), TQInputContext::identifierName() +*/ + +/*! + \fn TQInputContext* TQInputContextPlugin::create( const TQString& key ) + + Creates and returns a TQInputContext instance for the input context key \a key. + The input context key is usually the class name of the required input method. + + \sa keys() +*/ + +/*! + \fn TQStringList languages( const TQString &key ) + + Returns what languages are supported by the TQInputContext instance + specified by \a key. + + The languages are expressed as language code (e.g. "zh_CN", + "zh_TW", "zh_HK", "ja", "ko", ...). An input context that suports + multiple languages can return all supported languages as + TQStringList. The name has to be consistent with + TQInputContextPlugin::language(). + + This information may be used to optimize user interface. + + \sa TQInputContext::language() +*/ + +/*! + \fn TQString displayName( const TQString &key ) + + Returns a user friendly i18n-ized name of the TQInputContext + instance specified by \a key. This string may be appeared in a + menu and so on for users. + + There are two different names with different responsibility in the + input method domain. This function returns one of them. Another + name is called 'identifier name' to identify and specify input + methods for the input method switching mechanism and so on. + + Although tr( identifierName ) can provide user friendly i18n-ized + name without this function, the message catalog have to be managed + by TQt in the case. However, some sophisticated input method + framework manages their own message catalogs to provide this + i18n-ized name string. So we need this function rather than just + call tr() for identifier name. + + \sa keys(), TQInputContext::identifierName() +*/ + +/*! + \fn TQString description( const TQString &key ) + + Returns a i18n-ized brief description of the TQInputContext + instance specified by \a key. This string may be appeared in some + user interfaces. +*/ + + + +class TQInputContextPluginPrivate : public TQInputContextFactoryInterface +{ +public: + TQInputContextPluginPrivate( TQInputContextPlugin *p ) + : plugin( p ) + { + } + + virtual ~TQInputContextPluginPrivate(); + + TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface ); + TQ_REFCOUNT; + + TQStringList featureList() const; + TQInputContext *create( const TQString &key ); + TQStringList languages( const TQString &key ); + TQString displayName( const TQString &key ); + TQString description( const TQString &key ); + +private: + TQInputContextPlugin *plugin; +}; + +TQRESULT TQInputContextPluginPrivate::queryInterface( const TQUuid &iid, TQUnknownInterface **iface ) +{ + *iface = 0; + + if ( iid == IID_TQUnknown ) + *iface = this; + else if ( iid == IID_TQFeatureList ) + *iface = this; + else if ( iid == IID_TQInputContextFactory ) + *iface = this; + else + return TQE_NOINTERFACE; + + (*iface)->addRef(); + return TQS_OK; +} + +TQInputContextPluginPrivate::~TQInputContextPluginPrivate() +{ + delete plugin; +} + +TQStringList TQInputContextPluginPrivate::featureList() const +{ + return plugin->keys(); +} + +TQInputContext *TQInputContextPluginPrivate::create( const TQString &key ) +{ + return plugin->create( key ); +} + +TQStringList TQInputContextPluginPrivate::languages( const TQString &key ) +{ + return plugin->languages( key ); +} + +TQString TQInputContextPluginPrivate::displayName( const TQString &key ) +{ + return plugin->displayName( key ); +} + +TQString TQInputContextPluginPrivate::description( const TQString &key ) +{ + return plugin->description( key ); +} + + +/*! + Constructs a input context plugin. This is invoked automatically by the + \c TQ_EXPORT_PLUGIN macro. +*/ +TQInputContextPlugin::TQInputContextPlugin() + : TQGPlugin( d = new TQInputContextPluginPrivate( this ) ) +{ +} + +/*! + Destroys the input context plugin. + + You never have to call this explicitly. TQt destroys a plugin + automatically when it is no longer used. +*/ +TQInputContextPlugin::~TQInputContextPlugin() +{ + // don't delete d, as this is deleted by d +} + +#endif // TQT_NO_COMPONENT +#endif // TQT_NO_IM diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.h b/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.h new file mode 100644 index 0000000..3c50cc2 --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.h @@ -0,0 +1,67 @@ +/**************************************************************************** +** $Id: qinputcontextplugin.h,v 1.2 2004/06/20 18:43:11 daisuke Exp $ +** +** Definition of TQInputContextPlugin class +** +** Created : 010920 +** +** Copyright (C) 2001 Trolltech AS. All rights reserved. +** +** This file is part of the tools module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQINPUTCONTEXTPLUGIN_H +#define TQINPUTCONTEXTPLUGIN_H + +#ifndef TQT_H +#include "tqgplugin.h" +#include "tqstringlist.h" +#endif // TQT_H + +#ifndef TQT_NO_IM +class TQInputContext; +class TQInputContextPluginPrivate; + +class TQ_EXPORT TQInputContextPlugin : public TQGPlugin +{ + TQ_OBJECT +public: + TQInputContextPlugin(); + ~TQInputContextPlugin(); + + virtual TQStringList keys() const = 0; + virtual TQInputContext *create( const TQString &key ) = 0; + virtual TQStringList languages( const TQString &key ) = 0; + virtual TQString displayName( const TQString &key ) = 0; + virtual TQString description( const TQString &key ) = 0; + +private: + TQInputContextPluginPrivate *d; +}; +#endif // TQT_NO_IM +#endif // TQINPUTCONTEXTPLUGIN_H diff --git a/tqtinterface/qt4/src/inputmethod/tqt_inputmethod.pri b/tqtinterface/qt4/src/inputmethod/tqt_inputmethod.pri new file mode 100644 index 0000000..0d48026 --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqt_inputmethod.pri @@ -0,0 +1,10 @@ +# TQt inputmetod module + +inputmethod { + INPUTMETHOD_P = inputmethod + HEADERS +=$$INPUTMETHOD_H/qinputcontextfactory.h \ + $$INPUTMETHOD_P/qinputcontextinterface_p.h \ + $$INPUTMETHOD_H/qinputcontextplugin.h + SOURCES +=$$INPUTMETHOD_CPP/qinputcontextfactory.cpp \ + $$INPUTMETHOD_CPP/qinputcontextplugin.cpp +} diff --git a/tqtinterface/qt4/src/kernel/qt_kernel.pri b/tqtinterface/qt4/src/kernel/qt_kernel.pri index aa76de0..f10ed74 100644 --- a/tqtinterface/qt4/src/kernel/qt_kernel.pri +++ b/tqtinterface/qt4/src/kernel/qt_kernel.pri @@ -34,7 +34,6 @@ kernel { $$KERNEL_H/tqimage.h \ $$KERNEL_P/tqimageformatinterface_p.h \ $$KERNEL_H/tqimageformatplugin.h \ - $$KERNEL_P/tqinputcontext_p.h \ $$KERNEL_H/tqkeycode.h \ $$KERNEL_H/tqkeysequence.h \ $$KERNEL_H/tqlayout.h \ @@ -99,6 +98,12 @@ kernel { $$KERNEL_CPP/tqfontengine_p.h \ $$KERNEL_CPP/tqtextlayout_p.h + unix:x11 { + HEADERS += $$KERNEL_H/tqinputcontext.h + } else { + HEADERS += $$KERNEL_P/tqinputcontext_p.h + } + win32:SOURCES += $$KERNEL_CPP/tqapplication_win.cpp \ $$KERNEL_CPP/tqclipboard_win.cpp \ $$KERNEL_CPP/tqcolor_win.cpp \ @@ -130,6 +135,7 @@ kernel { $$KERNEL_CPP/tqdesktopwidget_x11.cpp \ $$KERNEL_CPP/tqeventloop_x11.cpp \ $$KERNEL_CPP/tqfont_x11.cpp \ + $$KERNEL_CPP/tqinputcontext.cpp \ $$KERNEL_CPP/tqinputcontext_x11.cpp \ $$KERNEL_CPP/tqmotifdnd_x11.cpp \ $$KERNEL_CPP/tqpixmap_x11.cpp \ diff --git a/tqtinterface/qt4/src/kernel/tqapplication.cpp b/tqtinterface/qt4/src/kernel/tqapplication.cpp index af193c9..74d2f08 100644 --- a/tqtinterface/qt4/src/kernel/tqapplication.cpp +++ b/tqtinterface/qt4/src/kernel/tqapplication.cpp @@ -4113,6 +4113,35 @@ void TQApplication::postEvent( TQObject *receiver, TQEvent *event ) }; } +#if !defined(TQT_NO_IM) + // if this is one of the compressible IM events, do compression + else if ( event->type() == TQEvent::IMCompose ) { + l->last(); + TQPostEvent * cur = 0; + for ( ;; ) { + while ( (cur=l->current()) != 0 && + ( cur->receiver != receiver || + cur->event == 0 || + cur->event->type() != event->type() || + cur->event->type() != TQEvent::IMStart ) ) + l->prev(); + if ( l->current() != 0 ) { + // IMCompose must not be compressed with another one + // beyond its IMStart boundary + if ( cur->event->type() == TQEvent::IMStart ) { + break; + } else if ( cur->event->type() == TQEvent::IMCompose ) { + TQIMComposeEvent * e = (TQIMComposeEvent *)(cur->event); + *e = *(TQIMComposeEvent *)event; + delete event; + return; + } + } + break; + }; + } +#endif + // if no compression could be done, just append something event->posted = TRUE; TQPostEvent * pe = new TQPostEvent( receiver, event ); @@ -4258,6 +4287,23 @@ void TQApplication::sendPostedEvents( TQObject *receiver, int event_type ) */ void TQApplication::removePostedEvents( TQObject *receiver ) +{ + removePostedEvents( receiver, 0 ); +} + +/*! + Removes all events that have the event type \a event_type posted + using postEvent() for \a receiver. + + The events are \e not dispatched, instead they are removed from the + queue. + + If \a event_type is 0, all the events are removed from the queue. + + \threadsafe +*/ + +void TQApplication::removePostedEvents( TQObject *receiver, int event_type ) { if ( !receiver ) return; @@ -4277,18 +4323,24 @@ void TQApplication::removePostedEvents( TQObject *receiver ) // leave the TQPostEvent objects; they'll be deleted by // sendPostedEvents(). TQPostEventList * l = receiver->postedEvents; - receiver->postedEvents = 0; l->first(); TQPostEvent * pe; while( (pe=l->current()) != 0 ) { - if ( pe->event ) { - pe->event->posted = FALSE; - delete pe->event; - pe->event = 0; + if ( !event_type || pe->event->type() == event_type ) { + if ( pe->event ) { + pe->event->posted = FALSE; + delete pe->event; + pe->event = 0; + } + l->remove(); + } else { + l->next(); } - l->remove(); } - delete l; + if ( !event_type || !l->count() ) { + receiver->postedEvents = 0; + delete l; + } } @@ -4473,6 +4525,8 @@ void TQApplication::setActiveWindow( TQWidget* act ) focus_widget = 0; #ifdef TQ_WS_WIN TQInputContext::accept( tmp ); +#elif defined(TQ_WS_X11) + tmp->unfocusInputContext(); #endif TQApplication::sendSpontaneousEvent( tmp, &out ); } else if ( active_window ) { diff --git a/tqtinterface/qt4/src/kernel/tqapplication.h b/tqtinterface/qt4/src/kernel/tqapplication.h index 2be7c02..e5e2ea9 100644 --- a/tqtinterface/qt4/src/kernel/tqapplication.h +++ b/tqtinterface/qt4/src/kernel/tqapplication.h @@ -67,6 +67,9 @@ class TQSessionManager; class TQStyle; class TQTranslator; class TQEventLoop; +#if defined(TQ_WS_X11) +class TQIMEvent; +#endif #if defined(TQ_WS_TQWS) class TQWSDecoration; #endif @@ -467,8 +470,19 @@ public: virtual void saveState( TQSessionManager& sm ); #endif #if defined(TQ_WS_X11) +#if !defined(TQT_NO_IM_EXTENSIONS) + virtual TQWidget *locateICHolderWidget( TQWidget *w ); + virtual TQWidgetList *icHolderWidgets(); + static void create_im(); + static void close_im(); +#else + TQWidget *locateICHolderWidget( TQWidget *w ); + TQWidgetList *icHolderWidgets(); static void create_xim(); static void close_xim(); +#endif + static TQString defaultInputMethod(); + void changeAllInputContext( const TQString & ); static bool x11_apply_settings(); #endif void wakeUpGuiThread(); @@ -523,6 +537,12 @@ private: friend void qt_init(int *, char **, TQApplication::Type); #endif +#if defined(TQ_WS_X11) +private slots: + void postIMEvent( TQObject *receiver, TQIMEvent *event ); +#endif + +private: #ifdef TQT_THREAD_SUPPORT static TQMutex *qt_mutex; #endif // TQT_THREAD_SUPPORT @@ -572,9 +592,12 @@ private: static TQString* session_key; bool is_session_restored; #endif -#if defined(TQ_WS_X11) && !defined (TQT_NO_STYLE ) +#if defined(TQ_WS_X11) +#if !defined (TQT_NO_STYLE) static void x11_initialize_style(); #endif + static TQString defaultIM; // default input method's name in this application. +#endif static TQSize app_strut; #ifndef TQT_NO_COMPONENT @@ -591,6 +614,7 @@ private: static bool sendSpontaneousEvent( TQObject *receiver, TQEvent *event ); static void removePostedEvent( TQEvent * ); + static void removePostedEvents( TQObject *receiver, int event_type ); friend class TQWidget; friend class TQETWidget; diff --git a/tqtinterface/qt4/src/kernel/tqapplication_x11.cpp b/tqtinterface/qt4/src/kernel/tqapplication_x11.cpp index 48616bf..e7cf92f 100644 --- a/tqtinterface/qt4/src/kernel/tqapplication_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqapplication_x11.cpp @@ -92,7 +92,9 @@ #include "tqfileinfo.h" // Input method stuff - UNFINISHED -#include "tqinputcontext_p.h" +#ifndef TQT_NO_IM +#include "tqinputcontext.h" +#endif // TQT_NO_IM #include "tqinternal_p.h" // shared double buffer cleanup #if defined(TQT_THREAD_SUPPORT) @@ -114,6 +116,7 @@ extern "C" Bool XftInitFtLibrary(void); #include #include #include +#include //#define X_NOT_BROKEN #ifdef X_NOT_BROKEN @@ -271,10 +274,16 @@ Atom qt_net_wm_window_type_menu = 0; Atom qt_net_wm_window_type_utility = 0; Atom qt_net_wm_window_type_splash = 0; Atom qt_net_wm_window_type_override = 0; // KDE extension +Atom qt_net_wm_window_type_dropdown_menu = 0; +Atom qt_net_wm_window_type_popup_menu = 0; +Atom qt_net_wm_window_type_tooltip = 0; +Atom qt_net_wm_window_type_combo = 0; +Atom qt_net_wm_window_type_dnd = 0; Atom qt_net_wm_frame_strut = 0; // KDE extension Atom qt_net_wm_state_stays_on_top = 0; // KDE extension Atom qt_net_wm_pid = 0; Atom qt_net_wm_user_time = 0; +Atom qt_net_wm_full_placement = 0; // KDE extension // Enlightenment support Atom qt_enlightenment_desktop = 0; @@ -284,6 +293,11 @@ Atom *qt_net_supported_list = 0; Window *qt_net_virtual_root_list = 0; +// X11 SYNC support +#ifndef TQT_NO_XSYNC +Atom qt_net_wm_sync_request_counter = 0; +Atom qt_net_wm_sync_request = 0; +#endif // client leader window Window qt_x11_wm_client_leader = 0; @@ -308,6 +322,13 @@ static int xrandr_eventbase; // Display TQ_EXPORT bool qt_use_xrender = FALSE; +#ifndef TQT_NO_XSYNC +// True if SYNC extension exists on the connected display +bool qt_use_xsync = FALSE; +static int xsync_eventbase; +static int xsync_errorbase; +#endif + // modifier masks for alt/meta - detected when the application starts static long qt_alt_mask = 0; static long qt_meta_mask = 0; @@ -1709,17 +1730,28 @@ void qt_init_internal( int *argcptr, char **argv, qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_UTILITY", &qt_net_wm_window_type_utility ); qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_SPLASH", &qt_net_wm_window_type_splash ); qt_x11_intern_atom( "_KDE_NET_WM_WINDOW_TYPE_OVERRIDE", &qt_net_wm_window_type_override ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", &qt_net_wm_window_type_dropdown_menu ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_POPUP_MENU", &qt_net_wm_window_type_popup_menu ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_TOOLTIP", &qt_net_wm_window_type_tooltip ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_COMBO", &qt_net_wm_window_type_combo ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_DND", &qt_net_wm_window_type_dnd ); qt_x11_intern_atom( "_KDE_NET_WM_FRAME_STRUT", &qt_net_wm_frame_strut ); qt_x11_intern_atom( "_NET_WM_STATE_STAYS_ON_TOP", &qt_net_wm_state_stays_on_top ); qt_x11_intern_atom( "_NET_WM_PID", &qt_net_wm_pid ); qt_x11_intern_atom( "_NET_WM_USER_TIME", &qt_net_wm_user_time ); + qt_x11_intern_atom( "_NET_WM_FULL_PLACEMENT", &qt_net_wm_full_placement ); qt_x11_intern_atom( "ENLIGHTENMENT_DESKTOP", &qt_enlightenment_desktop ); qt_x11_intern_atom( "_NET_WM_NAME", &qt_net_wm_name ); qt_x11_intern_atom( "_NET_WM_ICON_NAME", &qt_net_wm_icon_name ); qt_x11_intern_atom( "UTF8_STRING", &qt_utf8_string ); qt_x11_intern_atom( "_SGI_DESKS_MANAGER", &qt_sgi_desks_manager ); +#ifndef TQT_NO_XSYNC + qt_x11_intern_atom( "_NET_WM_SYNC_REQUEST_COUNTER", &qt_net_wm_sync_request_counter ); + qt_x11_intern_atom( "_NET_WM_SYNC_REQUEST", &qt_net_wm_sync_request ); +#endif + qt_xdnd_setup(); qt_x11_motifdnd_init(); @@ -1756,6 +1788,15 @@ void qt_init_internal( int *argcptr, char **argv, } #endif // TQT_NO_XRENDER +#ifndef TQT_NO_XSYNC + // Try to initialize SYNC extension on the connected display + int xsync_major, xsync_minor; + if ( XSyncQueryExtension( appDpy, &xsync_eventbase, &xsync_errorbase ) && + XSyncInitialize( appDpy, &xsync_major, &xsync_minor ) ) { + qt_use_xsync = TRUE; + } +#endif + #ifndef TQT_NO_XKB // If XKB is detected, set the GrabsUseXKBState option so input method // compositions continue to work (ie. deadkeys) @@ -2731,10 +2772,9 @@ static const char *appBTNCol = 0; // application btn color static const char *mwGeometry = 0; // main widget tqgeometry static const char *mwTitle = 0; // main widget title //Ming-Che 10/10 -static char *ximServer = 0; // XIM Server will connect to +char *qt_ximServer = 0; // XIM Server will connect to static bool mwIconic = FALSE; // main widget iconified //Ming-Che 10/10 -static bool noxim = FALSE; // connect to xim or not static Display *appDpy = 0; // X11 application display static char *appDpyName = 0; // X11 display name static bool appForeignDpy = FALSE; // we didn't create display @@ -2933,14 +2973,14 @@ static bool qt_x11EventFilter( XEvent* ev ) #if !defined(TQT_NO_XIM) -XIM qt_xim = 0; +//XIM qt_xim = 0; XIMStyle qt_xim_style = 0; +XIMStyle qt_xim_preferred_style = 0; static XIMStyle xim_default_style = XIMPreeditCallbacks | XIMStatusNothing; -static XIMStyle xim_preferred_style = 0; #endif -static int composingKeycode=0; -static TQTextCodec * input_mapper = 0; +int qt_ximComposingKeycode=0; +TQTextCodec * qt_input_mapper = 0; extern bool qt_check_clipboard_sentinel(); //def in qclipboard_x11.cpp extern bool qt_check_selection_sentinel(); //def in qclipboard_x11.cpp @@ -3051,8 +3091,7 @@ public: void setWFlags( WFlags f ) { TQWidget::setWFlags(f); } void clearWFlags( WFlags f ) { TQWidget::clearWFlags(f); } bool translateMouseEvent( const XEvent * ); - bool translateKeyEventInternal( const XEvent *, int& count, TQString& text, int& state, char& ascii, int &code, - TQEvent::Type &type, bool willRepeat=FALSE ); + bool translateKeyEventInternal( const XEvent *, int& count, TQString& text, int& state, char& ascii, int &code, TQEvent::Type &type, bool willRepeat=FALSE, bool statefulTranslation=TRUE ); bool translateKeyEvent( const XEvent *, bool grab ); bool translatePaintEvent( const XEvent * ); bool translateConfigEvent( const XEvent * ); @@ -3069,114 +3108,120 @@ public: // ************************************************************************ -// X Input Method support +// Input Method support // ************************************************************************ -#if !defined(TQT_NO_XIM) +/*! + An identifier name of the default input method. +*/ +TQString TQApplication::defaultIM = "imsw-multi"; -#if defined(TQ_C_CALLBACKS) -extern "C" { -#endif // TQ_C_CALLBACKS -#ifdef USE_X11R6_XIM - static void xim_create_callback(XIM /*im*/, - XPointer /*client_data*/, - XPointer /*call_data*/) - { - // qDebug("xim_create_callback"); - TQApplication::create_xim(); - } +/*! + This function handles the query about location of the widget + holding the TQInputContext instance for widget \a w. - static void xim_destroy_callback(XIM /*im*/, - XPointer /*client_data*/, - XPointer /*call_data*/) - { - // qDebug("xim_destroy_callback"); - TQApplication::close_xim(); - XRegisterIMInstantiateCallback(appDpy, 0, 0, 0, - (XIMProc) xim_create_callback, 0); - } + The input context is used for text input to widget \a w. By + default, it returns the top-level widget of \a w. -#endif // USE_X11R6_XIM + If you want to change the mapping of widget \w to TQInputContext + instance, reimplement both this function and + TQApplication::icHolderWidgets(). For example, suppose a tabbed web + browser. The browser should allocate a input context per tab + widget because users may switch the tabs and input a new text + during previous input contexts live. -#if defined(TQ_C_CALLBACKS) + See also 'Sharing input context between text widgets' and 'Preedit + preservation' section of the class description of TQInputContext. + + \sa TQInputContext, icHolderWidgets() +*/ +TQWidget *TQApplication::locateICHolderWidget( TQWidget *w ) +{ + return w->tqtopLevelWidget(); } -#endif // TQ_C_CALLBACKS -#endif // TQT_NO_XIM +/*! + This function returns all widgets holding TQInputContext. -/*! \internal - Creates the application input method. - */ -void TQApplication::create_xim() + By default, This function returns top-level widgets. So if you + want to change the mapping of a widget to TQInputContext instance, + you must override this function and locateICHolderWidget(). + + \sa locateICHolderWidget() +*/ +TQWidgetList *TQApplication::icHolderWidgets() { -#ifndef TQT_NO_XIM - qt_xim = XOpenIM( appDpy, 0, 0, 0 ); - if ( qt_xim ) { + return TQApplication::tqtopLevelWidgets(); +} -#ifdef USE_X11R6_XIM - XIMCallback destroy; - destroy.callback = (XIMProc) xim_destroy_callback; - destroy.client_data = 0; - if ( XSetIMValues( qt_xim, XNDestroyCallback, &destroy, (char *) 0 ) != 0 ) - qWarning( "Xlib dosn't support destroy callback"); -#endif // USE_X11R6_XIM - XIMStyles *styles = 0; - XGetIMValues(qt_xim, XNQueryInputStyle, &styles, (char *) 0, (char *) 0); - if ( styles ) { - int i; - for ( i = 0; !qt_xim_style && i < styles->count_styles; i++ ) { - if ( styles->supported_styles[i] == xim_preferred_style ) { - qt_xim_style = xim_preferred_style; - break; - } - } - // if the preferred input style couldn't be found, look for - // Nothing - for ( i = 0; !qt_xim_style && i < styles->count_styles; i++ ) { - if ( styles->supported_styles[i] == (XIMPreeditNothing | - XIMStatusNothing) ) { - qt_xim_style = XIMPreeditNothing | XIMStatusNothing; - break; - } - } - // ... and failing that, None. - for ( i = 0; !qt_xim_style && i < styles->count_styles; i++ ) { - if ( styles->supported_styles[i] == (XIMPreeditNone | - XIMStatusNone) ) { - qt_xim_style = XIMPreeditNone | XIMStatusNone; - break; - } - } +/*! + This function replaces all TQInputContext instances in the + application. The function's argument is the identifier name of + the newly selected input method. +*/ +void TQApplication::changeAllInputContext( const TQString &identifierName ) +{ + TQWidgetList *list = tqApp->icHolderWidgets(); + TQWidgetListIt it(*list); + while(it.current()) { + it.current()->changeInputContext( identifierName ); + ++it; + } + delete list; - // qDebug("TQApplication: using im style %lx", qt_xim_style); - XFree( (char *)styles ); - } + // defaultIM = identifierName ; // Change of defaultIM -- default input method -- may be enabled. +} - if ( qt_xim_style ) { -#ifdef USE_X11R6_XIM - XUnregisterIMInstantiateCallback(appDpy, 0, 0, 0, - (XIMProc) xim_create_callback, 0); -#endif // USE_X11R6_XIM +/*! + \internal + This is an internal function, you should never call this. - TQWidgetList *list= tqApp->tqtopLevelWidgets(); - TQWidgetListIt it(*list); - TQWidget * w; - while( (w=it.current()) != 0 ) { - ++it; - w->createTLSysExtra(); - } - delete list; - } else { - // Give up - qWarning( "No supported input style found." - " See InputMethod documentation."); - close_xim(); - } + \sa TQInputContext::imEventGenerated() +*/ +void TQApplication::postIMEvent( TQObject *receiver, TQIMEvent *event ) +{ + if ( event->type() == TQEvent::IMCompose ) { + // enable event compression to reduce preedit flicker on fast + // typing + postEvent( receiver, event ); + } else { + // cancel queued preedit update + if ( event->type() == TQEvent::IMEnd ) + removePostedEvents( receiver, TQEvent::IMCompose ); + + // to avoid event receiving order inversion between TQKeyEvent + // and TQIMEvent, we must send IMStart and IMEnd via + // sendEvent(). + sendEvent( receiver, event ); + delete event; } +} + + +/*! + This function returns the identifier name of the default input + method in this Application. The value is identical to the value of + TQApplication::defaultIM. +*/ +TQString TQApplication::defaultInputMethod() +{ + return TQApplication::defaultIM; +} + + +#if !defined(TQT_NO_IM_EXTENSIONS) +/*! \internal + Creates the application input method. +*/ +void TQApplication::create_im() +{ +#ifndef TQT_NO_XIM + if ( ! qt_xim_preferred_style ) // no configured input style, use the default + qt_xim_preferred_style = xim_default_style; #endif // TQT_NO_XIM } @@ -3184,6 +3229,43 @@ void TQApplication::create_xim() /*! \internal Closes the application input method. */ +void TQApplication::close_im() +{ + TQWidgetList *list = tqApp->icHolderWidgets(); + TQWidgetListIt it(*list); + while(it.current()) { + it.current()->destroyInputContext(); + ++it; + } + delete list; +} + +#else + +/*! \internal + Creates the application input method. +*/ +void TQApplication::create_xim() +{ +#ifndef TQT_NO_XIM + if ( ! qt_xim_preferred_style ) // no configured input style, use the default + qt_xim_preferred_style = xim_default_style; +#endif // TQT_NO_XIM + + TQWidgetList *list= tqApp->tqtopLevelWidgets(); + TQWidgetListIt it(*list); + TQWidget * w; + while( (w=it.current()) != 0 ) { + ++it; + w->createTLSysExtra(); + } + delete list; +} + + + /*! \internal + Closes the application input method. + */ void TQApplication::close_xim() { #ifndef TQT_NO_XIM @@ -3191,7 +3273,10 @@ void TQApplication::close_xim() // XCloseIM( qt_xim ); // We prefer a less serious memory leak - qt_xim = 0; + // if ( qt_xim ) + // qt_xim = 0; + +#endif // TQT_NO_XIM TQWidgetList *list = tqApp->tqtopLevelWidgets(); TQWidgetListIt it(*list); while(it.current()) { @@ -3199,9 +3284,8 @@ void TQApplication::close_xim() ++it; } delete list; -#endif // TQT_NO_XIM } - +#endif /***************************************************************************** Default X error handlers @@ -3572,18 +3656,40 @@ bool TQApplication::x11_apply_settings() settings.readBoolEntry("/qt/useRtlExtensions", FALSE); #ifndef TQT_NO_XIM - if (xim_preferred_style == 0) { + if (qt_xim_preferred_style == 0) { TQString ximInputStyle = settings.readEntry( "/qt/XIMInputStyle", TQObject::trUtf8( "On The Spot" ) ).lower(); if ( ximInputStyle == "on the spot" ) - xim_preferred_style = XIMPreeditCallbacks | XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditCallbacks | XIMStatusNothing; else if ( ximInputStyle == "over the spot" ) - xim_preferred_style = XIMPreeditPosition | XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditPosition | XIMStatusNothing; else if ( ximInputStyle == "off the spot" ) - xim_preferred_style = XIMPreeditArea | XIMStatusArea; + qt_xim_preferred_style = XIMPreeditArea | XIMStatusArea; else if ( ximInputStyle == "root" ) - xim_preferred_style = XIMPreeditNothing | XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditNothing | XIMStatusNothing; + } +#endif + +#ifndef TQT_NO_IM + /* + The identifier name of an input method is acquired from the + configuration file as a default. If a environment variable + "TQT_IM_SWITCHER" is not empty it will overwrite the + configuration file. The "imsw-multi" becomes the default if the entry + is not configured. + */ + if ( getenv( "TQT_IM_SWITCHER" ) ) + defaultIM = getenv( "TQT_IM_SWITCHER" ); +#ifndef TQT_NO_IM_EXTENSIONS + else + defaultIM = settings.readEntry( "/qt/DefaultInputMethodSwitcher", "imsw-multi" ); +#endif + + // defaultIM is restricted to be an IM-switcher. An IM-switcher + // has a 'imsw-' prefix + if ( ! defaultIM.startsWith( "imsw-" ) ) { + defaultIM = "imsw-multi"; } #endif @@ -3619,19 +3725,19 @@ static void qt_set_input_encoding() // Always use the locale codec, since we have no examples of non-local // XIMs, and since we cannot get a sensible answer about the encoding // from the XIM. - input_mapper = TQTextCodec::codecForLocale(); + qt_input_mapper = TQTextCodec::codecForLocale(); } else { if ( !qstricmp( data, "locale" ) ) - input_mapper = TQTextCodec::codecForLocale(); + qt_input_mapper = TQTextCodec::codecForLocale(); else - input_mapper = TQTextCodec::codecForName( data ); + qt_input_mapper = TQTextCodec::codecForName( data ); // make sure we have an input codec - if( !input_mapper ) - input_mapper = TQTextCodec::codecForName( "ISO 8859-1" ); + if( !qt_input_mapper ) + qt_input_mapper = TQTextCodec::codecForName( "ISO 8859-1" ); } - if ( input_mapper->mibEnum() == 11 ) // 8859-8 - input_mapper = TQTextCodec::codecForName( "ISO 8859-8-I"); + if ( qt_input_mapper->mibEnum() == 11 ) // 8859-8 + qt_input_mapper = TQTextCodec::codecForName( "ISO 8859-8-I"); if( data ) XFree( (char *)data ); } @@ -4071,6 +4177,8 @@ static Visual *tqfind_truecolor_visual( Display *dpy, int scr, int *depth, int * #define XK_MISCELLANY #define XK_LATIN1 +#define XK_KOREAN +#define XK_XKB_KEYS #include // ### This should be static but it isn't because of the friend declaration @@ -4161,10 +4269,7 @@ void qt_init_internal( int *argcptr, char **argv, //Ming-Che 10/10 } else if ( arg == "-im" ) { if ( ++i < argc ) - ximServer = argv[i]; - } else if ( arg == "-noxim" ) { - noxim=TRUE; - // + qt_ximServer = argv[i]; } else if ( arg == "-iconic" ) { mwIconic = !mwIconic; } else if ( arg == "-ncols" ) { // xv and netscape use this name @@ -4184,17 +4289,17 @@ void qt_init_internal( int *argcptr, char **argv, if ( ++i < argc ) { TQCString s = TQCString(argv[i]).lower(); if ( s == "onthespot" ) - xim_preferred_style = XIMPreeditCallbacks | - XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditCallbacks | + XIMStatusNothing; else if ( s == "overthespot" ) - xim_preferred_style = XIMPreeditPosition | - XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditPosition | + XIMStatusNothing; else if ( s == "offthespot" ) - xim_preferred_style = XIMPreeditArea | - XIMStatusArea; + qt_xim_preferred_style = XIMPreeditArea | + XIMStatusArea; else if ( s == "root" ) - xim_preferred_style = XIMPreeditNothing | - XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditNothing | + XIMStatusNothing; } #endif } else if ( arg == "-cmap" ) { // xv uses this name @@ -4642,34 +4747,13 @@ void qt_init_internal( int *argcptr, char **argv, TQApplication::setFont( f ); } -#ifndef TQT_NO_XIM - if ( ! xim_preferred_style ) // no configured input style, use the default - xim_preferred_style = xim_default_style; - - qt_xim = 0; - TQString ximServerName(ximServer); - if (ximServer) - ximServerName.prepend("@im="); - else - ximServerName = ""; - - if ( !XSupportsLocale() ) - qWarning("TQt: Locales not supported on X server"); - -#ifdef USE_X11R6_XIM - else if ( XSetLocaleModifiers (ximServerName.ascii()) == 0 ) - qWarning( "TQt: Cannot set locale modifiers: %s", - ximServerName.ascii()); - else if (! noxim) - XRegisterIMInstantiateCallback(appDpy, 0, 0, 0, - (XIMProc) xim_create_callback, 0); -#else // !USE_X11R6_XIM - else if ( XSetLocaleModifiers ("") == 0 ) - qWarning("TQt: Cannot set locale modifiers"); - else if (! noxim) - TQApplication::create_xim(); -#endif // USE_X11R6_XIM -#endif // TQT_NO_XIM +#if !defined(TQT_NO_IM) +#if !defined(TQT_NO_IM_EXTENSIONS) + TQApplication::create_im(); +#else + TQApplication::create_xim(); +#endif +#endif #if defined (TQT_TABLET_SUPPORT) int ndev, @@ -4918,9 +5002,12 @@ void qt_cleanup() XCloseDevice( appDpy, devEraser ); #endif -#if !defined(TQT_NO_XIM) - if ( qt_xim ) - TQApplication::close_xim(); +#if !defined(TQT_NO_IM) +#if !defined(TQT_NO_IM_EXTENSIONS) + TQApplication::close_im(); +#else + TQApplication::close_xim(); +#endif #endif if ( qt_is_gui_used ) { @@ -5673,6 +5760,10 @@ int TQApplication::x11ClientMessage(TQWidget* w, XEvent* event, bool passive_onl XSendEvent( event->xclient.display, event->xclient.window, False, SubstructureNotifyMask|SubstructureRedirectMask, event ); } +#ifndef TQT_NO_XSYNC + } else if (a == qt_net_wm_sync_request ) { + widget->handleSyncRequest( event ); +#endif } } else if ( event->xclient.message_type == qt_qt_scrolldone ) { widget->translateScrollDoneEvent(event); @@ -5779,77 +5870,59 @@ int TQApplication::x11ProcessEvent( XEvent* event ) } } - int xkey_keycode = event->xkey.keycode; - if ( XFilterEvent( event, - keywidget ? keywidget->tqtopLevelWidget()->winId() : None ) ) { - if ( keywidget ) - composingKeycode = xkey_keycode; // ### not documented in xlib +#ifndef TQT_NO_IM + // Filtering input events by the input context. It has to be taken + // place before any other key event consumers such as eventfilters + // and accelerators because some input methods require quite + // various key combination and sequences. It often conflicts with + // accelerators and so on, so we must give the input context the + // filtering opportunity first to ensure all input methods work + // properly regardless of application design. -#ifndef TQT_NO_XIM - if ( event->type != XKeyPress || ! (qt_xim_style & XIMPreeditCallbacks) ) - return 1; - - /* - * The Solaris htt input method will transform a ClientMessage - * event into a filtered KeyPress event, in which case our - * keywidget is still zero. - */ - if ( ! keywidget ) { - keywidget = (TQETWidget*)TQWidget::keyboardGrabber(); - if ( keywidget ) { - grabbed = TRUE; - } else { - if ( focus_widget ) - keywidget = (TQETWidget*)focus_widget; - if ( !keywidget ) { - if ( inPopupMode() ) // no focus widget, see if we have a popup - keywidget = (TQETWidget*) activePopupWidget(); - else if ( widget ) - keywidget = (TQETWidget*)widget->tqtopLevelWidget(); - } - } - } - - /* - if the composition string has been emptied, we need to send - an IMEnd event. however, we have no way to tell if the user - has cancelled input, or if the user has accepted the - composition. - - so, we have to look for the next keypress and see if it is - the 'commit' key press (keycode == 0). if it is, we deliver - an IMEnd event with the final text, otherwise we deliver an - IMEnd with empty text (meaning the user has cancelled the - input). - */ - TQInputContext *qic = - (TQInputContext *) keywidget->tqtopLevelWidget()->topData()->xic; - extern bool qt_compose_emptied; // qinputcontext_x11.cpp - if ( qic && qic->composing && qic->tqfocusWidget && qt_compose_emptied ) { - XEvent event2; - bool found = FALSE; - if ( XCheckTypedEvent( TQPaintDevice::x11AppDisplay(), - XKeyPress, &event2 ) ) { - if ( event2.xkey.keycode == 0 ) { - // found a key event with the 'commit' string - found = TRUE; - XPutBackEvent( TQPaintDevice::x11AppDisplay(), &event2 ); - } - } - - if ( !found ) { - // no key event, so the user must have cancelled the composition - TQIMEvent endevent( TQEvent::IMEnd, TQString::null, -1 ); - TQApplication::sendEvent( qic->tqfocusWidget, &endevent ); +// #ifndef TQT_NO_IM_EXTENSIONS + if( keywidget && keywidget->isEnabled() && keywidget->isInputMethodEnabled() ) { +// #else +// if( keywidget && keywidget->isEnabled() ) { +// #endif + if( ( event->type==XKeyPress || event->type==XKeyRelease ) && + sm_blockUserInput ) // block user interaction during session management + return TRUE; - qic->tqfocusWidget = 0; - } + // for XIM handling + TQInputContext *qic = keywidget->getInputContext(); + if( qic && qic->x11FilterEvent( keywidget, event ) ) + return TRUE; - qt_compose_emptied = FALSE; + // filterEvent() accepts TQEvent *event rather than preexpanded key + // event attribute values. This is intended to pass other IM-related + // events in future. The IM-related events are supposed as + // TQWheelEvent, TQTabletEvent and so on. Other non IM-related events + // should not be forwarded to input contexts to prevent weird event + // handling. + if ( ( event->type == XKeyPress || event->type == XKeyRelease ) ) { + int code = -1; + int count = 0; + int state; + char ascii = 0; + TQEvent::Type type; + TQString text; + + keywidget->translateKeyEventInternal( event, count, text, + state, ascii, code, type, + FALSE, FALSE ); + + // both key press/release is required for some complex + // input methods. don't eliminate anything. + TQKeyEvent keyevent( type, code, ascii, state, text, FALSE, count ); + + if( qic && qic->filterEvent( &keyevent ) ) + return TRUE; } -#endif // TQT_NO_XIM - - return 1; + } else +#endif // TQT_NO_IM + { + if ( XFilterEvent( event, None ) ) + return TRUE; } if ( qt_x11EventFilter(event) ) // send through app filter @@ -5946,7 +6019,8 @@ int TQApplication::x11ProcessEvent( XEvent* event ) #endif #ifndef TQT_NO_XRANDR - if (event->type == xrandr_eventbase + RRScreenChangeNotify) { + if (event->type == xrandr_eventbase + RRScreenChangeNotify + || ( event->type == ConfigureNotify && event->xconfigure.window == TQPaintDevice::x11AppRootWindow())) { // update Xlib internals with the latest screen configuration XRRUpdateConfiguration(event); @@ -6000,34 +6074,8 @@ int TQApplication::x11ProcessEvent( XEvent* event ) case XKeyRelease: { if ( keywidget && keywidget->isEnabled() ) { // should always exist -#ifndef TQT_NO_XIM - TQInputContext *qic = - (TQInputContext *) keywidget->tqtopLevelWidget()->topData()->xic; - - if ((qt_xim_style & XIMPreeditCallbacks) && event->xkey.keycode == 0 && - qic && qic->composing && qic->tqfocusWidget) { - // input method has sent us a commit string - TQCString data(513); - KeySym sym; // unused - Status status; // unused - TQString text; - int count = qic->lookupString( &(event->xkey), data, - &sym, &status ); - if ( count > 0 ) - text = input_mapper->toUnicode( data, count ); - - // qDebug( "sending IMEnd with %d chars", text.length() ); - TQIMEvent endevent( TQEvent::IMEnd, text, -1 ); - TQApplication::sendEvent( qic->tqfocusWidget, &endevent ); - - qic->tqfocusWidget = 0; - qic->text = TQString::null; - } else -#endif // !TQT_NO_XIM - { - // qDebug( "sending key event" ); - keywidget->translateKeyEvent( event, grabbed ); - } + // qDebug( "sending key event" ); + keywidget->translateKeyEvent( event, grabbed ); } break; } @@ -6514,7 +6562,7 @@ void TQApplication::closePopup( TQWidget *popup ) // Keyboard event translation // -static int translateButtonState( int s ) +int qt_x11_translateButtonState( int s ) { int bst = 0; if ( s & Button1Mask ) @@ -6580,7 +6628,7 @@ bool TQETWidget::translateMouseEvent( const XEvent *event ) pos.ry() = lastMotion.y; globalPos.rx() = lastMotion.x_root; globalPos.ry() = lastMotion.y_root; - state = translateButtonState( lastMotion.state ); + state = qt_x11_translateButtonState( lastMotion.state ); if ( qt_button_down && (state & (LeftButton | MidButton | RightButton ) ) == 0 ) @@ -6604,7 +6652,7 @@ bool TQETWidget::translateMouseEvent( const XEvent *event ) pos.ry() = xevent->xcrossing.y; globalPos.rx() = xevent->xcrossing.x_root; globalPos.ry() = xevent->xcrossing.y_root; - state = translateButtonState( xevent->xcrossing.state ); + state = qt_x11_translateButtonState( xevent->xcrossing.state ); if ( qt_button_down && (state & (LeftButton | MidButton | RightButton ) ) == 0 ) @@ -6616,7 +6664,7 @@ bool TQETWidget::translateMouseEvent( const XEvent *event ) pos.ry() = event->xbutton.y; globalPos.rx() = event->xbutton.x_root; globalPos.ry() = event->xbutton.y_root; - state = translateButtonState( event->xbutton.state ); + state = qt_x11_translateButtonState( event->xbutton.state ); switch ( event->xbutton.button ) { case Button1: button = LeftButton; break; case Button2: button = MidButton; break; @@ -7322,6 +7370,92 @@ static const KeySym KeyTbl[] = { // keyboard mapping table 0x1005FF10, TQt::Key_F11, // hardcoded Sun F36 (labeled F11) 0x1005FF11, TQt::Key_F12, // hardcoded Sun F37 (labeled F12) + // International input method support keys + + // International & multi-key character composition + XK_Multi_key, TQt::Key_Multi_key, + XK_Codeinput, TQt::Key_Codeinput, + XK_SingleCandidate, TQt::Key_SingleCandidate, + XK_MultipleCandidate, TQt::Key_MultipleCandidate, + XK_PreviousCandidate, TQt::Key_PreviousCandidate, + + // Misc Functions + XK_Mode_switch, TQt::Key_Mode_switch, + //XK_script_switch, TQt::Key_script_switch, + XK_script_switch, TQt::Key_Mode_switch, + + // Japanese keyboard support + XK_Kanji, TQt::Key_Kanji, + XK_Muhenkan, TQt::Key_Muhenkan, + //XK_Henkan_Mode, TQt::Key_Henkan_Mode, + XK_Henkan_Mode, TQt::Key_Henkan, + XK_Henkan, TQt::Key_Henkan, + XK_Romaji, TQt::Key_Romaji, + XK_Hiragana, TQt::Key_Hiragana, + XK_Katakana, TQt::Key_Katakana, + XK_Hiragana_Katakana, TQt::Key_Hiragana_Katakana, + XK_Zenkaku, TQt::Key_Zenkaku, + XK_Hankaku, TQt::Key_Hankaku, + XK_Zenkaku_Hankaku, TQt::Key_Zenkaku_Hankaku, + XK_Touroku, TQt::Key_Touroku, + XK_Massyo, TQt::Key_Massyo, + XK_Kana_Lock, TQt::Key_Kana_Lock, + XK_Kana_Shift, TQt::Key_Kana_Shift, + XK_Eisu_Shift, TQt::Key_Eisu_Shift, + XK_Eisu_toggle, TQt::Key_Eisu_toggle, + //XK_Kanji_Bangou, TQt::Key_Kanji_Bangou, + //XK_Zen_Koho, TQt::Key_Zen_Koho, + //XK_Mae_Koho, TQt::Key_Mae_Koho, + XK_Kanji_Bangou, TQt::Key_Codeinput, + XK_Zen_Koho, TQt::Key_MultipleCandidate, + XK_Mae_Koho, TQt::Key_PreviousCandidate, + +#ifdef XK_KOREAN + // Korean keyboard support + XK_Hangul, TQt::Key_Hangul, + XK_Hangul_Start, TQt::Key_Hangul_Start, + XK_Hangul_End, TQt::Key_Hangul_End, + XK_Hangul_Hanja, TQt::Key_Hangul_Hanja, + XK_Hangul_Jamo, TQt::Key_Hangul_Jamo, + XK_Hangul_Romaja, TQt::Key_Hangul_Romaja, + //XK_Hangul_Codeinput, TQt::Key_Hangul_Codeinput, + XK_Hangul_Codeinput, TQt::Key_Codeinput, + XK_Hangul_Jeonja, TQt::Key_Hangul_Jeonja, + XK_Hangul_Banja, TQt::Key_Hangul_Banja, + XK_Hangul_PreHanja, TQt::Key_Hangul_PreHanja, + XK_Hangul_PostHanja, TQt::Key_Hangul_PostHanja, + //XK_Hangul_SingleCandidate, TQt::Key_Hangul_SingleCandidate, + //XK_Hangul_MultipleCandidate, TQt::Key_Hangul_MultipleCandidate, + //XK_Hangul_PreviousCandidate, TQt::Key_Hangul_PreviousCandidate, + XK_Hangul_SingleCandidate, TQt::Key_SingleCandidate, + XK_Hangul_MultipleCandidate, TQt::Key_MultipleCandidate, + XK_Hangul_PreviousCandidate, TQt::Key_PreviousCandidate, + XK_Hangul_Special, TQt::Key_Hangul_Special, + //XK_Hangul_switch, TQt::Key_Hangul_switch, + XK_Hangul_switch, TQt::Key_Mode_switch, +#endif // XK_KOREAN + + // dead keys + XK_dead_grave, TQt::Key_Dead_Grave, + XK_dead_acute, TQt::Key_Dead_Acute, + XK_dead_circumflex, TQt::Key_Dead_Circumflex, + XK_dead_tilde, TQt::Key_Dead_Tilde, + XK_dead_macron, TQt::Key_Dead_Macron, + XK_dead_breve, TQt::Key_Dead_Breve, + XK_dead_abovedot, TQt::Key_Dead_Abovedot, + XK_dead_diaeresis, TQt::Key_Dead_Diaeresis, + XK_dead_abovering, TQt::Key_Dead_Abovering, + XK_dead_doubleacute, TQt::Key_Dead_Doubleacute, + XK_dead_caron, TQt::Key_Dead_Caron, + XK_dead_cedilla, TQt::Key_Dead_Cedilla, + XK_dead_ogonek, TQt::Key_Dead_Ogonek, + XK_dead_iota, TQt::Key_Dead_Iota, + XK_dead_voiced_sound, TQt::Key_Dead_Voiced_Sound, + XK_dead_semivoiced_sound, TQt::Key_Dead_Semivoiced_Sound, + XK_dead_belowdot, TQt::Key_Dead_Belowdot, + XK_dead_hook, TQt::Key_Dead_Hook, + XK_dead_horn, TQt::Key_Dead_Horn, + // Special multimedia keys // currently only tested with MS internet keyboard @@ -7539,9 +7673,9 @@ static TQChar keysymToUnicode(unsigned char byte3, unsigned char byte4) bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, TQString& text, int& state, - char& ascii, int& code, TQEvent::Type &type, bool willRepeat ) + char& ascii, int& code, TQEvent::Type &type, bool willRepeat, bool statefulTranslation ) { - TQTextCodec *mapper = input_mapper; + TQTextCodec *mapper = qt_input_mapper; // some XmbLookupString implementations don't return buffer overflow correctly, // so we increase the input buffer to allow for long strings... // 256 chars * 2 bytes + 1 null-term == 513 bytes @@ -7562,7 +7696,7 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, XKeyEvent xkeyevent = event->xkey; // save the modifier state, we will use the keystate uint later by passing - // it to translateButtonState + // it to qt_x11_translateButtonState uint keystate = event->xkey.state; // remove the modifiers where mode_switch exists... HPUX machines seem // to have alt *AND* mode_switch both in Mod1Mask, which causes @@ -7588,6 +7722,11 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, if ( type == TQEvent::KeyPress ) { bool mb=FALSE; + // commit string handling is done by + // TQXIMInputContext::x11FilterEvent() and are passed to + // widgets via TQIMEvent regardless of XIM style, so the + // following code is commented out. +#if 0 if ( qt_xim ) { TQTLWExtra* xd = tlw->topData(); TQInputContext *qic = (TQInputContext *) xd->xic; @@ -7596,13 +7735,14 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, count = qic->lookupString(&xkeyevent, chars, &key, &status); } } +#endif if ( !mb ) { count = XLookupString( &xkeyevent, chars.data(), chars.size(), &key, 0 ); } if ( count && !keycode ) { - keycode = composingKeycode; - composingKeycode = 0; + keycode = qt_ximComposingKeycode; + qt_ximComposingKeycode = 0; } if ( key ) keyDict->tqreplace( keycode, (void*)key ); @@ -7666,28 +7806,32 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, } else { key = (int)(long)keyDict->tqfind( keycode ); if ( key ) - if( !willRepeat ) // Take out key of dictionary only if this call. + if( !willRepeat && statefulTranslation ) // Take out key of dictionary only if this call. keyDict->take( keycode ); long s = (long)textDict->tqfind( keycode ); if ( s ) { - textDict->take( keycode ); + if( statefulTranslation ) + textDict->take( keycode ); ascii = (char)(s-256); } } #endif // !TQT_NO_XIM - state = translateButtonState( keystate ); + state = qt_x11_translateButtonState( keystate ); static int directionKeyEvent = 0; - if ( qt_use_rtl_extensions && type == TQEvent::KeyRelease ) { + static unsigned int lastWinId = 0; + if ( qt_use_rtl_extensions && type == TQEvent::KeyRelease && statefulTranslation ) { if (directionKeyEvent == Key_Direction_R || directionKeyEvent == Key_Direction_L ) { type = TQEvent::KeyPress; code = directionKeyEvent; chars[0] = 0; directionKeyEvent = 0; + lastWinId = 0; return TRUE; } else { directionKeyEvent = 0; + lastWinId = 0; } } @@ -7697,10 +7841,14 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, // (to figure out whether the Ctrl modifier is held while Shift is pressed, // or Shift is held while Ctrl is pressed) since the 'state' doesn't tell // us whether the modifier held is Left or Right. - if (qt_use_rtl_extensions && type == TQEvent::KeyPress) + if ( qt_use_rtl_extensions && type == TQEvent::KeyPress && statefulTranslation ) if (key == XK_Control_L || key == XK_Control_R || key == XK_Shift_L || key == XK_Shift_R) { - if (!directionKeyEvent) + if (!directionKeyEvent) { directionKeyEvent = key; + // This code exists in order to check that + // the event is occurred in the same widget. + lastWinId = winId(); + } } else { // this can no longer be a direction-changing accel. // if any other key was pressed. @@ -7714,7 +7862,7 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, // TQt keycodes between 128 and 255, but should rather use the // TQKeyEvent::text(). // - if ( key < 128 || (key < 256 && (!input_mapper || input_mapper->mibEnum()==4)) ) { + if ( key < 128 || (key < 256 && (!qt_input_mapper || qt_input_mapper->mibEnum()==4)) ) { code = isprint((int)key) ? toupper((int)key) : 0; // upper-case key, if known } else if ( key >= XK_F1 && key <= XK_F35 ) { code = Key_F1 + ((int)key - XK_F1); // function keys @@ -7765,8 +7913,8 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, chars[0] = 0; } - if ( qt_use_rtl_extensions && type == TQEvent::KeyPress ) { - if ( directionKeyEvent ) { + if ( qt_use_rtl_extensions && type == TQEvent::KeyPress && statefulTranslation ) { + if ( directionKeyEvent && lastWinId == winId() ) { if ( key == XK_Shift_L && directionKeyEvent == XK_Control_L || key == XK_Control_L && directionKeyEvent == XK_Shift_L ) { directionKeyEvent = Key_Direction_L; @@ -7838,8 +7986,10 @@ static Bool qt_keypress_scanner(Display *, XEvent *event, XPointer arg) qt_auto_repeat_data *d = (qt_auto_repeat_data *) arg; if (d->error || event->xkey.window != d->window || - event->xkey.keycode != d->keycode) + event->xkey.keycode != d->keycode) { + d->error = TRUE; return FALSE; + } if (event->type == XKeyPress) { d->error = (! d->release || event->xkey.time - d->timestamp > 10); @@ -7942,8 +8092,34 @@ bool TQETWidget::translateKeyEvent( const XEvent *event, bool grab ) translateKeyEventInternal( event, count, text, state, ascii, code, type ); } +#ifndef TQT_NO_IM + TQInputContext *qic = getInputContext(); +#endif + // compress keys if ( !text.isEmpty() && testWState(WState_CompressKeys) && +#ifndef TQT_NO_IM + // Ordinary input methods require discrete key events to work + // properly, so key compression has to be disabled when input + // context exists. + // + // And further consideration, some complex input method + // require all key press/release events discretely even if + // the input method awares of key compression and compressed + // keys are ordinary alphabets. For example, the uim project + // is planning to implement "combinational shift" feature for + // a Japanese input method, uim-skk. It will work as follows. + // + // 1. press "r" + // 2. press "u" + // 3. release both "r" and "u" in arbitrary order + // 4. above key sequence generates "Ru" + // + // Of course further consideration about other participants + // such as key repeat mechanism is required to implement such + // feature. + ! qic && +#endif // TQT_NO_IM // do not compress keys if the key event we just got above matches // one of the key ranges used to compute stopCompression ! ( ( code >= Key_Escape && code <= Key_SysReq ) || @@ -8002,7 +8178,12 @@ bool TQETWidget::translateKeyEvent( const XEvent *event, bool grab ) // autorepeat compression makes sense for all widgets (Windows // does it automatically .... ) - if ( event->type == XKeyPress && text.length() <= 1 ) { + if ( event->type == XKeyPress && text.length() <= 1 +#ifndef TQT_NO_IM + // input methods need discrete key events + && ! qic +#endif// TQT_NO_IM + ) { XEvent dummy; for (;;) { @@ -8210,6 +8391,21 @@ bool TQETWidget::translateScrollDoneEvent( const XEvent *event ) return FALSE; } +#if defined(TQ_C_CALLBACKS) +extern "C" { +#endif +#ifndef TQT_NO_XSYNC +static Bool qt_net_wm_sync_request_scanner(Display*, XEvent* event, XPointer arg) +{ + return (event->type == ClientMessage && event->xclient.window == *(Window*)arg + && event->xclient.message_type == qt_wm_protocols + && event->xclient.data.l[ 0 ] == qt_net_wm_sync_request ); +} +#endif + +#if defined(TQ_C_CALLBACKS) +} +#endif // // ConfigureNotify (window move and resize) event translation @@ -8241,6 +8437,7 @@ bool TQETWidget::translateConfigEvent( const XEvent *event ) if (! extra || extra->compress_events) { // ConfigureNotify compression for faster opaque resizing XEvent otherEvent; + int compressed_configs = 0; while ( XCheckTypedWindowEvent( x11Display(), winId(), ConfigureNotify, &otherEvent ) ) { if ( qt_x11EventFilter( &otherEvent ) ) @@ -8261,7 +8458,18 @@ bool TQETWidget::translateConfigEvent( const XEvent *event ) newCPos.ry() = otherEvent.xconfigure.y + otherEvent.xconfigure.border_width; } + ++compressed_configs; } +#ifndef TQT_NO_XSYNC + // _NET_WM_SYNC_REQUEST compression + Window wid = winId(); + while ( compressed_configs && + XCheckIfEvent( x11Display(), &otherEvent, + qt_net_wm_sync_request_scanner, (XPointer)&wid ) ) { + handleSyncRequest( (void*)&otherEvent ); + --compressed_configs; + } +#endif } TQRect cr ( tqgeometry() ); @@ -8315,6 +8523,8 @@ bool TQETWidget::translateConfigEvent( const XEvent *event ) tqrepaint( !testWFlags(WResizeNoErase) || transbg ); } + incrementSyncCounter(); + return TRUE; } diff --git a/tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp b/tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp index 14e7f08..9fd90e4 100644 --- a/tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp @@ -111,6 +111,7 @@ static int pending_timer_id = 0; static bool pending_clipboard_changed = FALSE; static bool pending_selection_changed = FALSE; +TQ_EXPORT bool qt_qclipboard_bailout_hack = false; // event capture mechanism for qt_xclb_wait_for_event static bool waiting_for_data = FALSE; @@ -142,6 +143,15 @@ static Bool checkForClipboardEvents(Display *, XEvent *e, XPointer) || e->xselectionclear.selection == qt_xa_clipboard))); } +static bool selection_request_pending = false; + +static Bool check_selection_request_pending( Display*, XEvent* e, XPointer ) + { + if( e->type == SelectionRequest && e->xselectionrequest.owner == owner->winId()) + selection_request_pending = true; + return False; + } + bool qt_xclb_wait_for_event( Display *dpy, Window win, int type, XEvent *event, int timeout ) { @@ -193,6 +203,14 @@ bool qt_xclb_wait_for_event( Display *dpy, Window win, int type, XEvent *event, do { if ( XCheckTypedWindowEvent(dpy,win,type,event) ) return TRUE; + if( qt_qclipboard_bailout_hack ) { + XEvent dummy; + selection_request_pending = false; + if ( owner != NULL ) + XCheckIfEvent(dpy,&dummy,check_selection_request_pending,NULL); + if( selection_request_pending ) + return TRUE; + } // process other clipboard events, since someone is probably requesting data from us XEvent e; diff --git a/tqtinterface/qt4/src/kernel/tqdesktopwidget_x11.cpp b/tqtinterface/qt4/src/kernel/tqdesktopwidget_x11.cpp index e2bd9f9..84da179 100644 --- a/tqtinterface/qt4/src/kernel/tqdesktopwidget_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqdesktopwidget_x11.cpp @@ -111,7 +111,7 @@ TQDesktopWidgetPrivate::~TQDesktopWidgetPrivate() screens[i] = 0; } - delete [] screens; + free(screens); } if ( rects ) delete [] rects; @@ -121,6 +121,8 @@ TQDesktopWidgetPrivate::~TQDesktopWidgetPrivate() void TQDesktopWidgetPrivate::init() { // get the screen count + int newScreenCount; + #ifndef TQT_NO_XINERAMA XineramaScreenInfo *xinerama_screeninfo = 0; int unused; @@ -130,23 +132,26 @@ void TQDesktopWidgetPrivate::init() if (use_xinerama) { xinerama_screeninfo = - XineramaQueryScreens(TQPaintDevice::x11AppDisplay(), &screenCount); + XineramaQueryScreens(TQPaintDevice::x11AppDisplay(), &newScreenCount); + + if (xinerama_screeninfo) defaultScreen = 0; } else #endif // TQT_NO_XINERAMA { defaultScreen = DefaultScreen(TQPaintDevice::x11AppDisplay()); - screenCount = ScreenCount(TQPaintDevice::x11AppDisplay()); + newScreenCount = ScreenCount(TQPaintDevice::x11AppDisplay()); + use_xinerama = false; } delete [] rects; - rects = new TQRect[ screenCount ]; + rects = new TQRect[ newScreenCount ]; delete [] workareas; - workareas = new TQRect[ screenCount ]; + workareas = new TQRect[ newScreenCount ]; // get the tqgeometry of each screen - int i, x, y, w, h; - for ( i = 0; i < screenCount; i++ ) { + int i, j, x, y, w, h; + for ( i = 0, j = 0; i < newScreenCount; i++ ) { #ifndef TQT_NO_XINERAMA if (use_xinerama) { @@ -163,11 +168,33 @@ void TQDesktopWidgetPrivate::init() h = HeightOfScreen(ScreenOfDisplay(TQPaintDevice::x11AppDisplay(), i)); } - rects[i].setRect(x, y, w, h); workareas[i] = TQRect(); + rects[j].setRect(x, y, w, h); + + // overlapping? + if (j > 0 && rects[j-1].intersects(rects[j])) { + // pick the bigger one, ignore the other + if ((rects[j].width()*rects[j].height()) > + (rects[j-1].width()*rects[j-1].height())) + rects[j-1] = rects[j]; + } + else + j++; } + if (screens) { + // leaks TQWidget* pointers on purpose, can't delete them as pointer escapes + screens = (TQWidget**) realloc(screens, j * sizeof(TQWidget*)); + if (j > screenCount) + memset(&screens[screenCount], 0, (j-screenCount) * sizeof(TQWidget*)); + } + + screenCount = j; + #ifndef TQT_NO_XINERAMA + if (use_xinerama && screenCount == 1) + use_xinerama = false; + if (xinerama_screeninfo) XFree(xinerama_screeninfo); #endif // TQT_NO_XINERAMA @@ -220,8 +247,7 @@ TQWidget *TQDesktopWidget::screen( int screen ) screen = d->defaultScreen; if ( ! d->screens ) { - d->screens = new TQWidget*[ d->screenCount ]; - memset( d->screens, 0, d->screenCount * sizeof( TQWidget * ) ); + d->screens = (TQWidget**) calloc( d->screenCount, sizeof(TQWidget*)); d->screens[ d->defaultScreen ] = this; } diff --git a/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp b/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp index 7882349..3ba66b9 100644 --- a/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp @@ -52,13 +52,15 @@ #include "tqdragobject.h" #include "tqobjectlist.h" #include "tqcursor.h" +#include "tqbitmap.h" +#include "tqpainter.h" #include "tqt_x11_p.h" // conflict resolution -// unused, may be used again later: const int XKeyPress = KeyPress; -// unused, may be used again later: const int XKeyRelease = KeyRelease; +const int XKeyPress = KeyPress; +const int XKeyRelease = KeyRelease; #undef KeyPress #undef KeyRelease @@ -114,6 +116,8 @@ Atom qt_xdnd_finished; Atom qt_xdnd_type_list; const int qt_xdnd_version = 4; +extern int qt_x11_translateButtonState( int s ); + // Actions // // The Xdnd spec allows for user-defined actions. This could be implemented @@ -199,6 +203,8 @@ static Time qt_xdnd_target_current_time; static int qt_xdnd_current_screen = -1; // state of dragging... true if dragging, false if not bool qt_xdnd_dragging = FALSE; +// need to check state of keyboard modifiers +static bool need_modifiers_check = FALSE; // dict of payload data, sorted by type atom static TQIntDict * qt_xdnd_target_data = 0; @@ -257,21 +263,49 @@ class TQShapedPixmapWidget : public TQWidget { public: TQShapedPixmapWidget(int screen = -1) : TQWidget(TQApplication::desktop()->screen( screen ), - 0, (Qt::WindowType)(WStyle_Customize | WStyle_Tool | WStyle_NoBorder | WX11BypassWM) ) + 0, (Qt::WindowType)(WStyle_Customize | WStyle_Tool | WStyle_NoBorder | WX11BypassWM) ), oldpmser( 0 ), oldbmser( 0 ) { + x11SetWindowType( X11WindowTypeDND ); } - void setPixmap(TQPixmap pm) + void setPixmap(TQPixmap pm, TQPoint hot) { - const TQBitmap* mask = pm.tqmask(); - if ( mask ) { + int bmser = pm.tqmask() ? pm.tqmask()->serialNumber() : 0; + if( oldpmser == pm.serialNumber() && oldbmser == bmser + && oldhot == hot ) + return; + oldpmser = pm.serialNumber(); + oldbmser = bmser; + oldhot = hot; + bool hotspot_in = !(hot.x() < 0 || hot.y() < 0 || hot.x() >= pm.width() || hot.y() >= pm.height()); +// if the pixmap has hotspot in its area, make a "hole" in it at that position +// this will allow XTranslateCoordinates() to find directly the window below the cursor instead +// of finding this pixmap, and therefore there won't be needed any (slow) search for the window +// using findRealWindow() + if( hotspot_in ) { + TQBitmap tqmask = pm.tqmask() ? *pm.tqmask() : TQBitmap( pm.width(), pm.height()); + if( !pm.tqmask()) + tqmask.fill( TQt::color1 ); + TQPainter p( &tqmask ); + p.setPen( TQt::color0 ); + p.drawPoint( hot.x(), hot.y()); + p.end(); + pm.setMask( tqmask ); + setMask( tqmask ); + } else if ( pm.tqmask() ) { setMask( *mask ); } else { clearMask(); } resize(pm.width(),pm.height()); setErasePixmap(pm); + erase(); } + +private: + int oldpmser; + int oldbmser; + TQPoint oldhot; }; static TQShapedPixmapWidget * qt_xdnd_deco = 0; @@ -875,8 +909,59 @@ void qt_handle_xdnd_finished( TQWidget *, const XEvent * xe, bool passive ) void TQDragManager::timerEvent( TQTimerEvent* e ) { - if ( e->timerId() == heartbeat && qt_xdnd_source_sameanswer.isNull() ) - move( TQCursor::pos() ); + if ( e->timerId() == heartbeat ) { + if( need_modifiers_check ) { + Window root, child; + int root_x, root_y, win_x, win_y; + unsigned int tqmask; + XQueryPointer( qt_xdisplay(), qt_xrootwin( qt_xdnd_current_screen ), + &root, &child, &root_x, &root_y, &win_x, &win_y, &tqmask ); + if( updateMode( (ButtonState)qt_x11_translateButtonState( tqmask ))) + qt_xdnd_source_sameanswer = TQRect(); // force move + } + need_modifiers_check = TRUE; + if( qt_xdnd_source_sameanswer.isNull() ) + move( TQCursor::pos() ); + } +} + +static bool qt_xdnd_was_move = false; +static bool qt_xdnd_found = false; +// check whole incoming X queue for move events +// checking whole queue is done by always returning False in the predicate +// if there's another move event in the queue, and there's not a mouse button +// or keyboard or ClientMessage event before it, the current move event +// may be safely discarded +// this helps avoiding being overloaded by being flooded from many events +// from the XServer +static +Bool qt_xdnd_predicate( Display*, XEvent* ev, XPointer ) +{ + if( qt_xdnd_found ) + return False; + if( ev->type == MotionNotify ) + { + qt_xdnd_was_move = true; + qt_xdnd_found = true; + } + if( ev->type == ButtonPress || ev->type == ButtonRelease + || ev->type == XKeyPress || ev->type == XKeyRelease + || ev->type == ClientMessage ) + { + qt_xdnd_was_move = false; + qt_xdnd_found = true; + } + return False; +} + +static +bool qt_xdnd_another_movement() +{ + qt_xdnd_was_move = false; + qt_xdnd_found = false; + XEvent dummy; + XCheckIfEvent( qt_xdisplay(), &dummy, qt_xdnd_predicate, NULL ); + return qt_xdnd_was_move; } bool TQDragManager::eventFilter( TQObject * o, TQEvent * e) @@ -901,8 +986,11 @@ bool TQDragManager::eventFilter( TQObject * o, TQEvent * e) if ( e->type() == TQEvent::MouseMove ) { TQMouseEvent* me = (TQMouseEvent *)e; - updateMode(me->stateAfter()); - move( me->globalPos() ); + if( !qt_xdnd_another_movement()) { + updateMode(me->stateAfter()); + move( me->globalPos() ); + } + need_modifiers_check = FALSE; return TRUE; } else if ( e->type() == TQEvent::MouseButtonRelease ) { tqApp->removeEventFilter( this ); @@ -941,9 +1029,11 @@ bool TQDragManager::eventFilter( TQObject * o, TQEvent * e) beingCancelled = FALSE; tqApp->exit_loop(); } else { - updateMode(ke->stateAfter()); - qt_xdnd_source_sameanswer = TQRect(); // force move - move( TQCursor::pos() ); + if( updateMode(ke->stateAfter())) { + qt_xdnd_source_sameanswer = TQRect(); // force move + move( TQCursor::pos() ); + } + need_modifiers_check = FALSE; } return TRUE; // Eat all key events } @@ -970,10 +1060,10 @@ bool TQDragManager::eventFilter( TQObject * o, TQEvent * e) static TQt::ButtonState oldstate; -void TQDragManager::updateMode( TQt::ButtonState newstate ) +bool TQDragManager::updateMode( TQt::ButtonState newstate ) { if ( newstate == oldstate ) - return; + return false; const int both = ShiftButton|ControlButton; if ( (newstate & both) == both ) { global_requested_action = TQDropEvent::Link; @@ -997,6 +1087,7 @@ void TQDragManager::updateMode( TQt::ButtonState newstate ) } } oldstate = newstate; + return true; } @@ -1138,12 +1229,13 @@ void TQDragManager::move( const TQPoint & globalPos ) // recreate the pixmap on the new screen... delete qt_xdnd_deco; qt_xdnd_deco = new TQShapedPixmapWidget( screen ); + qt_xdnd_deco->x11SetWindowTransient( dragSource->tqtopLevelWidget()); if (!TQWidget::mouseGrabber()) { updatePixmap(); qt_xdnd_deco->grabMouse(); } } - updatePixmap(); + updatePixmap( globalPos ); if ( qt_xdnd_source_sameanswer.contains( globalPos ) && qt_xdnd_source_sameanswer.isValid() ) { @@ -1691,6 +1783,7 @@ bool TQDragManager::drag( TQDragObject * o, TQDragObject::DragMode mode ) dragSource = (TQWidget *)(object->tqparent()); + qt_xdnd_deco->x11SetWindowTransient( dragSource->tqtopLevelWidget()); tqApp->installEventFilter( this ); qt_xdnd_source_current_time = GET_QT_X_TIME(); XSetSelectionOwner( TQPaintDevice::x11AppDisplay(), qt_xdnd_selection, @@ -1703,6 +1796,7 @@ bool TQDragManager::drag( TQDragObject * o, TQDragObject::DragMode mode ) qt_xdnd_source_sameanswer = TQRect(); move(TQCursor::pos()); heartbeat = startTimer(200); + need_modifiers_check = FALSE; #ifndef TQT_NO_CURSOR tqApp->setOverrideCursor( Qt::ArrowCursor ); @@ -1736,7 +1830,7 @@ bool TQDragManager::drag( TQDragObject * o, TQDragObject::DragMode mode ) // qt_xdnd_source_object persists until we get an xdnd_finish message } -void TQDragManager::updatePixmap() +void TQDragManager::updatePixmap( const TQPoint& cursorPos ) { if ( qt_xdnd_deco ) { TQPixmap pm; @@ -1751,9 +1845,8 @@ void TQDragManager::updatePixmap() defaultPm = new TQPixmap(default_pm); pm = *defaultPm; } - qt_xdnd_deco->setPixmap(pm); - qt_xdnd_deco->move(TQCursor::pos()-pm_hot); - qt_xdnd_deco->tqrepaint(FALSE); + qt_xdnd_deco->setPixmap(pm, pm_hot); + qt_xdnd_deco->move(cursorPos-pm_hot); //if ( willDrop ) { qt_xdnd_deco->show(); //} else { @@ -1762,4 +1855,9 @@ void TQDragManager::updatePixmap() } } +void TQDragManager::updatePixmap() +{ + updatePixmap( TQCursor::pos()); +} + #endif // TQT_NO_DRAGANDDROP diff --git a/tqtinterface/qt4/src/kernel/tqdragobject.cpp b/tqtinterface/qt4/src/kernel/tqdragobject.cpp index 6e58f84..5a4d2fe 100644 --- a/tqtinterface/qt4/src/kernel/tqdragobject.cpp +++ b/tqtinterface/qt4/src/kernel/tqdragobject.cpp @@ -2468,6 +2468,16 @@ bool TQTextDrag::decode( const TQMimeSource* e, TQString& str, TQCString& subtyp { if(!e) return FALSE; + + // when subtype is not specified, try text/plain first, otherwise this may read + // things like text/x-moz-url even though better targets are available + if( subtype.isNull()) { + TQCString subtmp = "plain"; + if( decode( e, str, subtmp )) { + subtype = subtmp; + return true; + } + } if ( e->cacheType == TQMimeSource::Text ) { str = *e->cache.txt.str; diff --git a/tqtinterface/qt4/src/kernel/tqdragobject.h b/tqtinterface/qt4/src/kernel/tqdragobject.h index 3d55967..7133c0f 100644 --- a/tqtinterface/qt4/src/kernel/tqdragobject.h +++ b/tqtinterface/qt4/src/kernel/tqdragobject.h @@ -476,10 +476,11 @@ private: void move( const TQPoint & ); void drop(); void updatePixmap(); + void updatePixmap( const TQPoint& cursorPos ); private: TQDragObject * object; - void updateMode( TQt::ButtonState newstate ); + bool updateMode( TQt::ButtonState newstate ); void updateCursor(); #if defined(TQ_WS_X11) void createCursors(); diff --git a/tqtinterface/qt4/src/kernel/tqevent.cpp b/tqtinterface/qt4/src/kernel/tqevent.cpp index b34f38d..59a6ca7 100644 --- a/tqtinterface/qt4/src/kernel/tqevent.cpp +++ b/tqtinterface/qt4/src/kernel/tqevent.cpp @@ -874,6 +874,10 @@ TQWheelEvent::TQWheelEvent( const TQPoint &pos, int delta, int state, Orientatio the result of a known key (e.g. it may be the result of a compose sequence or a keyboard macro, or due to key event compression). + Applications should not use the TQt latin 1 keycodes between 128 + and 255, but should rather use the TQKeyEvent::text(). This is + mainly for compatibility. + \sa TQWidget::setKeyCompression() */ diff --git a/tqtinterface/qt4/src/kernel/tqfontdatabase.cpp b/tqtinterface/qt4/src/kernel/tqfontdatabase.cpp index f79c14b..e70be03 100644 --- a/tqtinterface/qt4/src/kernel/tqfontdatabase.cpp +++ b/tqtinterface/qt4/src/kernel/tqfontdatabase.cpp @@ -707,6 +707,10 @@ static TQtFontStyle *bestStyle(TQtFontFoundry *foundry, const TQtFontStyle::Key } FM_DEBUG( " best style has distance 0x%x", dist ); + if (!foundry->count) { + TQtFontStyle *temp = NULL; + return temp; + } return foundry->styles[best]; } @@ -980,20 +984,22 @@ TQFontDatabase::tqfindFont( TQFont::Script script, const TQFontPrivate *fp, #ifdef TQ_WS_X11 if (script == TQFont::Han) { - // modify script according to locale - static TQFont::Script defaultHan = TQFont::UnknownScript; - if (defaultHan == TQFont::UnknownScript) { - TQCString locale = setlocale(LC_ALL, NULL); - if (locale.tqcontains("ko")) - defaultHan = TQFont::Han_Korean; - else if (locale.tqcontains("zh_TW") || locale.tqcontains("zh_HK")) - defaultHan = TQFont::Han_TraditionalChinese; - else if (locale.tqcontains("zh")) - defaultHan = TQFont::Han_SimplifiedChinese; - else - defaultHan = TQFont::Han_Japanese; - } - script = defaultHan; + // modify script according to locale + static TQFont::Script defaultHan; + TQCString locale = setlocale(LC_ALL, NULL); + + if (locale.tqcontains("ko")) + defaultHan = TQFont::Han_Korean; + else if (locale.tqcontains("zh_TW") || locale.tqcontains("zh_HK")) + defaultHan = TQFont::Han_TraditionalChinese; + else if (locale.tqcontains("zh")) + defaultHan = TQFont::Han_SimplifiedChinese; + else if (locale.tqcontains("ja")) + defaultHan = TQFont::Han_Japanese; + else + defaultHan = TQFont::Han; // don't change + + script = defaultHan; } #endif diff --git a/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp b/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp index 8ea403f..97cb544 100644 --- a/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp @@ -721,6 +721,9 @@ static void loadXlfds( const char *reqFamily, int encoding_id ) if ( fontFamily && fontFamily->xlfdLoaded ) return; +#ifdef TQT_XFT2 + if ( !qt_has_xft ) { +#endif // TQT_XFT2 int fontCount; // force the X server to give us XLFDs TQCString xlfd_pattern = "-*-"; @@ -822,8 +825,11 @@ static void loadXlfds( const char *reqFamily, int encoding_id ) } XFreeFontNames( fontList ); -} +#ifdef TQT_XFT2 + } +#endif // TQT_XFT2 +} #ifndef TQT_NO_XFTFREETYPE static int getXftWeight(int xftweight) diff --git a/tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp b/tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp index 0b45ec9..8d76e0b 100644 --- a/tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp @@ -2694,23 +2694,16 @@ bool TQOpenType::positionAndAdd(TQShaperItem *item, bool doLogClusters) // ###### fix the case where we have y advances. How do we handle this in Uniscribe????? if (positions[i].new_advance) { item->advances[i] = item->flags & TQTextEngine::RightToLeft - ? -tqRound((positions[i].x_advance >> 6)*scale) + ? -tqRound((positions[i].x_advance >> 6)*scale) : tqRound((positions[i].x_advance >> 6)*scale); } else { item->advances[i] += item->flags & TQTextEngine::RightToLeft - ? -tqRound((positions[i].x_advance >> 6)*scale) + ? -tqRound((positions[i].x_advance >> 6)*scale) : tqRound((positions[i].x_advance >> 6)*scale); } - int back = 0; - item->offsets[i].x = tqRound((positions[i].x_pos >> 6)*scale); - item->offsets[i].y = tqRound((positions[i].y_pos >> 6)*scale); - while (positions[i-back].back) { - back += positions[i - back].back; - item->offsets[i].x += tqRound((positions[i - back].x_pos >> 6)*scale); - item->offsets[i].y += tqRound((positions[i - back].y_pos >> 6)*scale); - } - item->offsets[i].y = -item->offsets[i].y; - back = positions[i].back; + item->offsets[i].x = tqRound((positions[i].x_pos >> 6)*scale); + item->offsets[i].y = -tqRound((positions[i].y_pos >> 6)*scale); + int back = positions[i].back; if (item->flags & TQTextEngine::RightToLeft) { while (back--) { item->offsets[i].x -= item->advances[i-back]; diff --git a/tqtinterface/qt4/src/kernel/tqinputcontext.cpp b/tqtinterface/qt4/src/kernel/tqinputcontext.cpp new file mode 100644 index 0000000..dfb38f7 --- /dev/null +++ b/tqtinterface/qt4/src/kernel/tqinputcontext.cpp @@ -0,0 +1,856 @@ +/**************************************************************************** +** $Id: qinputcontext.cpp,v 1.6 2004/06/22 06:47:30 daisuke Exp $ +** +** Implementation of TQInputContext class +** +** Copyright (C) 2000-2003 Trolltech AS. All rights reserved. +** +** This file is part of the kernel module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses for Unix/X11 may use this file in accordance with the TQt Commercial +** License Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +//#define TQT_NO_IM_PREEDIT_RELOCATION + +#include "tqinputcontext.h" + +#ifndef TQT_NO_IM + +#include "tqplatformdefs.h" + +#include "tqapplication.h" +#include "tqwidget.h" +#include "tqpopupmenu.h" + +#include +#include + +class TQInputContextPrivate +{ +public: + TQInputContextPrivate() + : holderWidget( 0 ), composingWidget( 0 ), hasFocus( FALSE ), + isComposing( FALSE ) +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + , preeditString( TQString() ), + cursorPosition( -1 ), selLength ( 0 ) +#endif + {} + + TQWidget *holderWidget; // widget to which TQInputContext instance belongs. + TQWidget *composingWidget; + bool hasFocus; + bool isComposing; + + void updateComposingState( const TQString &text, + int newCursorPosition, int newSelLength ) { +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + preeditString = text; + cursorPosition = newCursorPosition; + selLength = newSelLength; +#endif + } + + void resetComposingState() { + isComposing = FALSE; +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + preeditString = TQString(); + cursorPosition = -1; + selLength = 0; +#endif + } + +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + TQString preeditString; + int cursorPosition; + int selLength; +#endif +}; + + +// UPDATED COMMENT RETQUIRED -- 2004-07-08 YamaKen +/*! + \class TQInputContext qinputcontext.h + \brief The TQInputContext class abstracts the input method dependent data and composing state. + + \ingroup i18n + + An input method is responsible to input complex text that cannot + be inputted via simple keymap. It converts a sequence of input + events (typically key events) into a text string through the input + method specific converting process. The class of the processes are + widely ranging from simple finite state machine to complex text + translator that pools a whole paragraph of a text with text + editing capability to perform grammar and semantic analysis. + + To abstract such different input method specific intermediate + information, TQt offers the TQInputContext as base class. The + concept is well known as 'input context' in the input method + domain. an input context is created for a text widget in response + to a demand. It is ensured that an input context is prepared for + an input method before input to a text widget. + + Multiple input contexts that is belonging to a single input method + may concurrently coexist. Suppose multi-window text editor. Each + text widget of window A and B holds different TQInputContext + instance which contains different state information such as + partially composed text. + + \section1 Groups of functions: + + \table + \header \i Context \i Functions + + \row \i Receiving information \i + x11FilterEvent(), + filterEvent(), + setMicroFocus(), + mouseHandler() + + \row \i Sending back composed text \i + sendIMEvent(), + + \row \i State change notification \i + setFocus(), + unsetFocus(), + reset() + + \row \i Context information \i + identifierName(), + language(), + font(), + isComposing(), + + \endtable + + + \section1 Sharing input context between text widgets + + Any input context can be shared between several text widgets to + reduce resource consumption. In ideal case, each text widgets + should be allocated dedicated input context. But some complex + input contexts require slightly heavy resource such as 100 + kilobytes of memory. It prevents quite many text widgets from + being used concurrently. + + To resolve such problem, we can share an input context. There is + one 'input context holder widget' per text widgets that shares + identical input context. In this model, the holder widget owns the + shared input context. Other text widgets access the input context + via TQApplication::locateICHolderWidget(). But the access + convention is transparently hidden into TQWidget, so developers are + not required to aware of it. + + What developer should know is only the mapping function + TQApplication::locateICHolderWidget(). It accepts a widget as + argument and returns its holder widget. Default implementation + returns the top-level widget of the widget as reasonable + assumption. But some applications should reimplement the function + to fit application specific usability. See + TQApplication::locateICHolderWidget() for further information. + + + \section1 Preedit preservation + + As described above, input contexts have wide variety of amount of + the state information in accordance with belonging input + method. It is ranging from 2-3 keystrokes of sequence in + deterministic input methods to hundreds of keystrokes with + semantic text refinement in complex input methods such as ordinary + Japanese input method. The difference requires the different reset + policies in losing input focus. + + The former simple input method case, users will prefer resetting + the context to back to the neutral state when something + happened. Suppose a web browsing. The user scroll the page by + scrollbar after he or she has typed a half of the valid key + sequence into a text widget. In the case, the input context should + be reset in losing focus when he or she has dragged the + scrollbar. He or she will be confused if the input context is + still preserved until focused back to the text widget because he + or she will restart typing with first key of the sequence as a + habitual operation. + + On the other hand, we should choose completely different policy + for the latter complex input method case. Suppose same situation + as above but he or she is using a complex input method. In the + case, he or she will be angry if the input context has been lost + when he or she has dragged the scrollbar because the input context + contained a valuably composed text made up by considerable input + cost. So we should not reset the input context in the case. And + the input context should be preserved until focused back to the + text widget. This behavior is named as 'preedit preservation'. + + The two policies can be switched by calling or not calling reset() + in unsetFocus(). Default implementation of unsetFocus() calls + reset() to fit the simple input methods. The implementation is + expressed as 'preedit preservation is disabled'. + + + \section1 Preedit relocation + + Although the most case of the preedit preservation problem for + complex input methods is resolved as described above, there is a + special case. Suppose the case that matches all of the following + conditions. + + \list + + \i a input focus has been moved from a text widget to another text + widget directly + + \i the input context is shared between the two text widgets + + \i preedit preservation is enabled for the input context + + \endlist + + In the case, there are the following two requirements that + contradicts each other. The input context sharing causes it. + + \list + + \i the input context has to be reset to prepare to input to the + newly focused text widget + + \i the input context has to be preserved until focused back to the + previous text widget + + \endlist + + A intrinsic feature named 'preedit relocation' is available to + compromise the requirements. If the feature is enabled for the + input context, it is simply moved to the new text widget with the + preedit string. The user continues the input on the new text + widget, or relocate it to another text widget. The preedit of + previous text widget is automatically cleared to back to the + neutral state of the widget. + + This strange behavior is just a compromise. As described in + previous section, complex input method user should not be exposed + to the risk losing the input context because it contains valuable + long text made up with considerable input cost. The user will + immediately focus back to the previous text widget to continue the + input in the correct text widget if the preedit relocation + occurred. The feature is mainly existing as safety. + + The feature properly works even if the focus is moved as + following. Input method developers are not required to be aware of + the relocation protocol since TQInputContext transparently handles + it. + + a text widget -> a non-text widget -> another text widget + + To enable the preedit relocation feature, the input context class + have to reimplement isPreeditRelocationEnabled() as returns TRUE. + The implementation requires that the preedit preservation is also + enabled since preedit relocation is a special case of the preedit + preservation. If the preedit relocation is disabled, the input + context is simply reset in the relocation case. + + + \section1 Input context instanciation + \section1 Input method switching + + \section1 Text widget implementor's guide + + Add following code fragment into createPopupMenu() to add input + method dependent submenus. + + \code + #ifndef TQT_NO_IM + TQInputContext *qic = getInputContext(); + if ( qic ) + qic->addMenusTo( popup ); + #endif + \endcode + + \sa TQInputContextPlugin, TQInputContextFactory, TQApplication::locateICHolderWidget(), TQApplication::defaultInputMethod() +*/ + + +/*! + Constructs an input context. + + holderWidget is set immediately after this constructor has been + returned on the X11 platform. +*/ +TQInputContext::TQInputContext( TQObject *tqparent ) + : TQObject( tqparent ) +{ + d = new TQInputContextPrivate; +} + + +/*! + Destroys the input context. +*/ +TQInputContext::~TQInputContext() +{ + delete d; +} + +#if defined(TQ_WS_X11) +/*! + \internal + Returns the owner of this input context. Ordinary input methods + should not call this function directly to keep platform + independence and flexible configuration possibility. + + The return value may differ from tqfocusWidget() if the input + context is shared between several text widgets. + + \sa setHolderWidget(), tqfocusWidget() +*/ +TQWidget *TQInputContext::holderWidget() const +{ + return d->holderWidget; +} + +/*! + \internal + Sets the owner of this input context. Ordinary input methods + must not call this function directly. + + \sa holderWidget() +*/ +void TQInputContext::setHolderWidget( TQWidget *w ) +{ + d->holderWidget = w; +} + +/*! + \internal + Returns the widget that has an input focus for this input + context. Ordinary input methods should not call this function + directly to keep platform independence and flexible configuration + possibility. + + The return value may differ from holderWidget() if the input + context is shared between several text widgets. + + \sa setFocusWidget(), holderWidget() +*/ +TQWidget *TQInputContext::tqfocusWidget() const +{ + return d->hasFocus ? d->composingWidget : 0; +} + + +/*! + \internal + Sets the widget that has an input focus for this input + context. Ordinary input methods must not call this function + directly. + + \sa tqfocusWidget() +*/ +void TQInputContext::setFocusWidget( TQWidget *w ) +{ + if ( w ) { + bool isFocusingBack = ( w == d->composingWidget ); + bool isPreeditRelocation = ( ! isFocusingBack && isComposing() && + d->composingWidget ); + // invoke sendIMEventInternal() rather than sendIMEvent() to + // avoid altering the composing state + if ( isPreeditRelocation == TRUE ) { + // clear preedit of previously focused text + // widget. preserved preedit may be exist even if + // isPreeditRelocationEnabled() == FALSE. + sendIMEventInternal( TQEvent::IMEnd ); + } + d->composingWidget = w; // changes recipient of TQIMEvent + if ( isPreeditRelocation == TRUE ) { +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + if ( isPreeditRelocationEnabled() ) { + // copy preedit state to the widget that gaining focus + sendIMEventInternal( TQEvent::IMStart ); + sendIMEventInternal( TQEvent::IMCompose, d->preeditString, + d->cursorPosition, d->selLength ); + } else +#endif + { + // reset input context when the shared context has + // focused on another text widget + reset(); + } + } + } + d->hasFocus = w ? TRUE : FALSE; +} + + +/*! + \internal + This function is called from TQWidget to keep input state + consistency. Ordinary input method must not call this function + directly. +*/ +void TQInputContext::releaseComposingWidget( TQWidget *w ) +{ + if ( d->composingWidget == w ) { + d->composingWidget = 0; + d->hasFocus = FALSE; + } +} +#endif // TQ_WS_X11 + +/*! + \internal + This function can be reimplemented in a subclass as returning TRUE + if you want making your input method enable the preedit + relocation. See the description for preedit relocation of + TQInputContext. + + /sa TQInputContext +*/ +bool TQInputContext::isPreeditRelocationEnabled() +{ + return FALSE; +} + +/*! + This function indicates whether IMStart event had been sent to the + text widget. It is ensured that an input context can send IMCompose + or IMEnd event safely if this function returned TRUE. + + The state is automatically being tracked through sendIMEvent(). + + \sa sendIMEvent() +*/ +bool TQInputContext::isComposing() const +{ + return d->isComposing; +} + + +/*! + This function can be reimplemented in a subclass to filter input + events. + + Return TRUE if the \a event has been consumed. Otherwise, the + unfiltered \a event will be forwarded to widgets as ordinary + way. Although the input events have accept() and ignore() + methods, leave it untouched. + + \a event is currently restricted to TQKeyEvent. But some input + method related events such as TQWheelEvent or TQTabletEvent may be + added in future. + + The filtering opportunity is always given to the input context as + soon as possible. It has to be taken place before any other key + event consumers such as eventfilters and accelerators because some + input methods require quite various key combination and + sequences. It often conflicts with accelerators and so on, so we + must give the input context the filtering opportunity first to + ensure all input methods work properly regardless of application + design. + + Ordinary input methods require discrete key events to work + properly, so TQt's key compression is always disabled for any input + contexts. + + \sa TQKeyEvent, x11FilterEvent() +*/ +bool TQInputContext::filterEvent( const TQEvent *event ) +{ + return FALSE; +} + + +/*! + \fn void TQInputContext::deletionRequested() + + Emit this signal when a fatal error has been caused in the input + context. The input context will be deleted by the owner which is + usually the holder widget. +*/ + +/*! + \fn void TQInputContext::imEventGenerated( TQObject *receiver, TQIMEvent *e ) + + \internal + This signal is emitted when the user has sent a TQIMEvent through + sendIMEvent(). Ordinary input methods should not emit this signal + directly. + + \a receiver is a platform dependent destination of the \a e. + + \sa TQIMEvent, sendIMEvent(), sendIMEventInternal(), +*/ + +/*! + \internal + Sends a TQIMEvent to the client via imEventGenerated() + signal. Ordinary input method should not call this function + directly. + + \sa TQIMEvent, TQIMComposeEvent, sendIMEvent(), imEventGenerated() +*/ +void TQInputContext::sendIMEventInternal( TQEvent::Type type, + const TQString &text, + int cursorPosition, int selLength ) +{ + TQObject *receiver = 0; + TQIMEvent *event = 0; + +#if defined(TQ_WS_X11) + receiver = d->composingWidget; +#elif defined(TQ_WS_TQWS) + // just a placeholder +#endif + if ( ! receiver ) + return; + + if ( type == TQEvent::IMStart ) { + qDebug( "sending IMStart with %d chars to %p", + text.length(), receiver ); + event = new TQIMEvent( type, text, cursorPosition ); + } else if ( type == TQEvent::IMEnd ) { + qDebug( "sending IMEnd with %d chars to %p, text=%s", + text.length(), receiver, (const char*)text.local8Bit() ); + event = new TQIMEvent( type, text, cursorPosition ); + } else if ( type == TQEvent::IMCompose ) { + qDebug( "sending IMCompose to %p with %d chars, cpos=%d, sellen=%d, text=%s", + receiver, text.length(), cursorPosition, selLength, + (const char*)text.local8Bit() ); + event = new TQIMComposeEvent( type, text, cursorPosition, selLength ); + } + + if ( event ) + emit imEventGenerated( receiver, event ); +} + + +/*! + Call this function to send TQIMEvent to the text widget. This + function constructs a TQIMEvent based on the arguments and send it + to the appropriate widget. Ordinary input method should not + reimplement this function. + + \a type is either \c TQEvent::IMStart or \c TQEvent::IMCompose or \c + TQEvent::IMEnd. You have to send a \c TQEvent::IMStart to start + composing, then send several \c TQEvent::IMCompose to update the + preedit of the widget, and finalize the composition with sending + \c TQEvent::IMEnd. + + \c TQEvent::IMStart should always be sent without arguments as: + \code + sendIMEvent( TQEvent::IMStart ) + \endcode + + And \c TQEvent::IMCompose can be sent without cursor: + \code + sendIMEvent( TQEvent::IMCompose, TQString( "a text" ) ) + \endcode + + Or optionally with cursor with \a cursorPosition: + \code + sendIMEvent( TQEvent::IMCompose, TQString( "a text with cursor" ), 12 ) + \endcode + Note that \a cursorPosition also specifies microfocus position. + + Or optionally with selection text: + \code + sendIMEvent( TQEvent::IMCompose, TQString( "a text with selection" ), 12, 9 ) + \endcode + \a cursorPosition and \a selLength must be within the \a text. The + \a cursorPosition also specifies microfocus position in the case: + + \c TQEvent::IMEnd can be sent without arguments to terminate the + composition with null string: + \code + sendIMEvent( TQEvent::IMEnd ) + \endcode + + Or optionally accepts \a text to commit a string: + \code + sendIMEvent( TQEvent::IMEnd, TQString( "a text" ) ) + \endcode + + \sa TQIMEvent, TQIMComposeEvent, setMicroFocus() +*/ +void TQInputContext::sendIMEvent( TQEvent::Type type, const TQString &text, + int cursorPosition, int selLength ) +{ +#if defined(TQ_WS_X11) + if ( !tqfocusWidget() ) + return; +#endif + + if ( type == TQEvent::IMStart ) { + sendIMEventInternal( type, text, cursorPosition, selLength ); + d->isComposing = TRUE; + } else if ( type == TQEvent::IMEnd ) { + d->resetComposingState(); + sendIMEventInternal( type, text, cursorPosition, selLength ); + } else if ( type == TQEvent::IMCompose ) { + d->updateComposingState( text, cursorPosition, selLength ); + sendIMEventInternal( type, text, cursorPosition, selLength ); + } +} + + +/*! + This function can be reimplemented in a subclass to detect + that the input context has been focused on. + + The input context will receive input events through + x11FilterEvent() and filterEvent() after setFocus() until + unsetFocus() has been called. + + an input context is ensured that setFocus() is called exactly once + until unsetFocus() has been called even if preedit relocation has + occurred. This means that an input focus will survive between + several widgets that sharing the input context. + + On the X11 platform, tqfocusWidget is already set before this + function has been called. + + \sa unsetFocus() +*/ +void TQInputContext::setFocus() +{ +} + + +/*! + This function can be reimplemented in a subclass to detect + that the input context has lost the focus. + + an input context is ensured that unsetFocus() is not called during + preedit relocation. This means that an input focus will survive + between several widgets that sharing the input context. + + Default implementation that calls reset() is sufficient for simple + input methods. You can override this function to alter the + behavior. For example, most Japanese input contexts should not be + reset on losing focus. The context sometimes contains a whole + paragraph and has minutes of lifetime different to ephemeral one + in other languages. The piled input context should be survived + until focused again since Japanese user naturally expects so. + + On the X11 platform, tqfocusWidget is valid until this function has + been returned. + + \sa setFocus() +*/ +void TQInputContext::unsetFocus() +{ + reset(); +} + + +/*! + This function can be implemented in a subclass to handle + microfocus changes. + + 'microfocus' stands for the input method focus point in the + preedit (XIM "spot" point) for complex language input handling. It + can be used to place auxiliary GUI widgets such as candidate + selection window. + + \a x, \a y, \a w and \a h represents the position and size of the + cursor in the preedit string. \a f is the font on the location of + the cursor. +*/ +void TQInputContext::setMicroFocus( int x, int y, int w, int h, TQFont *f ) +{ +} + + +/*! + This function can be reimplemented in a subclass to handle mouse + presses/releases/doubleclicks/moves within the preedit text. You + can use the function to implement mouse-oriented user interface + such as text selection or popup menu for candidate selection. + + The parameter \a x is the offset within the string that was sent + with the IMCompose event. The alteration boundary of \a x is + ensured as character boundary of preedit string accurately. + + \a type is either \c TQEvent::MouseButtonPress or \c + TQEvent::MouseButtonRelease or \c TQEvent::MouseButtonDblClick or \c + TQEvent::MouseButtonMove. Refer \a button and \a state to determine + what operation has performed. + + The method interface is imported from + TQWSInputMethod::mouseHandler() of TQt/Embedded 2.3.7 and extended + for desktop system. + */ +void TQInputContext::mouseHandler( int x, TQEvent::Type type, + TQt::ButtonState button, + TQt::ButtonState state ) +{ + // Default behavior for simple ephemeral input contexts. Some + // complex input contexts should not be reset here. + if ( type == TQEvent::MouseButtonPress || + type == TQEvent::MouseButtonDblClick ) + reset(); +} + + +/*! + Returns the font of the current input widget + */ +TQFont TQInputContext::font() const +{ + if ( !tqfocusWidget() ) + return TQApplication::font(); //### absolutely last resort + + return tqfocusWidget()->font(); +} + + +/*! + This function can be reimplemented in a subclass to reset the + state of the input method. + + This function is called by several widgets to reset input + state. For example, a text widget call this function before + inserting a text to make widget ready to accept a text. + + Default implementation is sufficient for simple input method. You + can override this function to reset external input method engines + in complex input method. In the case, call TQInputContext::reset() + to ensure proper termination of inputting. + + You must not send any TQIMEvent except empty IMEnd event using + TQInputContext::reset() at reimplemented reset(). It will break + input state consistency. +*/ +void TQInputContext::reset() +{ + if ( isComposing() ) + sendIMEvent( TQEvent::IMEnd ); +} + + +/*! + This function must be implemented in any subclasses to return the + identifier name of the input method. + + Return value is the name to identify and specify input methods for + the input method switching mechanism and so on. The name has to be + consistent with TQInputContextPlugin::keys(). The name has to + consist of ASCII characters only. + + There are two different names with different responsibility in the + input method domain. This function returns one of them. Another + name is called 'display name' that stands for the name for + endusers appeared in a menu and so on. + + \sa TQInputContextPlugin::keys(), TQInputContextPlugin::displayName() +*/ +TQString TQInputContext::identifierName() +{ + return ""; +} + + +/*! + This function must be implemented in any subclasses to return a + language code (e.g. "zh_CN", "zh_TW", "zh_HK", "ja", "ko", ...) + of the input context. If the input context can handle multiple + languages, return the currently used one. The name has to be + consistent with TQInputContextPlugin::language(). + + This information will be used by language tagging feature in + TQIMEvent. It is required to distinguish unified han characters + correctly. It enables proper font and character code + handling. Suppose CJK-awared multilingual web browser + (that automatically modifies fonts in CJK-mixed text) and XML editor + (that automatically inserts lang attr). + + \sa TQInputContextPlugin::language() +*/ +TQString TQInputContext::language() +{ + return ""; +} + + +#if ([[[TQT_VERSION IS DEPRECATED]]]-0 >= 0x040000) +/*! + This is a preliminary interface for TQt4 + */ +TQList TQInputContext::actions() +{ +} +#else +/*! + This function can be reimplemented in a subclass to provide input + method dependent popup menus. Return 0 if the menus are + unnecessary. + + Ownership of the object and tqchildren are transferred to the + caller, and the result must not be called + setAutoDelete(). TQInputContextMenu::title is used for label text + of the popup menu as submenu. + + \sa addMenusTo() +*/ +TQPtrList *TQInputContext::menus() +{ + return 0; +} +#endif + +/*! + Appends input method dependent submenus into \a popup. A separator + is also inserted into \a popup if \a action is InsertSeparator. + + This is an utility function only for convenience in limited + situation. This function is used by input context owner such as + text widgets to add the submenus to its own context menu. If you + want to insert the submenus in more flexible way, use + TQInputContext::menus() manually. \a popup is not restricted to + context menu of a text widget. For example, the owner may be a + input method menu of TQtopia taskbar in TQt/Embedded platform. + + \sa menus(), TQInputContextMenu::Action +*/ +void TQInputContext::addMenusTo( TQPopupMenu *popup, TQInputContextMenu::Action action ) +{ + if ( ! popup ) + return; + + TQPtrList *imMenus = menus(); + if ( imMenus ) { + if ( action == TQInputContextMenu::InsertSeparator ) + popup->insertSeparator(); + for ( TQPtrList::Iterator it = imMenus->begin(); + it != imMenus->end(); + ++it ) { + TQInputContextMenu *imMenu = *it; + popup->insertItem( imMenu->title, imMenu->popup ); + } + imMenus->clear(); + delete imMenus; + } +} + +#endif //TQ_NO_IM diff --git a/tqtinterface/qt4/src/kernel/tqinputcontext.h b/tqtinterface/qt4/src/kernel/tqinputcontext.h new file mode 100644 index 0000000..9dbd9bf --- /dev/null +++ b/tqtinterface/qt4/src/kernel/tqinputcontext.h @@ -0,0 +1,143 @@ +/**************************************************************************** +** $Id: qinputcontext.h,v 1.8 2004/06/22 06:47:30 daisuke Exp $ +** +** Definition of TQInputContext +** +** Copyright (C) 1992-2002 Trolltech AS. All rights reserved. +** +** This file is part of the kernel module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef TQINPUTCONTEXT_H +#define TQINPUTCONTEXT_H + +#ifndef TQT_NO_IM + +#ifndef TQT_H +#include "tqobject.h" +#include "tqglobal.h" +#include "tqevent.h" +#include "tqstring.h" +#if ([[[TQT_VERSION IS DEPRECATED]]]-0 >= 0x040000) +#include "tqlist.h" +#include "tqaction.h" +#else +#include "tqptrlist.h" +#endif +#endif + +class TQWidget; +class TQFont; +class TQPopupMenu; +class TQInputContextPrivate; + + +struct TQInputContextMenu { + enum Action { + NoSeparator, + InsertSeparator + }; +#if !([[[TQT_VERSION IS DEPRECATED]]]-0 >= 0x040000) + TQString title; + TQPopupMenu *popup; +#endif +}; + + +class TQInputContext : public TQObject +{ + TQ_OBJECT +public: + TQInputContext( TQObject *tqparent = 0 ); + virtual ~TQInputContext(); + + virtual TQString identifierName(); + virtual TQString language(); + +#if defined(TQ_WS_X11) + virtual bool x11FilterEvent( TQWidget *keywidget, XEvent *event ); +#endif // TQ_WS_X11 + virtual bool filterEvent( const TQEvent *event ); + virtual void reset(); + + virtual void setFocus(); + virtual void unsetFocus(); + virtual void setMicroFocus( int x, int y, int w, int h, TQFont *f = 0 ); + virtual void mouseHandler( int x, TQEvent::Type type, + TQt::ButtonState button, TQt::ButtonState state ); + virtual TQFont font() const; + virtual bool isComposing() const; + virtual bool isPreeditRelocationEnabled(); + +#if ([[[TQT_VERSION IS DEPRECATED]]]-0 >= 0x040000) + virtual TQList actions(); + void addActionsTo( TQMenu *menu, TQInputContextMenu::Action action = TQInputContextMenu::InsertSeparator ); +#else + virtual TQPtrList *menus(); + void addMenusTo( TQPopupMenu *popup, TQInputContextMenu::Action action = TQInputContextMenu::InsertSeparator ); +#endif + +#if defined(TQ_WS_X11) + // these functions are not recommended for ordinary use + virtual TQWidget *tqfocusWidget() const; + virtual TQWidget *holderWidget() const; + + // these functions must not be used by ordinary input method + virtual void setFocusWidget( TQWidget *w ); + virtual void setHolderWidget( TQWidget *w ); + virtual void releaseComposingWidget( TQWidget *w ); +#endif + +signals: + void deletionRequested(); + void imEventGenerated( TQObject *receiver, TQIMEvent *e ); + +protected: + virtual void sendIMEvent( TQEvent::Type type, + const TQString &text = TQString(), + int cursorPosition = -1, int selLength = 0 ); + +private: + void sendIMEventInternal( TQEvent::Type type, + const TQString &text = TQString(), + int cursorPosition = -1, int selLength = 0 ); + + TQInputContextPrivate *d; + + friend class TQWidget; + friend class TQInputContextFactory; + +private: // Disabled copy constructor and operator= + TQInputContext( const TQInputContext & ); + TQInputContext &operator=( const TQInputContext & ); + +}; + +#endif //TQ_NO_IM + +#endif // TQINPUTCONTEXT_H diff --git a/tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp b/tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp index 758b56d..e96c75c 100644 --- a/tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp @@ -36,500 +36,34 @@ ** **********************************************************************/ +#include "tqinputcontext.h" + +#ifndef TQT_NO_IM + #include "tqplatformdefs.h" #include "tqapplication.h" #include "tqwidget.h" -#include "tqinputcontext_p.h" - -#include -#include +#include "tqt_x11_p.h" -bool qt_compose_emptied = FALSE; +/*! + This function may be overridden only if input method is depending + on X11 and you need raw XEvent. Otherwise, this function must not. -#if !defined(TQT_NO_XIM) + This function is designed to filter raw key events for XIM, but + other input methods may use this to implement some special + features such as distinguishing Shift_L and Shift_R. -#define XK_MISCELLANY -#define XK_LATIN1 -#include + Return TRUE if the \a event has been consumed. Otherwise, the + unfiltered \a event will be translated into TQEvent and forwarded + to filterEvent(). Filtering at both x11FilterEvent() and + filterEvent() in single input method is allowed. -// #define TQT_XIM_DEBUG + \a keywidget is a client widget into which a text is inputted. \a + event is inputted XEvent. -// from qapplication_x11.cpp -extern XIM qt_xim; -extern XIMStyle qt_xim_style; - -/* The cache here is needed, as X11 leaks a few kb for every - XFreeFontSet call, so we avoid creating and deletion of fontsets as - much as possible + \sa filterEvent() */ -static XFontSet fontsetCache[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; -static int fontsetRefCount = 0; - -static const char * const fontsetnames[] = { - "-*-fixed-medium-r-*-*-16-*,-*-*-medium-r-*-*-16-*", - "-*-fixed-medium-i-*-*-16-*,-*-*-medium-i-*-*-16-*", - "-*-fixed-bold-r-*-*-16-*,-*-*-bold-r-*-*-16-*", - "-*-fixed-bold-i-*-*-16-*,-*-*-bold-i-*-*-16-*", - "-*-fixed-medium-r-*-*-24-*,-*-*-medium-r-*-*-24-*", - "-*-fixed-medium-i-*-*-24-*,-*-*-medium-i-*-*-24-*", - "-*-fixed-bold-r-*-*-24-*,-*-*-bold-r-*-*-24-*", - "-*-fixed-bold-i-*-*-24-*,-*-*-bold-i-*-*-24-*" -}; - -static XFontSet getFontSet( const TQFont &f ) -{ - int i = 0; - if (f.italic()) - i |= 1; - if (f.bold()) - i |= 2; - - if ( f.pointSize() > 20 ) - i += 4; - - if ( !fontsetCache[i] ) { - Display* dpy = TQPaintDevice::x11AppDisplay(); - int missCount; - char** missList; - fontsetCache[i] = XCreateFontSet(dpy, fontsetnames[i], &missList, &missCount, 0); - if(missCount > 0) - XFreeStringList(missList); - if ( !fontsetCache[i] ) { - fontsetCache[i] = XCreateFontSet(dpy, "-*-fixed-*-*-*-*-16-*", &missList, &missCount, 0); - if(missCount > 0) - XFreeStringList(missList); - if ( !fontsetCache[i] ) - fontsetCache[i] = (XFontSet)-1; - } - } - return (fontsetCache[i] == (XFontSet)-1) ? 0 : fontsetCache[i]; -} - - -#ifdef TQ_C_CALLBACKS -extern "C" { -#endif // TQ_C_CALLBACKS - - static int xic_start_callback(XIC, XPointer client_data, XPointer) { - TQInputContext *qic = (TQInputContext *) client_data; - if (! qic) { -#ifdef TQT_XIM_DEBUG - qDebug("compose start: no qic"); -#endif // TQT_XIM_DEBUG - - return 0; - } - - qic->composing = TRUE; - qic->text = TQString::null; - qic->tqfocusWidget = 0; - - if ( qic->selectedChars.size() < 128 ) - qic->selectedChars.resize( 128 ); - qic->selectedChars.fill( 0 ); - -#ifdef TQT_XIM_DEBUG - qDebug("compose start"); -#endif // TQT_XIM_DEBUG - - return 0; - } - - static int xic_draw_callback(XIC, XPointer client_data, XPointer call_data) { - TQInputContext *qic = (TQInputContext *) client_data; - if (! qic) { -#ifdef TQT_XIM_DEBUG - qDebug("compose event: invalid compose event %p", qic); -#endif // TQT_XIM_DEBUG - - return 0; - } - - bool send_imstart = FALSE; - if (tqApp->tqfocusWidget() != qic->tqfocusWidget && qic->text.isEmpty()) { - if (qic->tqfocusWidget) { -#ifdef TQT_XIM_DEBUG - qDebug( "sending IMEnd (empty) to %p", qic->tqfocusWidget ); -#endif // TQT_XIM_DEBUG - - TQIMEvent endevent(TQEvent::IMEnd, TQString::null, -1); - TQApplication::sendEvent(qic->tqfocusWidget, &endevent); - } - - qic->text = TQString::null; - qic->tqfocusWidget = tqApp->tqfocusWidget(); - qic->composing = FALSE; - - if ( qic->selectedChars.size() < 128 ) - qic->selectedChars.resize( 128 ); - qic->selectedChars.fill( 0 ); - - if (qic->tqfocusWidget) { - qic->composing = TRUE; - send_imstart = TRUE; - } - } - - if (! qic->composing || ! qic->tqfocusWidget) { -#ifdef TQT_XIM_DEBUG - qDebug("compose event: invalid compose event %d %p", - qic->composing, qic->tqfocusWidget); -#endif // TQT_XIM_DEBUG - - return 0; - } - - if ( send_imstart ) { -#ifdef TQT_XIM_DEBUG - qDebug( "sending IMStart to %p", qic->tqfocusWidget ); -#endif // TQT_XIM_DEBUG - - qt_compose_emptied = FALSE; - TQIMEvent startevent(TQEvent::IMStart, TQString::null, -1); - TQApplication::sendEvent(qic->tqfocusWidget, &startevent); - } - - XIMPreeditDrawCallbackStruct *drawstruct = - (XIMPreeditDrawCallbackStruct *) call_data; - XIMText *text = (XIMText *) drawstruct->text; - int cursor = drawstruct->caret, sellen = 0; - - if ( ! drawstruct->caret && ! drawstruct->chg_first && - ! drawstruct->chg_length && ! text ) { - // nothing to do - return 0; - } - - if (text) { - char *str = 0; - if (text->encoding_is_wchar) { - int l = wcstombs(NULL, text->string.wide_char, text->length); - if (l != -1) { - str = new char[l + 1]; - wcstombs(str, text->string.wide_char, l); - str[l] = 0; - } - } else - str = text->string.multi_byte; - - if (! str) - return 0; - - TQString s = TQString::fromLocal8Bit(str); - - if (text->encoding_is_wchar) - delete [] str; - - if (drawstruct->chg_length < 0) - qic->text.tqreplace(drawstruct->chg_first, UINT_MAX, s); - else - qic->text.tqreplace(drawstruct->chg_first, drawstruct->chg_length, s); - - if ( qic->selectedChars.size() < qic->text.length() ) { - // expand the selectedChars array if the compose string is longer - uint from = qic->selectedChars.size(); - qic->selectedChars.resize( qic->text.length() ); - for ( uint x = from; from < qic->selectedChars.size(); ++x ) - qic->selectedChars[x] = 0; - } - - uint x; - bool *p = qic->selectedChars.data() + drawstruct->chg_first; - // determine if the changed chars are selected based on text->feedback - for ( x = 0; x < s.length(); ++x ) - *p++ = ( text->feedback ? ( text->feedback[x] & XIMReverse ) : 0 ); - - // figure out where the selection starts, and how long it is - p = qic->selectedChars.data(); - bool started = FALSE; - for ( x = 0; x < TQMIN(qic->text.length(), qic->selectedChars.size()); ++x ) { - if ( started ) { - if ( *p ) ++sellen; - else break; - } else { - if ( *p ) { - cursor = x; - started = TRUE; - sellen = 1; - } - } - ++p; - } - } else { - if (drawstruct->chg_length == 0) - drawstruct->chg_length = -1; - - qic->text.remove(drawstruct->chg_first, drawstruct->chg_length); - qt_compose_emptied = qic->text.isEmpty(); - if ( qt_compose_emptied ) { -#ifdef TQT_XIM_DEBUG - qDebug( "compose emptied" ); -#endif // TQT_XIM_DEBUG - - // don't send an empty compose, since we will send an IMEnd with - // either the correct compose text (or null text if the user has - // cancelled the compose or deleted all chars). - return 0; - } - } - -#ifdef TQT_XIM_DEBUG - qDebug( "sending IMCompose to %p with %d chars", - qic->tqfocusWidget, qic->text.length() ); -#endif // TQT_XIM_DEBUG - - TQIMComposeEvent event( TQEvent::IMCompose, qic->text, cursor, sellen ); - TQApplication::sendEvent(qic->tqfocusWidget, &event); - return 0; - } - - static int xic_done_callback(XIC, XPointer client_data, XPointer) { - TQInputContext *qic = (TQInputContext *) client_data; - if (! qic) - return 0; - - if (qic->composing && qic->tqfocusWidget) { -#ifdef TQT_XIM_DEBUG - qDebug( "sending IMEnd (empty) to %p", qic->tqfocusWidget ); -#endif // TQT_XIM_DEBUG - - TQIMEvent event(TQEvent::IMEnd, TQString::null, -1); - TQApplication::sendEvent(qic->tqfocusWidget, &event); - } - - qic->composing = FALSE; - qic->tqfocusWidget = 0; - - if ( qic->selectedChars.size() < 128 ) - qic->selectedChars.resize( 128 ); - qic->selectedChars.fill( 0 ); - - return 0; - } - -#ifdef TQ_C_CALLBACKS -} -#endif // TQ_C_CALLBACKS - -#endif // !TQT_NO_XIM - - - -TQInputContext::TQInputContext(TQWidget *widget) - : ic(0), tqfocusWidget(0), composing(FALSE), fontset(0) -{ -#if !defined(TQT_NO_XIM) - fontsetRefCount++; - if (! qt_xim) { - qWarning("TQInputContext: no input method context available"); - return; - } - - if (! widget->isTopLevel()) { - qWarning("TQInputContext: cannot create input context for non-toplevel widgets"); - return; - } - - XPoint spot; - XRectangle rect; - XVaNestedList preedit_attr = 0; - XIMCallback startcallback, drawcallback, donecallback; - - font = widget->font(); - fontset = getFontSet( font ); - - if (qt_xim_style & XIMPreeditArea) { - rect.x = 0; - rect.y = 0; - rect.width = widget->width(); - rect.height = widget->height(); - - preedit_attr = XVaCreateNestedList(0, - XNArea, &rect, - XNFontSet, fontset, - (char *) 0); - } else if (qt_xim_style & XIMPreeditPosition) { - spot.x = 1; - spot.y = 1; - - preedit_attr = XVaCreateNestedList(0, - XNSpotLocation, &spot, - XNFontSet, fontset, - (char *) 0); - } else if (qt_xim_style & XIMPreeditCallbacks) { - startcallback.client_data = (XPointer) this; - startcallback.callback = (XIMProc) xic_start_callback; - drawcallback.client_data = (XPointer) this; - drawcallback.callback = (XIMProc)xic_draw_callback; - donecallback.client_data = (XPointer) this; - donecallback.callback = (XIMProc) xic_done_callback; - - preedit_attr = XVaCreateNestedList(0, - XNPreeditStartCallback, &startcallback, - XNPreeditDrawCallback, &drawcallback, - XNPreeditDoneCallback, &donecallback, - (char *) 0); - } - - if (preedit_attr) { - ic = XCreateIC(qt_xim, - XNInputStyle, qt_xim_style, - XNClientWindow, widget->winId(), - XNPreeditAttributes, preedit_attr, - (char *) 0); - XFree(preedit_attr); - } else - ic = XCreateIC(qt_xim, - XNInputStyle, qt_xim_style, - XNClientWindow, widget->winId(), - (char *) 0); - - if (! ic) - qFatal("Failed to create XIM input context!"); - - // when resetting the input context, preserve the input state - (void) XSetICValues((XIC) ic, XNResetState, XIMPreserveState, (char *) 0); -#endif // !TQT_NO_XIM -} - - -TQInputContext::~TQInputContext() -{ - -#if !defined(TQT_NO_XIM) - if (ic) - XDestroyIC((XIC) ic); - - if ( --fontsetRefCount == 0 ) { - Display *dpy = TQPaintDevice::x11AppDisplay(); - for ( int i = 0; i < 8; i++ ) { - if ( fontsetCache[i] && fontsetCache[i] != (XFontSet)-1 ) { - XFreeFontSet(dpy, fontsetCache[i]); - fontsetCache[i] = 0; - } - } - } - -#endif // !TQT_NO_XIM - - ic = 0; - tqfocusWidget = 0; - composing = FALSE; -} - - -void TQInputContext::reset() -{ -#if !defined(TQT_NO_XIM) - if (tqfocusWidget && composing && ! text.isNull()) { -#ifdef TQT_XIM_DEBUG - qDebug("TQInputContext::reset: composing - sending IMEnd (empty) to %p", - tqfocusWidget); -#endif // TQT_XIM_DEBUG - - TQIMEvent endevent(TQEvent::IMEnd, TQString::null, -1); - TQApplication::sendEvent(tqfocusWidget, &endevent); - tqfocusWidget = 0; - text = TQString::null; - if ( selectedChars.size() < 128 ) - selectedChars.resize( 128 ); - selectedChars.fill( 0 ); - - char *mb = XmbResetIC((XIC) ic); - if (mb) - XFree(mb); - } -#endif // !TQT_NO_XIM -} - - -void TQInputContext::setComposePosition(int x, int y) -{ -#if !defined(TQT_NO_XIM) - if (qt_xim && ic) { - XPoint point; - point.x = x; - point.y = y; - - XVaNestedList preedit_attr = - XVaCreateNestedList(0, - XNSpotLocation, &point, - - (char *) 0); - XSetICValues((XIC) ic, XNPreeditAttributes, preedit_attr, (char *) 0); - XFree(preedit_attr); - } -#endif // !TQT_NO_XIM -} - - -void TQInputContext::setComposeArea(int x, int y, int w, int h) -{ -#if !defined(TQT_NO_XIM) - if (qt_xim && ic) { - XRectangle rect; - rect.x = x; - rect.y = y; - rect.width = w; - rect.height = h; - - XVaNestedList preedit_attr = XVaCreateNestedList(0, - XNArea, &rect, - - (char *) 0); - XSetICValues((XIC) ic, XNPreeditAttributes, preedit_attr, (char *) 0); - XFree(preedit_attr); - } -#endif -} - - -int TQInputContext::lookupString(XKeyEvent *event, TQCString &chars, - KeySym *key, Status *status) const -{ - int count = 0; - -#if !defined(TQT_NO_XIM) - if (qt_xim && ic) { - count = XmbLookupString((XIC) ic, event, chars.data(), - chars.size(), key, status); - - if ((*status) == XBufferOverflow ) { - chars.resize(count + 1); - count = XmbLookupString((XIC) ic, event, chars.data(), - chars.size(), key, status); - } - } - -#endif // TQT_NO_XIM - - return count; -} - -void TQInputContext::setFocus() -{ -#if !defined(TQT_NO_XIM) - if (qt_xim && ic) - XSetICFocus((XIC) ic); -#endif // !TQT_NO_XIM -} - -void TQInputContext::setXFontSet(const TQFont &f) -{ -#if !defined(TQT_NO_XIM) - if (font == f) return; // nothing to do - font = f; - - XFontSet fs = getFontSet(font); - if (fontset == fs) return; // nothing to do - fontset = fs; - XVaNestedList preedit_attr = XVaCreateNestedList(0, XNFontSet, fontset, (char *) 0); - XSetICValues((XIC) ic, XNPreeditAttributes, preedit_attr, (char *) 0); - XFree(preedit_attr); -#else - TQ_UNUSED( f ); -#endif -} +#endif //TQ_NO_IM \ No newline at end of file diff --git a/tqtinterface/qt4/src/kernel/tqnamespace.h b/tqtinterface/qt4/src/kernel/tqnamespace.h index b158936..d3919c9 100644 --- a/tqtinterface/qt4/src/kernel/tqnamespace.h +++ b/tqtinterface/qt4/src/kernel/tqnamespace.h @@ -512,7 +512,8 @@ typedef Qt::Orientation Orientation; #ifdef TQT_NO_COMPAT enum GUIStyle { WindowsStyle = 1, // ### TQt 4.0: either remove the obsolete enums or clean up compat vs. - MotifStyle = 4 // ### TQT_NO_COMPAT by reordering or combination into one enum. + MotifStyle = 4, // ### TQT_NO_COMPAT by reordering or combination into one enum. + GtkStyle = 6 // Gtk compability mode }; #else enum GUIStyle { @@ -520,7 +521,8 @@ typedef Qt::Orientation Orientation; WindowsStyle, Win3Style, // OBSOLETE PMStyle, // OBSOLETE - MotifStyle + MotifStyle, + GtkStyle = 6 // Gtk compability mode }; #endif @@ -631,6 +633,87 @@ typedef Qt::Orientation Orientation; Key_Help = (int)Qt::Key_Help, Key_Direction_L = (int)Qt::Key_Direction_L, Key_Direction_R = (int)Qt::Key_Direction_R, + + // International input method support (X keycode - 0xEE00, the + // definition follows TQt/Embedded 2.3.7) Only interesting if + // you are writing your own input method + + // International & multi-key character composition + Key_Multi_key = 0x1120, // Multi-key character compose + Key_Codeinput = 0x1137, + Key_SingleCandidate = 0x113c, + Key_MultipleCandidate = 0x113d, + Key_PreviousCandidate = 0x113e, + + // Misc Functions + Key_Mode_switch = 0x117e, // Character set switch + //Key_script_switch = 0x117e, // Alias for mode_switch + + // Japanese keyboard support + Key_Kanji = 0x1121, // Kanji, Kanji convert + Key_Muhenkan = 0x1122, // Cancel Conversion + //Key_Henkan_Mode = 0x1123, // Start/Stop Conversion + Key_Henkan = 0x1123, // Alias for Henkan_Mode + Key_Romaji = 0x1124, // to Romaji + Key_Hiragana = 0x1125, // to Hiragana + Key_Katakana = 0x1126, // to Katakana + Key_Hiragana_Katakana = 0x1127, // Hiragana/Katakana toggle + Key_Zenkaku = 0x1128, // to Zenkaku + Key_Hankaku = 0x1129, // to Hankaku + Key_Zenkaku_Hankaku = 0x112a, // Zenkaku/Hankaku toggle + Key_Touroku = 0x112b, // Add to Dictionary + Key_Massyo = 0x112c, // Delete from Dictionary + Key_Kana_Lock = 0x112d, // Kana Lock + Key_Kana_Shift = 0x112e, // Kana Shift + Key_Eisu_Shift = 0x112f, // Alphanumeric Shift + Key_Eisu_toggle = 0x1130, // Alphanumeric toggle + //Key_Kanji_Bangou = 0x1137, // Codeinput + //Key_Zen_Koho = 0x113d, // Multiple/All Candidate(s) + //Key_Mae_Koho = 0x113e, // Previous Candidate + + // Korean keyboard support + // + // In fact, many Korean users need only 2 keys, Key_Hangul and + // Key_Hangul_Hanja. But rest of the keys are good for future. + + Key_Hangul = 0x1131, // Hangul start/stop(toggle) + Key_Hangul_Start = 0x1132, // Hangul start + Key_Hangul_End = 0x1133, // Hangul end, English start + Key_Hangul_Hanja = 0x1134, // Start Hangul->Hanja Conversion + Key_Hangul_Jamo = 0x1135, // Hangul Jamo mode + Key_Hangul_Romaja = 0x1136, // Hangul Romaja mode + //Key_Hangul_Codeinput = 0x1137, // Hangul code input mode + Key_Hangul_Jeonja = 0x1138, // Jeonja mode + Key_Hangul_Banja = 0x1139, // Banja mode + Key_Hangul_PreHanja = 0x113a, // Pre Hanja conversion + Key_Hangul_PostHanja = 0x113b, // Post Hanja conversion + //Key_Hangul_SingleCandidate = 0x113c, // Single candidate + //Key_Hangul_MultipleCandidate = 0x113d, // Multiple candidate + //Key_Hangul_PreviousCandidate = 0x113e, // Previous candidate + Key_Hangul_Special = 0x113f, // Special symbols + //Key_Hangul_switch = 0x117e, // Alias for mode_switch + + // dead keys (X keycode - 0xED00 to avoid the conflict) + Key_Dead_Grave = 0x1250, + Key_Dead_Acute = 0x1251, + Key_Dead_Circumflex = 0x1252, + Key_Dead_Tilde = 0x1253, + Key_Dead_Macron = 0x1254, + Key_Dead_Breve = 0x1255, + Key_Dead_Abovedot = 0x1256, + Key_Dead_Diaeresis = 0x1257, + Key_Dead_Abovering = 0x1258, + Key_Dead_Doubleacute = 0x1259, + Key_Dead_Caron = 0x125a, + Key_Dead_Cedilla = 0x125b, + Key_Dead_Ogonek = 0x125c, + Key_Dead_Iota = 0x125d, + Key_Dead_Voiced_Sound = 0x125e, + Key_Dead_Semivoiced_Sound = 0x125f, + Key_Dead_Belowdot = 0x1260, + Key_Dead_Hook = 0x1261, + Key_Dead_Horn = 0x1262, + Key_Space = (int)Qt::Key_Space, // 7 bit printable ASCII Key_Any = Key_Space, Key_Exclam = (int)Qt::Key_Exclam, @@ -703,6 +786,11 @@ typedef Qt::Orientation Orientation; Key_AsciiTilde = (int)Qt::Key_AsciiTilde, // Latin 1 codes adapted from X: keysymdef.h,v 1.21 94/08/28 16:17:06 + // + // This is mainly for compatibility - applications and input + // methods should not use the TQt keycodes between 128 and 255, + // but should rather use the TQKeyEvent::text(). See + // TQETWidget::translateKeyEventInternal() for more details. Key_nobreakspace = (int)Qt::Key_nobreakspace, Key_exclamdown = (int)Qt::Key_exclamdown, diff --git a/tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp b/tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp index 2432607..fd4cc0b 100644 --- a/tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp @@ -1105,11 +1105,16 @@ static void create_dpis() TQ_CHECK_PTR( dpisX ); TQ_CHECK_PTR( dpisY ); for ( i = 0; i < screens; i++ ) { - dpisX[ i ] = (DisplayWidth(dpy,i) * 254 + DisplayWidthMM(dpy,i)*5) - - / (DisplayWidthMM(dpy,i)*10); - dpisY[ i ] = (DisplayHeight(dpy,i) * 254 + DisplayHeightMM(dpy,i)*5) - / (DisplayHeightMM(dpy,i)*10); + if (DisplayWidthMM(dpy,i) < 1) + dpisX[ i ] = 75; // default the dpi to 75. + else + dpisX[ i ] = (DisplayWidth(dpy,i) * 254 + DisplayWidthMM(dpy,i)*5) + / (DisplayWidthMM(dpy,i)*10); + if (DisplayHeightMM(dpy,i) < 1) + dpisY[ i ] = 75; // default the dpi to 75. + else + dpisY[ i ] = (DisplayHeight(dpy,i) * 254 + DisplayHeightMM(dpy,i)*5) + / (DisplayHeightMM(dpy,i)*10); } } diff --git a/tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp b/tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp index 974f23c..2a497e5 100644 --- a/tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp @@ -40,7 +40,19 @@ // NOT REVISED +#include "tqplatformdefs.h" + +#if defined(Q_OS_WIN32) && defined(TQT_MITSHM) +#undef TQT_MITSHM +#endif + +#ifdef TQT_MITSHM + +// Use the MIT Shared Memory extension for pixmap<->image conversions +#define TQT_MITSHM_CONVERSIONS + // Uncomment the next line to enable the MIT Shared Memory extension +// for TQPixmap::xForm() // // WARNING: This has some problems: // @@ -48,7 +60,7 @@ // 2. TQt does not handle the ShmCompletion message, so you will // get strange effects if you xForm() repeatedly. // -// #define TQT_MITSHM +// #define TQT_MITSHM_XFORM #if defined(TQ_OS_WIN32) && defined(TQT_MITSHM) #undef TQT_MITSHM @@ -131,7 +143,7 @@ inline static void qSafeXDestroyImage( XImage *x ) MIT Shared Memory Extension support: makes xForm noticeably (~20%) faster. *****************************************************************************/ -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) static bool xshminit = FALSE; static XShmSegmentInfo xshminfo; @@ -213,8 +225,100 @@ static bool qt_create_mitshm_buffer( const TQPaintDevice* dev, int w, int h ) // return FALSE; // } -#endif // TQT_MITSHM +#endif // TQT_MITSHM_XFORM + +#ifdef TQT_MITSHM_CONVERSIONS + +static bool qt_mitshm_error = false; +static int qt_mitshm_errorhandler( Display*, XErrorEvent* ) +{ + qt_mitshm_error = true; + return 0; +} + +static XImage* qt_XShmCreateImage( Display* dpy, Visual* visual, unsigned int depth, + int format, int /*offset*/, char* /*data*/, unsigned int width, unsigned int height, + int /*bitmap_pad*/, int /*bytes_per_line*/, XShmSegmentInfo* shminfo ) +{ + if( width * height * depth < 100*100*32 ) + return NULL; + static int shm_inited = -1; + if( shm_inited == -1 ) { + if( XShmQueryExtension( dpy )) + shm_inited = 1; + else + shm_inited = 0; + } + if( shm_inited == 0 ) + return NULL; + XImage* xi = XShmCreateImage( dpy, visual, depth, format, NULL, shminfo, width, + height ); + if( xi == NULL ) + return NULL; + shminfo->shmid = shmget( IPC_PRIVATE, xi->bytes_per_line * xi->height, + IPC_CREAT|0600); + if( shminfo->shmid < 0 ) { + XDestroyImage( xi ); + return NULL; + } + shminfo->readOnly = False; + shminfo->shmaddr = (char*)shmat( shminfo->shmid, 0, 0 ); + if( shminfo->shmaddr == (char*)-1 ) { + XDestroyImage( xi ); + shmctl( shminfo->shmid, IPC_RMID, 0 ); + return NULL; + } + xi->data = shminfo->shmaddr; +#ifndef TQT_MITSHM_RMID_IGNORES_REFCOUNT + // mark as deleted to automatically free the memory in case + // of a crash (but this doesn't work e.g. on Solaris) + shmctl( shminfo->shmid, IPC_RMID, 0 ); +#endif + if( shm_inited == 1 ) { // first time + XErrorHandler old_h = XSetErrorHandler( qt_mitshm_errorhandler ); + XShmAttach( dpy, shminfo ); + shm_inited = 2; + XSync( dpy, False ); + XSetErrorHandler( old_h ); + if( qt_mitshm_error ) { // oops ... perhaps we are remote? + shm_inited = 0; + XDestroyImage( xi ); + shmdt( shminfo->shmaddr ); +#ifdef TQT_MITSHM_RMID_IGNORES_REFCOUNT + shmctl( shminfo->shmid, IPC_RMID, 0 ); +#endif + return NULL; + } + } else + XShmAttach( dpy, shminfo ); + return xi; +} + +static void qt_XShmDestroyImage( XImage* xi, XShmSegmentInfo* shminfo ) +{ + XShmDetach( TQPaintDevice::x11AppDisplay(), shminfo ); + XDestroyImage( xi ); + shmdt( shminfo->shmaddr ); +#ifdef TQT_MITSHM_RMID_IGNORES_REFCOUNT + shmctl( shminfo->shmid, IPC_RMID, 0 ); +#endif +} +static XImage* qt_XShmGetImage( const TQPixmap* pix, int format, + XShmSegmentInfo* shminfo ) +{ + XImage* xi = qt_XShmCreateImage( pix->x11Display(), (Visual*)pix->x11Visual(), + pix->depth(), format, 0, 0, pix->width(), pix->height(), 32, 0, shminfo ); + if( xi == NULL ) + return NULL; + if( XShmGetImage( pix->x11Display(), pix->handle(), xi, 0, 0, AllPlanes ) == False ) { + qt_XShmDestroyImage( xi, shminfo ); + return NULL; + } + return xi; +} + +#endif // TQT_MITSHM_CONVERSIONS /***************************************************************************** Internal functions @@ -667,9 +771,20 @@ TQImage TQPixmap::convertToImage() const d = 32; // > 8 ==> 32 XImage *xi = (XImage *)data->ximage; // any cached ximage? - if ( !xi ) // fetch data from X server +#ifdef TQT_MITSHM_CONVERSIONS + bool mitshm_ximage = false; + XShmSegmentInfo shminfo; +#endif + if ( !xi ) { // fetch data from X server +#ifdef TQT_MITSHM_CONVERSIONS + xi = qt_XShmGetImage( this, mono ? XYPixmap : ZPixmap, &shminfo ); + if( xi ) { + mitshm_ximage = true; + } else +#endif xi = XGetImage( x11Display(), hd, 0, 0, w, h, AllPlanes, mono ? XYPixmap : ZPixmap ); + } TQ_CHECK_PTR( xi ); if (!xi) return image; // null image @@ -680,15 +795,31 @@ TQImage TQPixmap::convertToImage() const TQImage::LittleEndian : TQImage::BigEndian; } image.create( w, h, d, 0, bitOrder ); - if ( image.isNull() ) // could not create image + if ( image.isNull() ) { // could not create image +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + qt_XShmDestroyImage( xi, &shminfo ); + else +#endif + qSafeXDestroyImage( xi ); return image; + } const TQPixmap* msk = tqmask(); const TQPixmap *alf = data->alphapm; TQImage alpha; if (alf) { - XImage *axi = XGetImage(x11Display(), alf->hd, 0, 0, w, h, AllPlanes, ZPixmap); + XImage* axi; +#ifdef TQT_MITSHM_CONVERSIONS + bool mitshm_aximage = false; + XShmSegmentInfo ashminfo; + axi = qt_XShmGetImage( alf, ZPixmap, &ashminfo ); + if( axi ) { + mitshm_aximage = true; + } else +#endif + axi = XGetImage(x11Display(), alf->hd, 0, 0, w, h, AllPlanes, ZPixmap); if (axi) { image.setAlphaBuffer( TRUE ); @@ -702,6 +833,11 @@ TQImage TQPixmap::convertToImage() const src += axi->bytes_per_line; } +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_aximage ) + qt_XShmDestroyImage( axi, &ashminfo ); + else +#endif qSafeXDestroyImage( axi ); } } else if (msk) { @@ -844,6 +980,12 @@ TQImage TQPixmap::convertToImage() const xi->bits_per_pixel ); #endif image.reset(); +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + qt_XShmDestroyImage( xi, &shminfo ); + else +#endif + qSafeXDestroyImage( xi ); return image; } @@ -949,10 +1091,22 @@ TQImage TQPixmap::convertToImage() const delete [] carr; } if ( data->optim != BestOptim ) { // throw away image data +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + qt_XShmDestroyImage( xi, &shminfo ); + else +#endif qSafeXDestroyImage( xi ); ((TQPixmap*)this)->data->ximage = 0; - } else // keep ximage data + } else { // keep ximage data +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) { // copy the XImage? + qt_XShmDestroyImage( xi, &shminfo ); + xi = 0; + } +#endif ((TQPixmap*)this)->data->ximage = xi; + } return image; } @@ -1125,6 +1279,11 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) bool trucol = (visual->c_class == TrueColor || visual->c_class == DirectColor); int nbytes = image.numBytes(); uchar *newbits= 0; + int newbits_size = 0; +#ifdef TQT_MITSHM_CONVERSIONS + bool mitshm_ximage = false; + XShmSegmentInfo shminfo; +#endif if ( trucol ) { // truecolor display TQRgb pix[256]; // pixel translation table @@ -1153,19 +1312,24 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) } } +#ifdef TQT_MITSHM_CONVERSIONS + xi = qt_XShmCreateImage( dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0, &shminfo ); + if( xi != NULL ) { + mitshm_ximage = true; + newbits = (uchar*)xi->data; + } + else +#endif xi = XCreateImage( dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0 ); - TQ_CHECK_PTR( xi ); if (!xi) return false; + if( newbits == NULL ) newbits = (uchar *)malloc( xi->bytes_per_line*h ); TQ_CHECK_PTR( newbits ); if ( !newbits ) // no memory return FALSE; int bppc = xi->bits_per_pixel; - if ( bppc > 8 && xi->byte_order == LSBFirst ) - bppc++; - bool contig_bits = n_bits(red_mask) == rbits && n_bits(green_mask) == gbits && n_bits(blue_mask) == bbits; @@ -1215,31 +1379,70 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) init=TRUE; } - for ( uint y=0; ybytes_per_line*y; - TQRgb* p = (TQRgb *)src; + enum { BPP8, + BPP16_8_3_M3, BPP16_7_2_M3, BPP16_MSB, BPP16_LSB, + BPP24_MSB, BPP24_LSB, + BPP32_16_8_0, BPP32_MSB, BPP32_LSB + } mode = BPP8; -#define GET_RGB \ - int r = tqRed ( *p ); \ - int g = tqGreen( *p ); \ - int b = tqBlue ( *p++ ); \ - r = red_shift > 0 \ - ? r << red_shift : r >> -red_shift; \ - g = green_shift > 0 \ - ? g << green_shift : g >> -green_shift; \ - b = blue_shift > 0 \ - ? b << blue_shift : b >> -blue_shift; + if ( bppc > 8 && xi->byte_order == LSBFirst ) + bppc++; + + int wordsize; + bool bigendian; + qSysInfo( &wordsize, &bigendian ); + bool same_msb_lsb = ( xi->byte_order == MSBFirst ) == ( bigendian ); + + if( bppc == 8 ) // 8 bit + mode = BPP8; + else if( bppc == 16 || bppc == 17 ) { // 16 bit MSB/LSB + if( red_shift == 8 && green_shift == 3 && blue_shift == -3 + && !d8 && same_msb_lsb ) + mode = BPP16_8_3_M3; + else if( red_shift == 7 && green_shift == 2 && blue_shift == -3 + && !d8 && same_msb_lsb ) + mode = BPP16_7_2_M3; + else + mode = bppc == 17 ? BPP16_LSB : BPP16_MSB; + } else if( bppc == 24 || bppc == 25 ) { // 24 bit MSB/LSB + mode = bppc == 25 ? BPP24_LSB : BPP24_MSB; + } else if( bppc == 32 || bppc == 33 ) { // 32 bit MSB/LSB + if( red_shift == 16 && green_shift == 8 && blue_shift == 0 + && !d8 && same_msb_lsb ) + mode = BPP32_16_8_0; + else + mode = bppc == 33 ? BPP32_LSB : BPP32_MSB; + } else + qFatal("Logic error 3"); #define GET_PIXEL \ int pixel; \ if ( d8 ) pixel = pix[*src++]; \ else { \ - GET_RGB \ - pixel = (b & blue_mask)|(g & green_mask) | (r & red_mask) \ + int r = tqRed ( *p ); \ + int g = tqGreen( *p ); \ + int b = tqBlue ( *p++ ); \ + r = red_shift > 0 \ + ? r << red_shift : r >> -red_shift; \ + g = green_shift > 0 \ + ? g << green_shift : g >> -green_shift; \ + b = blue_shift > 0 \ + ? b << blue_shift : b >> -blue_shift; \ + pixel = (r & red_tqmask)|(g & green_tqmask) | (b & blue_tqmask) \ | ~(blue_mask | green_mask | red_mask); \ } +// optimized case - no d8 case, shift only once instead of twice, tqmask only once instead of twice, +// use direct values instead of variables, and use only one statement +// (*p >> 16), (*p >> 8 ) and (*p) are tqRed(),tqGreen() and tqBlue() without masking +// shifts have to be passed including the shift operator (e.g. '>>3'), because of the direction +#define GET_PIXEL_OPT(red_shift,green_shift,blue_shift,red_tqmask,green_tqmask,blue_tqmask) \ + int pixel = ((( *p >> 16 ) red_shift ) & red_tqmask ) \ + | ((( *p >> 8 ) green_shift ) & green_tqmask ) \ + | ((( *p ) blue_shift ) & blue_tqmask ); \ + ++p; + + #define GET_PIXEL_DITHER_TC \ int r = tqRed ( *p ); \ int g = tqGreen( *p ); \ @@ -1262,89 +1465,176 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) ? b << blue_shift : b >> -blue_shift; \ int pixel = (b & blue_mask)|(g & green_mask) | (r & red_mask); - if ( dither_tc ) { - uint x; - switch ( bppc ) { - case 16: // 16 bit MSB - for ( x=0; x> 8); - *dst++ = pixel; - } +// again, optimized case +// can't be optimized that much :( +#define GET_PIXEL_DITHER_TC_OPT(red_shift,green_shift,blue_shift,red_tqmask,green_tqmask,blue_tqmask, \ + rbits,gbits,bbits) \ + const int thres = D[x%16][y%16]; \ + int r = tqRed ( *p ); \ + if ( r <= (255-(1<<(8-rbits))) && ((r< thres) \ + r += (1<<(8-rbits)); \ + int g = tqGreen( *p ); \ + if ( g <= (255-(1<<(8-gbits))) && ((g< thres) \ + g += (1<<(8-gbits)); \ + int b = tqBlue ( *p++ ); \ + if ( b <= (255-(1<<(8-bbits))) && ((b< thres) \ + b += (1<<(8-bbits)); \ + int pixel = (( r red_shift ) & red_tqmask ) \ + | (( g green_shift ) & green_tqmask ) \ + | (( b blue_shift ) & blue_tqmask ); + +#define CYCLE(body) \ + for ( uint y=0; ybytes_per_line*y; \ + TQRgb* p = (TQRgb *)src; \ + body \ + } + + if ( dither_tc ) { + switch ( mode ) { + case BPP16_8_3_M3: + CYCLE( + TQ_INT16* dst16 = (TQ_INT16*)dst; + for ( uint x=0; x>3,0xf800,0x7e0,0x1f,5,6,5) + *dst16++ = pixel; + } + ) break; - case 17: // 16 bit LSB - for ( x=0; x> 8; - } + case BPP16_7_2_M3: + CYCLE( + TQ_INT16* dst16 = (TQ_INT16*)dst; + for ( uint x=0; x>3,0x7c00,0x3e0,0x1f) + *dst16++ = pixel; + } + ) break; default: qFatal("Logic error"); } - } else { - uint x; - switch ( bppc ) { - case 8: // 8 bit - for ( x=0; x> 8); - *dst++ = pixel; - } + case BPP16_8_3_M3: + CYCLE( + TQ_INT16* dst16 = (TQ_INT16*)dst; + for ( uint x=0; x>3,0xf800,0x7e0,0x1f) + *dst16++ = pixel; + } + ) break; - case 17: // 16 bit LSB - for ( x=0; x> 8; - } + case BPP16_7_2_M3: + CYCLE( + TQ_INT16* dst16 = (TQ_INT16*)dst; + for ( uint x=0; x>3,0x7c00,0x3e0,0x1f,5,5,5) + *dst16++ = pixel; + } + ) break; - case 24: // 24 bit MSB - for ( x=0; x> 16; - *dst++ = pixel >> 8; - *dst++ = pixel; - } + case BPP16_MSB: // 16 bit MSB + CYCLE( + for ( uint x=0; x> 8); + *dst++ = pixel; + } + ) break; - case 25: // 24 bit LSB - for ( x=0; x> 8; - *dst++ = pixel >> 16; - } + case BPP16_LSB: // 16 bit LSB + CYCLE( + for ( uint x=0; x> 8; + } + ) break; - case 32: // 32 bit MSB - for ( x=0; x> 24; - *dst++ = pixel >> 16; - *dst++ = pixel >> 8; - *dst++ = pixel; - } + case BPP16_MSB: // 16 bit MSB + CYCLE( + for ( uint x=0; x> 8); + *dst++ = pixel; + } + ) + break; + case BPP16_LSB: // 16 bit LSB + CYCLE( + for ( uint x=0; x> 8; + } + ) + break; + case BPP24_MSB: // 24 bit MSB + CYCLE( + for ( uint x=0; x> 16; + *dst++ = pixel >> 8; + *dst++ = pixel; + } + ) break; case 33: // 32 bit LSB - for ( x=0; x> 8; - *dst++ = pixel >> 16; - *dst++ = pixel >> 24; - } + case BPP24_LSB: // 24 bit LSB + CYCLE( + for ( uint x=0; x> 8; + *dst++ = pixel >> 16; + } + ) break; - default: - qFatal("Logic error 2"); - } - } - } - xi->data = (char *)newbits; + case BPP32_16_8_0: + CYCLE( + memcpy( dst, p, w * 4 ); + ) + break; + case BPP32_MSB: // 32 bit MSB + CYCLE( + for ( uint x=0; x> 24; + *dst++ = pixel >> 16; + *dst++ = pixel >> 8; + *dst++ = pixel; + } + ) + break; + case BPP32_LSB: // 32 bit LSB + CYCLE( + for ( uint x=0; x> 8; + *dst++ = pixel >> 16; + *dst++ = pixel >> 24; + } + ) + break; + default: + qFatal("Logic error 2"); + } + } + xi->data = (char *)newbits; } if ( d == 8 && !trucol ) { // 8 bit pixmap @@ -1363,6 +1653,7 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) } newbits = (uchar *)malloc( nbytes ); // copy image into newbits + newbits_size = nbytes; TQ_CHECK_PTR( newbits ); if ( !newbits ) // no memory return FALSE; @@ -1479,12 +1770,19 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) } } - if ( !xi ) { // X image not created + if ( !xi ) { +#ifdef TQT_MITSHM_CONVERSIONS + xi = qt_XShmCreateImage( dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0, &shminfo ); + if( xi != NULL ) + mitshm_ximage = true; + else +#endif // X image not created xi = XCreateImage( dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0 ); if ( xi->bits_per_pixel == 16 ) { // convert 8 bpp ==> 16 bpp ushort *p2; int p2inc = xi->bytes_per_line/sizeof(ushort); ushort *newerbits = (ushort *)malloc( xi->bytes_per_line * h ); + newbits_size = xi->bytes_per_line * h; TQ_CHECK_PTR( newerbits ); if ( !newerbits ) // no memory return FALSE; @@ -1502,6 +1800,14 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) "(bpp=%d)", xi->bits_per_pixel ); #endif } +#ifdef TQT_MITSHM_CONVERSIONS + if( newbits_size > 0 && mitshm_ximage ) { // need to copy to shared memory + memcpy( xi->data, newbits, newbits_size ); + free( newbits ); + newbits = (uchar*)xi->data; + } + else +#endif xi->data = (char *)newbits; } @@ -1535,19 +1841,24 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) } +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + XShmPutImage( dpy, hd, qt_xget_readonly_gc( x11Screen(), FALSE ), + xi, 0, 0, 0, 0, w, h, False ); + else +#endif XPutImage( dpy, hd, qt_xget_readonly_gc( x11Screen(), FALSE ), xi, 0, 0, 0, 0, w, h ); - if ( data->optim != BestOptim ) { // throw away image - qSafeXDestroyImage( xi ); - data->ximage = 0; - } else { // keep ximage that we created - data->ximage = xi; - } data->w = w; data->h = h; data->d = dd; + XImage* axi = NULL; +#ifdef TQT_MITSHM_CONVERSIONS + bool mitshm_aximage = false; + XShmSegmentInfo ashminfo; +#endif if ( image.hasAlphaBuffer() ) { TQBitmap m; m = image.createAlphaMask( conversion_flags ); @@ -1583,38 +1894,90 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) data->alphapm->rendhd = (HANDLE) XftDrawCreateAlpha( x11Display(), data->alphapm->hd, 8 ); - XImage *axi = XCreateImage(x11Display(), (Visual *) x11Visual(), +#ifdef TQT_MITSHM_CONVERSIONS + axi = qt_XShmCreateImage( x11Display(), (Visual*)x11Visual(), + 8, ZPixmap, 0, 0, w, h, 8, 0, &ashminfo ); + if( axi != NULL ) + mitshm_aximage = true; + else +#endif + axi = XCreateImage(x11Display(), (Visual *) x11Visual(), 8, ZPixmap, 0, 0, w, h, 8, 0); if (axi) { + if( axi->data==NULL ) { // the data is deleted by qSafeXDestroyImage axi->data = (char *) malloc(h * axi->bytes_per_line); TQ_CHECK_PTR( axi->data ); + } char *aptr = axi->data; if (image.depth() == 32) { const int *iptr = (const int *) image.bits(); - int max = w * h; - while (max--) - *aptr++ = *iptr++ >> 24; // squirt + if( axi->bytes_per_line == (int)w ) { + int max = w * h; + while (max--) + *aptr++ = *iptr++ >> 24; // squirt + } else { + for (uint i = 0; i < h; ++i ) { + for (uint j = 0; j < w; ++j ) + *aptr++ = *iptr++ >> 24; // squirt + aptr += ( axi->bytes_per_line - w ); + } + } } else if (image.depth() == 8) { const TQRgb * const rgb = image.colorTable(); for (uint y = 0; y < h; ++y) { const uchar *iptr = image.scanLine(y); for (uint x = 0; x < w; ++x) *aptr++ = tqAlpha(rgb[*iptr++]); + aptr += ( axi->bytes_per_line - w ); } } GC gc = XCreateGC(x11Display(), data->alphapm->hd, 0, 0); + #ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_aximage ) + XShmPutImage( dpy, data->alphapm->hd, gc, axi, 0, 0, 0, 0, w, h, False ); + else +#endif XPutImage(dpy, data->alphapm->hd, gc, axi, 0, 0, 0, 0, w, h); XFreeGC(x11Display(), gc); - qSafeXDestroyImage(axi); } } #endif // TQT_NO_XFTFREETYPE } +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage || mitshm_aximage ) + XSync( x11Display(), False ); // wait until processed +#endif + + if ( data->optim != BestOptim ) { // throw away image +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + qt_XShmDestroyImage( xi, &shminfo ); + else +#endif + qSafeXDestroyImage( xi ); + data->ximage = 0; + } else { // keep ximage that we created +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) { // copy the XImage? + qt_XShmDestroyImage( xi, &shminfo ); + xi = 0; + } +#endif + data->ximage = xi; + } + if( axi ) { +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_aximage ) + qt_XShmDestroyImage( axi, &ashminfo ); + else +#endif + qSafeXDestroyImage(axi); + } return TRUE; } @@ -1777,7 +2140,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const return pm; } -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) static bool try_once = TRUE; if (try_once) { try_once = FALSE; @@ -1810,7 +2173,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const dbpl = ((w*bpp+31)/32)*4; dbytes = dbpl*h; -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) if ( use_mitshm ) { dptr = (uchar *)xshmimg->data; uchar fillbyte = bpp == 8 ? white.pixel() : 0xff; @@ -1826,7 +2189,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const memset( dptr, TQt::white.pixel( x11Screen() ), dbytes ); else memset( dptr, 0xff, dbytes ); -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) } #endif @@ -1857,7 +2220,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const } else { xbpl = (w*bpp)/8; p_inc = dbpl - xbpl; -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) if ( use_mitshm ) p_inc = xshmimg->bytes_per_line - xbpl; #endif @@ -1894,7 +2257,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const TQPixmap pm( w, h ); pm.data->uninit = FALSE; pm.x11SetScreen( x11Screen() ); -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) if ( use_mitshm ) { XCopyArea( dpy, xshmpm, pm.handle(), gc, 0, 0, w, h, 0, 0 ); } else { @@ -1903,7 +2266,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const ZPixmap, 0, (char *)dptr, w, h, 32, 0 ); XPutImage( dpy, pm.handle(), gc, xi, 0, 0, 0, 0, w, h); qSafeXDestroyImage( xi ); -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) } #endif diff --git a/tqtinterface/qt4/src/kernel/tqrichtext.cpp b/tqtinterface/qt4/src/kernel/tqrichtext.cpp index 8b614d6..00484d6 100644 --- a/tqtinterface/qt4/src/kernel/tqrichtext.cpp +++ b/tqtinterface/qt4/src/kernel/tqrichtext.cpp @@ -9028,7 +9028,7 @@ void TQTextCursor::restoreState() pop(); } -bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link ) +bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link, bool loosePlacing, bool matchBetweenCharacters ) { TQPoint pos( p ); TQRect r; @@ -9046,7 +9046,7 @@ bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link ) str = s; if ( pos.y() >= r.y() && pos.y() <= r.y() + r.height() ) break; - if ( !s->next() ) { + if ( loosePlacing == TRUE && !s->next() ) { #ifdef TQ_WS_MACX pos.setX( s->rect().x() + s->rect().width() ); #endif @@ -9087,7 +9087,7 @@ bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link ) if ( pos.x() < x ) pos.setX( x + 1 ); int cw; - int curpos = s->length()-1; + int curpos = -1; int dist = 10000000; bool inCustom = FALSE; while ( i < nextLine ) { @@ -9109,14 +9109,21 @@ bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link ) cpos += cw; int d = cpos - pos.x(); bool dm = d < 0 ? !chr->rightToLeft : chr->rightToLeft; - if ( (TQABS( d ) < dist || (dist == d && dm == TRUE )) && para->string()->validCursorPosition( i ) ) { + if ( ( matchBetweenCharacters == TRUE && (TQABS( d ) < dist || (dist == d && dm == TRUE )) && para->string()->validCursorPosition( i ) ) || + ( matchBetweenCharacters == FALSE && ( d == 0 || dm == TRUE ) ) ) { dist = TQABS( d ); - if ( !link || pos.x() >= x + chr->x ) + if ( !link || ( pos.x() >= x + chr->x && ( loosePlacing == TRUE || pos.x() < cpos ) ) ) curpos = i; } } i++; } + if ( curpos == -1 ) { + if ( loosePlacing == TRUE ) + curpos = s->length()-1; + else + return FALSE; + } setIndex( curpos ); #ifndef TQT_NO_TEXTCUSTOMITEM @@ -13244,6 +13251,9 @@ void TQTextParagraph::drawString( TQPainter &painter, const TQString &str, int s tmpw = fullSelectionWidth - xleft; painter.fillRect( xleft, y, tmpw, h, color ); painter.drawText( xstart, y + baseLine, str, start, len, dir ); + // draw preedit's underline + if (selection == TQTextDocument::IMCompositionText) + painter.drawLine(xstart, y + baseLine + 1, xstart + w, y + baseLine + 1); if (selStart != start || selEnd != start + len || selWrap) painter.restore(); } diff --git a/tqtinterface/qt4/src/kernel/tqrichtext_p.h b/tqtinterface/qt4/src/kernel/tqrichtext_p.h index b9cbd98..edb8c76 100644 --- a/tqtinterface/qt4/src/kernel/tqrichtext_p.h +++ b/tqtinterface/qt4/src/kernel/tqrichtext_p.h @@ -2523,7 +2523,8 @@ public: int totalOffsetY() const; // total document offset bool place( const TQPoint &pos, TQTextParagraph *s ) { return place( pos, s, FALSE ); } - bool place( const TQPoint &pos, TQTextParagraph *s, bool link ); + bool place( const TQPoint &pos, TQTextParagraph *s, bool link ) { return place( pos, s, link, TRUE, TRUE ); } + bool place( const TQPoint &pos, TQTextParagraph *s, bool link, bool loosePlacing, bool matchBetweenCharacters ); void restoreState(); diff --git a/tqtinterface/qt4/src/kernel/tqt_x11_p.h b/tqtinterface/qt4/src/kernel/tqt_x11_p.h index e08531d..a33ce01 100644 --- a/tqtinterface/qt4/src/kernel/tqt_x11_p.h +++ b/tqtinterface/qt4/src/kernel/tqt_x11_p.h @@ -177,6 +177,11 @@ extern "C" { #endif // TQT_NO_XRENDER +#ifndef TQT_NO_XSYNC +# include +#endif // TQT_NO_XSYNC + + #ifndef TQT_NO_XKB # include #endif // TQT_NO_XKB diff --git a/tqtinterface/qt4/src/kernel/tqwidget.cpp b/tqtinterface/qt4/src/kernel/tqwidget.cpp index 9e60bac..67d0e1b 100644 --- a/tqtinterface/qt4/src/kernel/tqwidget.cpp +++ b/tqtinterface/qt4/src/kernel/tqwidget.cpp @@ -5953,8 +5953,24 @@ void TQWidget::setFocus() if ( isActiveWindow() ) { TQWidget * prev = tqApp->focus_widget; if ( prev ) { - if ( prev != this ) + // This part is never executed when TQ_WS_X11? Preceding XFocusOut + // had already reset focus_widget when received XFocusIn + + // Don't reset input context explicitly here. Whether reset or not + // when focusing out is a responsibility of input methods. For + // example, Japanese input context should not be reset here. The + // context sometimes contains a whole paragraph and has minutes of + // lifetime different to ephemeral one in other languages. The + // input context should be survived until focused again. So we + // delegate the responsibility to input context via + // unfocusInputContext(). + if ( prev != this && prev->isInputMethodEnabled() ) { +#if 0 prev->resetInputContext(); +#else + prev->unfocusInputContext(); +#endif + } } #if defined(TQ_WS_WIN) else { @@ -5962,9 +5978,8 @@ void TQWidget::setFocus() } #endif tqApp->focus_widget = this; -#if defined(TQ_WS_X11) - focusInputContext(); -#endif + if( isInputMethodEnabled() ) + focusInputContext(); #if defined(TQ_WS_WIN) if ( !tqtopLevelWidget()->isPopup() ) @@ -6012,7 +6027,11 @@ void TQWidget::clearFocus() focusProxy()->clearFocus(); return; } else if ( hasFocus() ) { +#if !defined(TQ_WS_X11) resetInputContext(); +#else + unfocusInputContext(); +#endif TQWidget* w = tqApp->tqfocusWidget(); // clear active focus tqApp->focus_widget = 0; @@ -7338,7 +7357,13 @@ bool TQWidget::event( TQEvent *e ) break; case TQEvent::MouseButtonPress: + // Don't reset input context here. Whether reset or not is + // a responsibility of input method. reset() will be + // called by mouseHandler() of input method if necessary + // via mousePressEvent() of text widgets. +#if 0 resetInputContext(); +#endif mousePressEvent( (TQMouseEvent*)e ); if ( ! ((TQMouseEvent*)e)->isAccepted() ) return FALSE; diff --git a/tqtinterface/qt4/src/kernel/tqwidget.h b/tqtinterface/qt4/src/kernel/tqwidget.h index c027464..65b424e 100644 --- a/tqtinterface/qt4/src/kernel/tqwidget.h +++ b/tqtinterface/qt4/src/kernel/tqwidget.h @@ -64,6 +64,10 @@ #endif // TQFONTENGINE_P_H #endif // USE_QT4 +#if defined(TQ_WS_X11) && !defined(TQT_NO_IM) +class TQInputContext; +#endif + class TQLayout; #ifdef USE_QT4 @@ -980,7 +984,19 @@ public: CGContextRef macCGContext(bool clipped=TRUE) const; #endif #endif - +#if defined(TQ_WS_X11) + enum X11WindowType { + X11WindowTypeSelect, + X11WindowTypeCombo, + X11WindowTypeDND, + X11WindowTypeTooltip, + X11WindowTypeMenu, // torn-off + X11WindowTypeDropdown, + X11WindowTypePopup + }; + void x11SetWindowType( X11WindowType type = X11WindowTypeSelect ); + void x11SetWindowTransient( TQWidget* tqparent ); +#endif void setWindowOpacity(double level); double windowOpacity() const; @@ -1051,6 +1067,18 @@ protected: int metric( int ) const; +#if defined(TQ_WS_X11) +#if !defined(TQT_NO_IM_EXTENSIONS) + virtual TQWidget *icHolderWidget(); +#else + TQWidget *icHolderWidget(); +#endif + TQInputContext *getInputContext(); + void changeInputContext( const TQString & ); + void sendMouseEventToInputContext( int x, TQEvent::Type type, + TQt::ButtonState button, + TQt::ButtonState state ); +#endif void resetInputContext(); virtual void create( WId = 0, bool initializeWindow = TRUE, @@ -1082,14 +1110,25 @@ protected: private Q_SLOTS: void focusProxyDestroyed(); +#if defined(TQ_WS_X11) + void destroyInputContext(); +#endif private: void setFontSys( TQFont *f = 0 ); #if defined(TQ_WS_X11) void createInputContext(); - void destroyInputContext(); void focusInputContext(); + void unfocusInputContext(); void checkChildrenDnd(); + +#ifndef TQT_NO_XSYNC + void createSyncCounter(); + void destroySyncCounter(); + void incrementSyncCounter(); + void handleSyncRequest( void* ev ); +#endif + #elif defined(TQ_WS_MAC) uint own_id : 1, macDropEnabled : 1; EventHandlerRef window_event; @@ -1159,6 +1198,9 @@ private: TQFont fnt; #ifndef TQT_NO_LAYOUT TQLayout *lay_out; +#endif +#if defined(TQ_WS_X11) && !defined(TQT_NO_IM) && !defined(TQT_NO_IM_EXTENSIONS) + TQInputContext *ic; // Input Context #endif TQWExtra *extra; #if defined(TQ_WS_TQWS) @@ -1471,7 +1513,13 @@ struct TQ_EXPORT TQTLWExtra { uint dnd : 1; // DND properties installed uint uspos : 1; // User defined position uint ussize : 1; // User defined size - void *xic; // XIM Input Context +#if defined(TQT_NO_IM_EXTENSIONS) + void *xic; // Input Context +#endif +#ifndef TQT_NO_XSYNC + ulong syncCounter; + uint syncRequestValue[2]; +#endif #endif #if defined(TQ_WS_MAC) WindowGroupRef group; diff --git a/tqtinterface/qt4/src/kernel/tqwidget_x11.cpp b/tqtinterface/qt4/src/kernel/tqwidget_x11.cpp index f8c605a..c6e7abb 100644 --- a/tqtinterface/qt4/src/kernel/tqwidget_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqwidget_x11.cpp @@ -83,6 +83,11 @@ extern Atom qt_net_wm_window_type_menu; extern Atom qt_net_wm_window_type_utility; extern Atom qt_net_wm_window_type_splash; extern Atom qt_net_wm_window_type_override; +extern Atom qt_net_wm_window_type_dropdown_menu; +extern Atom qt_net_wm_window_type_popup_menu; +extern Atom qt_net_wm_window_type_combo; +extern Atom qt_net_wm_window_type_dnd; +extern Atom qt_net_wm_window_type_tooltip; extern Atom qt_net_wm_pid; extern Atom qt_net_wm_user_time; extern Atom qt_enlightenment_desktop; @@ -300,11 +305,9 @@ int qt_sip_count( TQWidget* ); bool qt_wstate_iconified( WId ); void qt_updated_rootinfo(); -#ifndef TQT_NO_XIM -#include "tqinputcontext_p.h" - -extern XIM qt_xim; -extern XIMStyle qt_xim_style; +#ifndef TQT_NO_IM +#include "tqinputcontext.h" +#include "tqinputcontextfactory.h" #endif // Paint event clipping magic @@ -322,6 +325,12 @@ extern bool qt_deferred_map_tqcontains(TQWidget *); static TQWidget *mouseGrb = 0; static TQWidget *keyboardGrb = 0; +#ifndef TQT_NO_XSYNC +extern Atom qt_net_wm_sync_request_counter; +extern Atom qt_net_wm_sync_request; +extern bool qt_use_xsync; +#endif + // defined in qfont_x11.cpp extern bool qt_has_xft; @@ -683,10 +692,6 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) x11Colormap() ); #endif // TQT_NO_XFTFREETYPE - // NET window types - long net_wintypes[7] = { 0, 0, 0, 0, 0, 0, 0 }; - int curr_wintype = 0; - // NET window states long net_winstates[6] = { 0, 0, 0, 0, 0, 0 }; int curr_winstate = 0; @@ -708,7 +713,6 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) if ( testWFlags(WStyle_Splash) ) { if (qt_net_supports(qt_net_wm_window_type_splash)) { clearWFlags( WX11BypassWM ); - net_wintypes[curr_wintype++] = qt_net_wm_window_type_splash; } else { setWFlags( WX11BypassWM | WStyle_Tool | WStyle_NoBorder ); } @@ -717,27 +721,22 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) mwmhints.decorations = 0L; mwmhints.flags |= (1L << 1); // MWM_HINTS_DECORATIONS - if ( testWFlags( WStyle_NoBorder ) ) { - // override netwm type - quick and easy for KDE noborder - net_wintypes[curr_wintype++] = qt_net_wm_window_type_override; - } else { - if ( testWFlags( WStyle_NormalBorder | WStyle_DialogBorder ) ) { - mwmhints.decorations |= (1L << 1); // MWM_DECOR_BORDER - mwmhints.decorations |= (1L << 2); // MWM_DECOR_RESIZEH - } + if ( testWFlags( WStyle_NormalBorder | WStyle_DialogBorder ) ) { + mwmhints.decorations |= (1L << 1); // MWM_DECOR_BORDER + mwmhints.decorations |= (1L << 2); // MWM_DECOR_RESIZEH + } - if ( testWFlags( WStyle_Title ) ) - mwmhints.decorations |= (1L << 3); // MWM_DECOR_TITLE + if ( testWFlags( WStyle_Title ) ) + mwmhints.decorations |= (1L << 3); // MWM_DECOR_TITLE - if ( testWFlags( WStyle_SysMenu ) ) - mwmhints.decorations |= (1L << 4); // MWM_DECOR_MENU + if ( testWFlags( WStyle_SysMenu ) ) + mwmhints.decorations |= (1L << 4); // MWM_DECOR_MENU - if ( testWFlags( WStyle_Minimize ) ) - mwmhints.decorations |= (1L << 5); // MWM_DECOR_MINIMIZE + if ( testWFlags( WStyle_Minimize ) ) + mwmhints.decorations |= (1L << 5); // MWM_DECOR_MINIMIZE - if ( testWFlags( WStyle_Maximize ) ) - mwmhints.decorations |= (1L << 6); // MWM_DECOR_MAXIMIZE - } + if ( testWFlags( WStyle_Maximize ) ) + mwmhints.decorations |= (1L << 6); // MWM_DECOR_MAXIMIZE if (testWFlags(WStyle_Tool)) { wsa.save_under = True; @@ -757,23 +756,6 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) } } - // ### need a better way to do this - if (inherits("TQPopupMenu")) { - // menu netwm type - net_wintypes[curr_wintype++] = qt_net_wm_window_type_menu; - } else if (inherits("TQToolBar")) { - // toolbar netwm type - net_wintypes[curr_wintype++] = qt_net_wm_window_type_toolbar; - } else if (testWFlags(WStyle_Customize) && testWFlags(WStyle_Tool)) { - // utility netwm type - net_wintypes[curr_wintype++] = qt_net_wm_window_type_utility; - } - - if (dialog) // dialog netwm type - net_wintypes[curr_wintype++] = qt_net_wm_window_type_dialog; - // normal netwm type - default - net_wintypes[curr_wintype++] = qt_net_wm_window_type_normal; - // stays on top if (testWFlags(WStyle_StaysOnTop)) { net_winstates[curr_winstate++] = qt_net_wm_state_above; @@ -808,6 +790,7 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) wsa.save_under = True; XChangeWindowAttributes( dpy, id, CWOverrideRedirect | CWSaveUnder, &wsa ); + x11SetWindowType(); } else if ( topLevel && !desktop ) { // top-level widget TQWidget *p = parentWidget(); // real tqparent if (p) @@ -851,11 +834,14 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) XResizeWindow( dpy, id, crect.width(), crect.height() ); XStoreName( dpy, id, tqAppName() ); - Atom protocols[4]; + Atom protocols[5]; int n = 0; protocols[n++] = qt_wm_delete_window; // support del window protocol protocols[n++] = qt_wm_take_focus; // support take focus window protocol protocols[n++] = qt_net_wm_ping; // support _NET_WM_PING protocol +#ifndef TQT_NO_XSYNC + protocols[n++] = qt_net_wm_sync_request;// support the _NET_WM_SYNC_REQUEST protocol +#endif if ( testWFlags( WStyle_ContextHelp ) ) protocols[n++] = qt_net_wm_context_help; XSetWMProtocols( dpy, id, protocols, n ); @@ -867,12 +853,7 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) else XDeleteProperty(dpy, id, qt_xa_motif_wm_hints); - // set _NET_WM_WINDOW_TYPE - if (curr_wintype > 0) - XChangeProperty(dpy, id, qt_net_wm_window_type, XA_ATOM, 32, PropModeReplace, - (unsigned char *) net_wintypes, curr_wintype); - else - XDeleteProperty(dpy, id, qt_net_wm_window_type); + x11SetWindowType(); // set _NET_WM_WINDOW_STATE if (curr_winstate > 0) @@ -886,6 +867,14 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) XChangeProperty(dpy, id, qt_net_wm_pid, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &curr_pid, 1); +#ifndef TQT_NO_XSYNC + // set _NET_WM_SYNC_COUNTER + createSyncCounter(); + long counterVal = topData()->syncCounter; + XChangeProperty( dpy, id, qt_net_wm_sync_request_counter, XA_CARDINAL, 32, PropModeReplace, + (unsigned char*) &counterVal, 1); +#endif + // when we create a toplevel widget, the frame strut should be dirty fstrut_dirty = 1; @@ -923,6 +912,10 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) if ( destroyw ) qt_XDestroyWindow( this, dpy, destroyw ); + +#if !defined(TQT_NO_IM_EXTENSIONS) + ic = 0; +#endif } @@ -981,11 +974,24 @@ void TQWidget::destroy( bool destroyWindow, bool destroySubWindows ) if ( destroyWindow ) qt_XDestroyWindow( this, x11Display(), winid ); } +#ifndef TQT_NO_XSYNC + destroySyncCounter(); +#endif setWinId( 0 ); extern void qPRCleanup( TQWidget *widget ); // from qapplication_x11.cpp if ( testWState(WState_Reparented) ) qPRCleanup(this); + + if( this == icHolderWidget() ) { + destroyInputContext(); + } else { + // release previous focus information participating with + // preedit preservation of qic + TQInputContext *qic = getInputContext(); + if ( qic ) + qic->releaseComposingWidget( this ); + } } } @@ -1022,14 +1028,18 @@ void TQWidget::reparentSys( TQWidget *tqparent, WFlags f, const TQPoint &p, bool XReparentWindow( x11Display(), old_winid, RootWindow( x11Display(), x11Screen() ), 0, 0 ); - if ( isTopLevel() ) { - // input contexts are associated with toplevel widgets, so we need - // destroy the context here. if we are reparenting back to toplevel, - // then we will have another context created, otherwise we will - // use our new toplevel's context + if ( this == icHolderWidget() ) { + // input contexts are sometimes associated with toplevel widgets, so + // we need destroy the context here. if we are reparenting back to + // toplevel, then we may have another context created, otherwise we + // will use our new ic holder's context destroyInputContext(); } +#ifndef TQT_NO_XSYNC + destroySyncCounter(); +#endif + if ( isTopLevel() || !tqparent ) // we are toplevel, or reparenting to toplevel topData()->parentWinId = 0; @@ -1131,6 +1141,64 @@ void TQWidget::reparentSys( TQWidget *tqparent, WFlags f, const TQPoint &p, bool setMouseTracking(mouse_tracking); } +// Sets the EWMH (netwm) window type. Needed as a separate function +// because create() may be too soon in some cases. +void TQWidget::x11SetWindowType( X11WindowType type ) +{ + // NET window types + long net_wintypes[7] = { 0, 0, 0, 0, 0, 0, 0 }; + int curr_wintype = 0; + if( testWFlags(WType_Desktop)) + return; + if( type == X11WindowTypeSelect ) { + if ( testWFlags(WStyle_Splash)) { + if (qt_net_supports(qt_net_wm_window_type_splash)) { + net_wintypes[curr_wintype++] = qt_net_wm_window_type_splash; + } + } else if (inherits(TQTOOLBAR_OBJECT_NAME_STRING)) { + // toolbar netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_toolbar; + } else if (testWFlags(WStyle_Customize) && testWFlags(WStyle_Tool)) { + // utility netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_utility; + } else if (testWFlags(WType_Dialog)) { + // dialog netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_dialog; + } + } else if( type == X11WindowTypeCombo ) { + // combo netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_combo; + } else if( type == X11WindowTypeDND ) { + // dnd netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_dnd; + } else if( type == X11WindowTypeDropdown ) { + // dropdown netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_dropdown_menu; + } else if( type == X11WindowTypePopup ) { + // popup netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_popup_menu; + } else if( type == X11WindowTypeMenu ) { + // menu netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_menu; + } else if( type == X11WindowTypeTooltip ) { + // tooltip netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_tooltip; + } + + // normal netwm type - default + net_wintypes[curr_wintype++] = qt_net_wm_window_type_normal; + // set _NET_WM_WINDOW_TYPE + if (curr_wintype > 0) + XChangeProperty(x11Display(), winId(), qt_net_wm_window_type, XA_ATOM, 32, PropModeReplace, + (unsigned char *) net_wintypes, curr_wintype); + else + XDeleteProperty(x11Display(), winId(), qt_net_wm_window_type); +} + +void TQWidget::x11SetWindowTransient( TQWidget* tqparent ) +{ + XSetTransientForHint( x11Display(), winId(), tqparent->winId()); +} /*! Translates the widget coordinate \a pos to global screen @@ -1182,7 +1250,8 @@ TQPoint TQWidget::mapFromGlobal( const TQPoint &pos ) const language input systems. In the X11 version of TQt, if \a text is TRUE, this method sets the - XIM "spot" point for complex language input handling. + input method focus point in the preedit (XIM "spot" point) for + complex language input handling. The font \a f is a rendering hint to the currently active input method. If \a f is 0 the widget's font is used. @@ -1192,22 +1261,15 @@ TQPoint TQWidget::mapFromGlobal( const TQPoint &pos ) const void TQWidget::setMicroFocusHint(int x, int y, int width, int height, bool text, TQFont *f ) { -#ifndef TQT_NO_XIM +#ifndef TQT_NO_IM if ( text ) { - TQWidget* tlw = tqtopLevelWidget(); - TQTLWExtra *topdata = tlw->topData(); - // trigger input context creation if it hasn't happened already createInputContext(); - TQInputContext *qic = (TQInputContext *) topdata->xic; - - if ( qt_xim && qic ) { - TQPoint p( x, y ); - TQPoint p2 = mapTo( tqtopLevelWidget(), TQPoint( 0, 0 ) ); - p = mapTo( tqtopLevelWidget(), p); - qic->setXFontSet( f ? *f : fnt ); - qic->setComposePosition(p.x(), p.y() + height); - qic->setComposeArea(p2.x(), p2.y(), this->width(), this->height()); + + TQInputContext *qic = getInputContext(); + if(qic) { + TQPoint gp = mapToGlobal( TQPoint( x, y ) ); + qic->setMicroFocus(gp.x(), gp.y(), width, height, f); } } #endif @@ -2659,13 +2721,21 @@ void TQWidget::deleteSysExtra() void TQWidget::createTLSysExtra() { +#if defined(TQT_NO_IM_EXTENSIONS) // created lazily extra->topextra->xic = 0; +#endif +#ifndef TQT_NO_XSYNC + extra->topextra->syncCounter = 0; + extra->topextra->syncRequestValue[0] = 0; + extra->topextra->syncRequestValue[1] = 0; +#endif } void TQWidget::deleteTLSysExtra() { - destroyInputContext(); + // don't destroy input context here. it will be destroyed in + // TQWidget::destroy() destroyInputContext(); } /* @@ -2706,6 +2776,51 @@ void TQWidget::checkChildrenDnd() } } + +#ifndef TQT_NO_XSYNC +// create a window's XSyncCounter +void TQWidget::createSyncCounter() +{ + if( !qt_use_xsync || !isTopLevel() || topData()->syncCounter ) + return; + XSyncValue zero; + XSyncIntToValue( &zero, 0 ); + topData()->syncCounter = XSyncCreateCounter( x11Display(), zero ); +} + +// destroy a window's XSyncCounter +void TQWidget::destroySyncCounter() +{ + if( !qt_use_xsync || !extra || !extra->topextra + || !extra->topextra->syncCounter ) + return; + XSyncDestroyCounter( x11Display(), extra->topextra->syncCounter ); + extra->topextra->syncCounter = 0; +} + +// increment a window's XSyncCounter +void TQWidget::incrementSyncCounter() +{ + if( qt_use_xsync && topData()->syncCounter && + !(topData()->syncRequestValue[0] == 0 && + topData()->syncRequestValue[1] == 0) ) { + XSyncValue val; + XSyncIntsToValue( &val, topData()->syncRequestValue[ 0 ], topData()->syncRequestValue[ 1 ] ); + XSyncSetCounter( x11Display(), topData()->syncCounter, val ); + topData()->syncRequestValue[0] = topData()->syncRequestValue[1] = 0; + } +} + +// handle _NET_WM_SYNC_REQUEST +void TQWidget::handleSyncRequest( void* ev ) +{ + XEvent* xev = (XEvent*)ev; + topData()->syncRequestValue[ 0 ] = xev->xclient.data.l[ 2 ]; + topData()->syncRequestValue[ 1 ] = xev->xclient.data.l[ 3 ]; +} +#endif // TQT_NO_XSYNC + + /*! \property TQWidget::acceptDrops \brief whether drop events are enabled for this widget @@ -2897,76 +3012,256 @@ void TQWidget::updateFrameStrut() const } +/*! + This function returns the widget holding the TQInputContext + instance for this widget. The instance is used for text input to + this widget, switching input method, etc. + + By default, this function delegates the role of returning input + context holder widget to TQApplication::locateICHolderWidget(). + + This definition enables application developer to change the + mapping of widgets to TQInputContext instance simply by overriding + TQApplication::locateICHolderWidget(). + + \sa TQApplication::locateICHolderWidget() +*/ +TQWidget *TQWidget::icHolderWidget() +{ + return tqApp->locateICHolderWidget(this); +} + + +/*! + This function returns the TQInputContext instance for this widget. + This instance is used for text input to this widget, etc. + It is simply the accessor function. +*/ +TQInputContext *TQWidget::getInputContext() +{ + TQInputContext *qic = 0; + +// #if !defined(TQT_NO_IM_EXTENSIONS) + if ( isInputMethodEnabled() ) { +#if !defined(TQT_NO_IM_EXTENSIONS) + qic = icHolderWidget()->ic; +#else +// { + // icHolderWidget is always tqtopLevelWidget + TQTLWExtra *topdata = icHolderWidget()->topData(); + qic = (TQInputContext *)topdata->xic; +#endif + } + + return qic; +} + + +/*! + This function replaces the TQInputContext instance used for text + input to this widget. The \a identifierName is the identifier name + of newly choosed input method. +*/ +void TQWidget::changeInputContext( const TQString& identifierName ) +{ + TQWidget *icWidget = icHolderWidget(); +#if !defined(TQT_NO_IM_EXTENSIONS) + TQInputContext **qicp = &icWidget->ic; +#else + TQInputContext **qicp = (TQInputContext **)&icWidget->topData()->xic; +#endif + + if( *qicp ) + delete *qicp; + // an input context that has the identifierName is generated. + TQInputContext *qic = TQInputContextFactory::create( identifierName, icWidget ); + *qicp = qic; + if ( qic ) { + TQObject::connect( qic, TQT_SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)), + tqApp, TQT_SLOT(postIMEvent(TQObject *,TQIMEvent *)) ); + TQObject::connect( qic, TQT_SIGNAL(deletionRequested()), + icWidget, TQT_SLOT(destroyInputContext()) ); + } +} + + +/*! + \internal + This is an internal function, you should never call this. + + This function is called to generate an input context + according to a configuration for default input method + + When TQT_NO_IM_EXTENSIONS is not set, input context is + generated only when isInputMethodEnabled() returns TRUE. +*/ void TQWidget::createInputContext() { - TQWidget *tlw = tqtopLevelWidget(); - TQTLWExtra *topdata = tlw->topData(); +// #if !defined(TQT_NO_IM_EXTENSIONS) + if( !isInputMethodEnabled() || TQApplication::closingDown() ) + return; +// #endif -#ifndef TQT_NO_XIM - if (qt_xim) { - if (! topdata->xic) { - TQInputContext *qic = new TQInputContext(tlw); - topdata->xic = (void *) qic; - } - } else -#endif // TQT_NO_XIM - { - // qDebug("TQWidget::createInputContext: no xim"); - topdata->xic = 0; - } + TQWidget *icWidget = icHolderWidget(); +#ifndef TQT_NO_IM +#if !defined(TQT_NO_IM_EXTENSIONS) + TQInputContext **qicp = &icWidget->ic; +#else + TQInputContext **qicp = (TQInputContext **)&icWidget->topData()->xic; +#endif + + if ( ! *qicp ) { + // an input context of the default input method is generated. + TQInputContext *qic = TQInputContextFactory::create( TQApplication::defaultInputMethod(), icWidget ); + + *qicp = qic; + if ( qic ) { + TQObject::connect( qic, TQT_SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)), + tqApp, TQT_SLOT(postIMEvent(TQObject *,TQIMEvent *)) ); + TQObject::connect( qic, TQT_SIGNAL(deletionRequested()), + icWidget, TQT_SLOT(destroyInputContext()) ); + } + } +#endif // TQT_NO_IM } +/*! + \internal + + This slot is used to destroy the input context that belonging + to the widget itself, so icHolderWidget()->ic is not fetched. + + \sa TQInputContext::deletionRequested() +*/ void TQWidget::destroyInputContext() { -#ifndef TQT_NO_XIM - TQInputContext *qic = (TQInputContext *) extra->topextra->xic; - delete qic; -#endif // TQT_NO_XIM - extra->topextra->xic = 0; +#ifndef TQT_NO_IM +#if !defined(TQT_NO_IM_EXTENSIONS) + TQInputContext **qicp = ⁣ +#else + if ( ! extra || ! extra->topextra ) + return; + + TQInputContext **qicp = (TQInputContext **)&extra->topextra->xic; +#endif + + if( *qicp ) + delete *qicp; + + *qicp = 0; +#endif // TQT_NO_IM } /*! - This function is called when the user finishes input composition, - e.g. changes focus to another widget, moves the cursor, etc. + This function is called when text widgets need to be neutral state to + execute text operations properly. See qlineedit.cpp and qtextedit.cpp as + example. + + Ordinary reset that along with changing focus to another widget, + moving the cursor, etc, is implicitly handled via + unfocusInputContext() because whether reset or not when such + situation is a responsibility of input methods. So we delegate the + responsibility to the input context via unfocusInputContext(). See + 'Preedit preservation' section of the class description of + TQInputContext for further information. + + \sa TQInputContext, unfocusInputContext(), TQInputContext::unsetFocus() */ void TQWidget::resetInputContext() { -#ifndef TQT_NO_XIM - if ((qt_xim_style & XIMPreeditCallbacks) && hasFocus()) { - TQWidget *tlw = tqtopLevelWidget(); - TQTLWExtra *topdata = tlw->topData(); +#ifndef TQT_NO_IM + // trigger input context creation if it hasn't happened already + createInputContext(); + + TQInputContext *qic = getInputContext(); + if( qic ) + qic->reset(); +#endif // TQT_NO_IM +} + + +/*! + \internal + This is an internal function, you should never call this. + + This function is called to focus associated input context. The + code intends to eliminate duplicate focus for the context even if + the context is shared between widgets + + \sa TQInputContext::setFocus() + */ +void TQWidget::focusInputContext() +{ +#ifndef TQT_NO_IM + TQWidget* tlw = tqtopLevelWidget(); + if (!tlw->isPopup() || isInputMethodEnabled()) { // trigger input context creation if it hasn't happened already createInputContext(); - if (topdata->xic) { - TQInputContext *qic = (TQInputContext *) topdata->xic; - qic->reset(); + TQInputContext *qic = getInputContext(); + if ( qic ) { + if( qic->tqfocusWidget() != this ) { + qic->setFocusWidget( this ); + qic->setFocus(); + } } } -#endif // TQT_NO_XIM +#endif // TQT_NO_IM } -void TQWidget::focusInputContext() -{ -#ifndef TQT_NO_XIM - TQWidget *tlw = tqtopLevelWidget(); - if (!tlw->isPopup() || isInputMethodEnabled()) { - TQTLWExtra *topdata = tlw->topData(); +/*! + \internal + This is an internal function, you should never call this. - // trigger input context creation if it hasn't happened already - createInputContext(); + This function is called to remove focus from associated input + context. - if (topdata->xic) { - TQInputContext *qic = (TQInputContext *) topdata->xic; - qic->setFocus(); - } + \sa TQInputContext::unsetFocus() + */ +void TQWidget::unfocusInputContext() +{ +#ifndef TQT_NO_IM + // trigger input context creation if it hasn't happened already + createInputContext(); + + TQInputContext *qic = getInputContext(); + if ( qic ) { + // may be caused reset() in some input methods + qic->unsetFocus(); + qic->setFocusWidget( 0 ); } -#endif // TQT_NO_XIM +#endif // TQT_NO_IM } + + +/*! + This function is called to send mouse event to associated input + context by derived text widgets. A derived text widget must be + calculate \a x as character offset at the mouse cursor in the + preedit. + + \sa TQInputContext::mouseHandler() + */ +void TQWidget::sendMouseEventToInputContext( int x, TQEvent::Type type, + TQt::ButtonState button, + TQt::ButtonState state ) +{ +#ifndef TQT_NO_IM + // trigger input context creation if it hasn't happened already + createInputContext(); + + TQInputContext *qic = getInputContext(); + if ( qic ) { + // may be causing reset() in some input methods + qic->mouseHandler( x, type, button, state ); + } +#endif // TQT_NO_IM +} + void TQWidget::setWindowOpacity(double) { diff --git a/tqtinterface/qt4/src/opengl/tqgl_x11.cpp b/tqtinterface/qt4/src/opengl/tqgl_x11.cpp index 56fc053..70abe7d 100644 --- a/tqtinterface/qt4/src/opengl/tqgl_x11.cpp +++ b/tqtinterface/qt4/src/opengl/tqgl_x11.cpp @@ -128,7 +128,7 @@ bool qt_resolve_gl_symbols(bool fatal) if (gl_syms_resolved) return TRUE; - TQLibrary gl("GL"); + TQLibrary gl("GL.so.1"); gl.setAutoUnload(FALSE); qt_glCallLists = (_glCallLists) gl.resolve("glCallLists"); @@ -286,7 +286,7 @@ static Colormap choose_cmap( Display *dpy, XVisualInfo *vi ) typedef Status (*_XmuLookupStandardColormap)( Display *dpy, int screen, VisualID visualid, unsigned int depth, Atom property, Bool tqreplace, Bool retain ); _XmuLookupStandardColormap qt_XmuLookupStandardColormap; - qt_XmuLookupStandardColormap = (_XmuLookupStandardColormap) TQLibrary::resolve("Xmu", "XmuLookupStandardColormap"); + qt_XmuLookupStandardColormap = (_XmuLookupStandardColormap) TQLibrary::resolve("Xmu.so.6", "XmuLookupStandardColormap"); if (!qt_XmuLookupStandardColormap) qFatal("Unable to resolve Xmu symbols - please check your Xmu library installation."); #define XmuLookupStandardColormap qt_XmuLookupStandardColormap diff --git a/tqtinterface/qt4/src/qt.pro b/tqtinterface/qt4/src/qt.pro index 9f91a6b..63e75d9 100644 --- a/tqtinterface/qt4/src/qt.pro +++ b/tqtinterface/qt4/src/qt.pro @@ -38,6 +38,7 @@ OPENGL_CPP = opengl TOOLS_CPP = tools CODECS_CPP = codecs WORKSPACE_CPP = workspace +INPUTMETHOD_CPP = inputmethod XML_CPP = xml STYLES_CPP = styles EMBEDDED_CPP = embedded @@ -55,6 +56,7 @@ win32 { TOOLS_H = $$TOOLS_CPP CODECS_H = $$CODECS_CPP WORKSPACE_H = $$WORKSPACE_CPP + #INPUTMETHOD_H = $$INPUTMETHOD_CPP XML_H = $$XML_CPP CANVAS_H = $$CANVAS_CPP STYLES_H = $$STYLES_CPP @@ -71,6 +73,7 @@ win32 { TOOLS_H = $$WIN_ALL_H CODECS_H = $$WIN_ALL_H WORKSPACE_H = $$WIN_ALL_H + #INPUTMETHOD_H = $$WIN_ALL_H XML_H = $$WIN_ALL_H CANVAS_H = $$WIN_ALL_H STYLES_H = $$WIN_ALL_H @@ -99,6 +102,7 @@ unix { TOOLS_H = $$TOOLS_CPP CODECS_H = $$CODECS_CPP WORKSPACE_H = $$WORKSPACE_CPP + INPUTMETHOD_H = $$INPUTMETHOD_CPP XML_H = $$XML_CPP STYLES_H = $$STYLES_CPP !embedded:!mac:CONFIG += x11 x11inc @@ -114,7 +118,7 @@ embedded { EMBEDDED_H = $$EMBEDDED_CPP } -DEPENDPATH += ;$$NETWORK_H;$$KERNEL_H;$$WIDGETS_H;$$SQL_H;$$TABLE_H;$$DIALOGS_H; +DEPENDPATH += ;$$NETWORK_H;$$KERNEL_H;$$WIDGETS_H;$$INPUTMETHOD_H;$$SQL_H;$$TABLE_H;$$DIALOGS_H; DEPENDPATH += $$ICONVIEW_H;$$OPENGL_H;$$TOOLS_H;$$CODECS_H;$$WORKSPACE_H;$$XML_H; DEPENDPATH += $$CANVAS_H;$$STYLES_H embedded:DEPENDPATH += ;$$EMBEDDED_H @@ -149,6 +153,7 @@ include($$WIDGETS_CPP/qt_widgets.pri) include($$DIALOGS_CPP/qt_dialogs.pri) include($$ICONVIEW_CPP/qt_iconview.pri) include($$WORKSPACE_CPP/qt_workspace.pri) +include($$INPUTMETHOD_CPP/qt_inputmethod.pri) include($$NETWORK_CPP/qt_network.pri) include($$CANVAS_CPP/qt_canvas.pri) include($$TABLE_CPP/qt_table.pri) @@ -176,6 +181,16 @@ unix { QMAKE_PKGCONFIG_INCDIR = $$headers.path } +unix { + # Debian - compile __debian_export_symbols.cpp with -fno-inline + debian_no_inline.output = .obj/${TQMAKE_FILE_BASE}.o + debian_no_inline.commands = $(CXX) -c $(CXXFLAGS) $(INCPATH) -fno-inline ${TQMAKE_FILE_NAME} -o ${TQMAKE_FILE_OUT} + debian_no_inline.input = DEBIAN_NO_INLINE + TQMAKE_EXTRA_UNIX_COMPILERS += debian_no_inline + + DEBIAN_NO_INLINE = __debian_export_symbols.cpp +} + wince-* { CONFIG -= incremental message( ...removing plugin stuff... (not permanent) ) diff --git a/tqtinterface/qt4/src/sql/drivers/ibase/tqsql_ibase.cpp b/tqtinterface/qt4/src/sql/drivers/ibase/tqsql_ibase.cpp index 955ecc4..ddc103a 100644 --- a/tqtinterface/qt4/src/sql/drivers/ibase/tqsql_ibase.cpp +++ b/tqtinterface/qt4/src/sql/drivers/ibase/tqsql_ibase.cpp @@ -767,7 +767,7 @@ TQIBaseDriver::TQIBaseDriver(void *connection, TQObject *tqparent, const char *n : TQSqlDriver(tqparent, name ? name : TQIBASE_DRIVER_NAME) { d = new TQIBaseDriverPrivate(this); - d->ibase = (isc_db_handle)connection; + d->ibase = (isc_db_handle)(long int)connection; setOpen(TRUE); setOpenError(FALSE); } diff --git a/tqtinterface/qt4/src/sql/qt_sql.pri b/tqtinterface/qt4/src/sql/qt_sql.pri index 198edee..29845f8 100644 --- a/tqtinterface/qt4/src/sql/qt_sql.pri +++ b/tqtinterface/qt4/src/sql/qt_sql.pri @@ -188,7 +188,7 @@ sql { SOURCES += $$SQL_CPP/drivers/ibase/tqsql_ibase.cpp DEFINES += TQT_SQL_IBASE unix { - LIBS *= -lgds + LIBS *= -lfbclient } win32 { !win32-borland:LIBS *= gds32_ms.lib diff --git a/tqtinterface/qt4/src/tools/tqdir_unix.cpp b/tqtinterface/qt4/src/tools/tqdir_unix.cpp index 5d69993..f96808b 100644 --- a/tqtinterface/qt4/src/tools/tqdir_unix.cpp +++ b/tqtinterface/qt4/src/tools/tqdir_unix.cpp @@ -74,6 +74,20 @@ TQString TQDir::homeDirPath() TQString TQDir::canonicalPath() const { TQString r; +#if defined(__GLIBC__) && !defined(PATH_MAX) + char *cur = ::get_current_dir_name(); + if ( cur ) { + char *tmp = canonicalize_file_name( TQFile::encodeName( dPath ).data() ); + if ( tmp ) { + r = TQFile::decodeName( tmp ); + free( tmp ); + } + slashify( r ); + // always make sure we go back to the current dir + ::chdir( cur ); + free( cur ); + } +#else char cur[PATH_MAX+1]; if ( ::getcwd( cur, PATH_MAX ) ) { char tmp[PATH_MAX+1]; @@ -86,6 +100,7 @@ TQString TQDir::canonicalPath() const // always make sure we go back to the current dir ::chdir( cur ); } +#endif /* __GLIBC__ && !PATH_MAX */ return r; } @@ -147,9 +162,17 @@ TQString TQDir::currentDirPath() struct stat st; if ( ::stat( ".", &st ) == 0 ) { +#if defined(__GLIBC__) && !defined(PATH_MAX) + char *currentName = ::get_current_dir_name(); + if ( currentName ) { + result = TQFile::decodeName(currentName); + free( currentName ); + } +#else char currentName[PATH_MAX+1]; if ( ::getcwd( currentName, PATH_MAX ) ) result = TQFile::decodeName(currentName); +#endif /* __GLIBC__ && !PATH_MAX */ #if defined(TQT_DEBUG) if ( result.isNull() ) qWarning( "TQDir::currentDirPath: getcwd() failed" ); diff --git a/tqtinterface/qt4/src/tools/tqfeatures.h b/tqtinterface/qt4/src/tools/tqfeatures.h index f06fe39..dfafe61 100644 --- a/tqtinterface/qt4/src/tools/tqfeatures.h +++ b/tqtinterface/qt4/src/tools/tqfeatures.h @@ -982,3 +982,13 @@ #define TQT_NO_WORKSPACE #endif +// Input method +#if !defined(TQT_NO_IM) && (defined(TQT_NO_STRINGLIST)) +#define TQT_NO_IM +#endif + +// Input method extensions +#if !defined(TQT_NO_IM_EXTENSIONS) && (defined(TQT_NO_IM) || defined(TQT_NO_STRINGLIST)) +#define TQT_NO_IM_EXTENSIONS +#endif + diff --git a/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp b/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp index 921b9f9..3be62bf 100644 --- a/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp +++ b/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp @@ -48,6 +48,9 @@ #if !defined(TQWS) && defined(TQ_OS_MAC) # include #endif +#if defined(Q_OS_HURD) +# include +#endif void TQFileInfo::slashify( TQString& ) { @@ -127,16 +130,43 @@ bool TQFileInfo::isSymLink() const TQString TQFileInfo::readLink() const { + if ( !isSymLink() ) + return TQString(); #if defined(TQ_OS_UNIX) && !defined(TQ_OS_OS2EMX) +#if defined(__GLIBC__) && !defined(PATH_MAX) + int size = 256; + char *s = NULL, *s2; + + while (1) + { + s2 = (char *) realloc (s, size); + if (s2 == NULL) { + free( s ); + return TQString(); + } + s = s2; + int len = readlink ( TQFile::encodeName(fn).data(), s, size ); + if ( len < 0 ) { + free( s ); + return TQString(); + } + if ( len < size ) { + s[len] = '\0'; + TQString str = TQFile::decodeName(s); + free(s); + return str; + } + size *= 2; + } +#else char s[PATH_MAX+1]; - if ( !isSymLink() ) - return TQString(); int len = readlink( TQFile::encodeName(fn).data(), s, PATH_MAX ); if ( len >= 0 ) { s[len] = '\0'; return TQFile::decodeName(s); } -#endif +#endif /* __GLIBC__ && !PATH_MAX */ +#endif /* Q_OS_UNIX && !Q_OS_OS2EMX */ #if !defined(TQWS) && defined(TQ_OS_MAC) { FSRef fref; diff --git a/tqtinterface/qt4/src/tools/tqglobal.h b/tqtinterface/qt4/src/tools/tqglobal.h index 3fe0fb0..693da3f 100644 --- a/tqtinterface/qt4/src/tools/tqglobal.h +++ b/tqtinterface/qt4/src/tools/tqglobal.h @@ -115,7 +115,9 @@ # define TQ_OS_ULTRIX #elif defined(sinix) # define TQ_OS_RELIANT -#elif defined(__linux__) || defined(__linux) +#elif defined(__GNU__) +# define TQ_OS_HURD +#elif defined(__linux__) || defined(__linux) || defined(__GNU__) || defined(__GLIBC__) # define TQ_OS_LINUX #elif defined(__FreeBSD__) || defined(__DragonFly__) # define TQ_OS_FREEBSD @@ -137,8 +139,6 @@ # define TQ_OS_AIX #elif defined(__Lynx__) # define TQ_OS_LYNX -#elif defined(__GNU_HURD__) -# define TQ_OS_HURD #elif defined(__DGUX__) # define TQ_OS_DGUX #elif defined(__TQNXNTO__) @@ -318,9 +318,9 @@ TQString bloat. However, gcc 3.4 doesn't allow us to create references to members of a packed struct. (Pointers are OK, because then you supposedly know what you are doing.) */ -# if (defined(__arm__) || defined(__ARMEL__)) && !defined(TQT_TQMOC_CPP) +# if (defined(__arm__) || defined(__ARMEL__)) && !defined(__ARM_EABI__) && !defined(TQT_TQMOC_CPP) # define TQ_PACKED __attribute__ ((packed)) -# if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 +# if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3 # define TQ_NO_PACKED_REFERENCE # endif # endif diff --git a/tqtinterface/qt4/src/tools/tqlibrary.cpp b/tqtinterface/qt4/src/tools/tqlibrary.cpp index 140e017..cf34295 100644 --- a/tqtinterface/qt4/src/tools/tqlibrary.cpp +++ b/tqtinterface/qt4/src/tools/tqlibrary.cpp @@ -429,6 +429,7 @@ TQString TQLibrary::library() const } else { tmpfilename = TQString( "lib%1" ).arg( filename ); } + if ( !filename.tqcontains(".so") ) tmpfilename += filter; if(TQFile::exists(tmpfilename) || it == filters.end()) { filename = tmpfilename; diff --git a/tqtinterface/qt4/src/tools/tqlocale.cpp b/tqtinterface/qt4/src/tools/tqlocale.cpp index 26a3230..69c8c39 100644 --- a/tqtinterface/qt4/src/tools/tqlocale.cpp +++ b/tqtinterface/qt4/src/tools/tqlocale.cpp @@ -125,13 +125,24 @@ static inline double nan() #endif // We can't rely on -NAN, since all operations on a NAN should return a NAN. +static double be_neg_nan; +static double le_neg_nan; static const unsigned char be_neg_nan_bytes[] = { 0xff, 0xf8, 0, 0, 0, 0, 0, 0 }; static const unsigned char le_neg_nan_bytes[] = { 0, 0, 0, 0, 0, 0, 0xf8, 0xff }; +static bool neg_nan_init = false; + static inline double negNan() { + if (!neg_nan_init) + { + memcpy(&be_neg_nan,be_neg_nan_bytes,sizeof(be_neg_nan_bytes)); + memcpy(&le_neg_nan,le_neg_nan_bytes,sizeof(le_neg_nan_bytes)); + neg_nan_init = true; + } return (ByteOrder == BigEndian ? - *((const double *) be_neg_nan_bytes) : - *((const double *) le_neg_nan_bytes)); + be_neg_nan : + le_neg_nan); + } // Sizes as defined by the ISO C99 standard - fallback diff --git a/tqtinterface/qt4/src/tools/tqmap.h b/tqtinterface/qt4/src/tools/tqmap.h index 029f4a3..fe36e97 100644 --- a/tqtinterface/qt4/src/tools/tqmap.h +++ b/tqtinterface/qt4/src/tools/tqmap.h @@ -60,6 +60,7 @@ #ifndef TQT_NO_STL #include #include +#include #endif //#define TQT_CHECK_MAP_RANGE diff --git a/tqtinterface/qt4/src/tools/tqstring.h b/tqtinterface/qt4/src/tools/tqstring.h index b4db802..71bc563 100644 --- a/tqtinterface/qt4/src/tools/tqstring.h +++ b/tqtinterface/qt4/src/tools/tqstring.h @@ -754,7 +754,7 @@ public: char latin1() const { return ucs > 0xff ? 0 : (char) ucs; } ushort tqunicode() const { return ucs; } #ifdef TQ_NO_PACKED_REFERENCE - ushort &tqunicode() { return *(&ucs); } + ushort &tqunicode() { return *((ushort*)&ucs); } #else ushort &tqunicode() { return ucs; } #endif diff --git a/tqtinterface/qt4/src/tools/tqvaluelist.h b/tqtinterface/qt4/src/tools/tqvaluelist.h index 67c2574..799473a 100644 --- a/tqtinterface/qt4/src/tools/tqvaluelist.h +++ b/tqtinterface/qt4/src/tools/tqvaluelist.h @@ -50,6 +50,7 @@ #ifndef TQT_NO_STL #include #include +#include #endif //#define TQT_CHECK_VALUELIST_RANGE diff --git a/tqtinterface/qt4/src/widgets/tqbutton.h b/tqtinterface/qt4/src/widgets/tqbutton.h index f75de1a..42088a7 100644 --- a/tqtinterface/qt4/src/widgets/tqbutton.h +++ b/tqtinterface/qt4/src/widgets/tqbutton.h @@ -184,7 +184,7 @@ inline const TQPixmap *TQButton::pixmap() const inline bool TQButton::isToggleButton() const { - return toggleTyp != SingleShot; + return ToggleType(toggleTyp) != SingleShot; } inline bool TQButton::isDown() const @@ -194,7 +194,7 @@ inline bool TQButton::isDown() const inline bool TQButton::isOn() const { - return stat != Off; + return ToggleState(stat) != Off; } #ifndef TQT_NO_COMPAT diff --git a/tqtinterface/qt4/src/widgets/tqcombobox.cpp b/tqtinterface/qt4/src/widgets/tqcombobox.cpp index d152da2..6305993 100644 --- a/tqtinterface/qt4/src/widgets/tqcombobox.cpp +++ b/tqtinterface/qt4/src/widgets/tqcombobox.cpp @@ -392,12 +392,8 @@ public: inline TQListBox * listBox() { return lBox; } inline TQComboBoxPopup * popup() { return pop; } void updateLinedGeometry(); - - void setListBox( TQListBox *l ) { lBox = l ; usingLBox = TRUE; - l->setMouseTracking( TRUE );} - - void setPopupMenu( TQComboBoxPopup * pm, bool isPopup=TRUE ) - { pop = pm; if(isPopup) usingLBox = FALSE; } + void setListBox( TQListBox *l ); + void setPopupMenu( TQComboBoxPopup * pm, bool isPopup=TRUE ); int current; int maxCount; @@ -443,6 +439,30 @@ void TQComboBoxData::updateLinedGeometry() ed->setGeometry( r ); } +void TQComboBoxData::setListBox( TQListBox *l ) +{ + lBox = l; + usingLBox = TRUE; + l->setMouseTracking( TRUE ); +#ifdef TQ_WS_X11 + l->x11SetWindowType( TQWidget::X11WindowTypeCombo ); + l->x11SetWindowTransient( combo->tqtopLevelWidget()); +#endif +} + +void TQComboBoxData::setPopupMenu( TQComboBoxPopup * pm, bool isPopup ) +{ + pop = pm; + if(isPopup) + usingLBox = FALSE; +#ifdef TQ_WS_X11 + if( pm ) { + pm->x11SetWindowType( TQWidget::X11WindowTypeCombo ); + pm->x11SetWindowTransient( combo->tqtopLevelWidget()); + } +#endif +} + static inline bool checkInsertIndex( const char *method, const char * name, int count, int *index) { diff --git a/tqtinterface/qt4/src/widgets/tqlineedit.cpp b/tqtinterface/qt4/src/widgets/tqlineedit.cpp index 2d41152..10c1be8 100644 --- a/tqtinterface/qt4/src/widgets/tqlineedit.cpp +++ b/tqtinterface/qt4/src/widgets/tqlineedit.cpp @@ -40,6 +40,12 @@ #include "tqlineedit.h" #ifndef TQT_NO_LINEEDIT + +// Keep this position to avoid patch rejection +#ifndef TQT_NO_IM +#include "tqinputcontext.h" +#endif + #include "tqpainter.h" #include "tqdrawutil.h" #include "tqfontmetrics.h" @@ -248,12 +254,17 @@ struct TQLineEditPrivate : public TQt // input methods int imstart, imend, imselstart, imselend; + bool composeMode() const { return preeditLength(); } + bool hasIMSelection() const { return imSelectionLength(); } + int preeditLength() const { return ( imend - imstart ); } + int imSelectionLength() const { return ( imselend - imselstart ); } // complex text tqlayout TQTextLayout textLayout; void updateTextLayout(); void moveCursor( int pos, bool mark = FALSE ); void setText( const TQString& txt ); + int xToPosInternal( int x, TQTextItem::CursorPosition ) const; int xToPos( int x, TQTextItem::CursorPosition = TQTextItem::BetweenCharacters ) const; inline int visualAlignment() const { return tqalignment ? tqalignment : int( isRightToLeft() ? TQt::AlignRight : TQt::AlignLeft ); } TQRect cursorRect() const; @@ -591,6 +602,7 @@ void TQLineEdit::setEchoMode( EchoMode mode ) return; d->echoMode = mode; d->updateTextLayout(); + setInputMethodEnabled( mode == Normal ); update(); } @@ -1422,6 +1434,8 @@ bool TQLineEdit::event( TQEvent * e ) */ void TQLineEdit::mousePressEvent( TQMouseEvent* e ) { + if ( sendMouseEventToInputContext( e ) ) + return; if ( e->button() == Qt::RightButton ) return; if ( d->tripleClickTimer && ( e->pos() - d->tripleClick ).manhattanLength() < @@ -1451,7 +1465,8 @@ void TQLineEdit::mousePressEvent( TQMouseEvent* e ) */ void TQLineEdit::mouseMoveEvent( TQMouseEvent * e ) { - + if ( sendMouseEventToInputContext( e ) ) + return; #ifndef TQT_NO_CURSOR if ( ( e->state() & Qt::MouseButtonMask ) == 0 ) { if ( !d->readOnly && d->dragEnabled @@ -1480,6 +1495,8 @@ void TQLineEdit::mouseMoveEvent( TQMouseEvent * e ) */ void TQLineEdit::mouseReleaseEvent( TQMouseEvent* e ) { + if ( sendMouseEventToInputContext( e ) ) + return; #ifndef TQT_NO_DRAGANDDROP if ( e->button() == Qt::LeftButton ) { if ( d->dndTimer ) { @@ -1506,6 +1523,8 @@ void TQLineEdit::mouseReleaseEvent( TQMouseEvent* e ) */ void TQLineEdit::mouseDoubleClickEvent( TQMouseEvent* e ) { + if ( sendMouseEventToInputContext( e ) ) + return; if ( e->button() == Qt::LeftButton ) { deselect(); d->cursor = d->xToPos( e->pos().x() ); @@ -1775,6 +1794,33 @@ void TQLineEdit::keyPressEvent( TQKeyEvent * e ) e->ignore(); } + +/*! + This function is not intended as polymorphic usage. Just a shared code + fragment that calls TQWidget::sendMouseEventToInputContext() easily for this + class. + */ +bool TQLineEdit::sendMouseEventToInputContext( TQMouseEvent *e ) +{ +#ifndef TQT_NO_IM + if ( d->composeMode() ) { + int cursor = d->xToPosInternal( e->pos().x(), TQTextItem::OnCharacters ); + int mousePos = cursor - d->imstart; + if ( mousePos >= 0 && mousePos < d->preeditLength() ) { + TQWidget::sendMouseEventToInputContext( mousePos, e->type(), + e->button(), e->state() ); + } else if ( e->type() != TQEvent::MouseMove ) { + // send button events on out of preedit + TQWidget::sendMouseEventToInputContext( -1, e->type(), + e->button(), e->state() ); + } + return TRUE; + } +#endif + return FALSE; +} + + /*! \reimp */ void TQLineEdit::imStartEvent( TQIMEvent *e ) @@ -1841,6 +1887,8 @@ void TQLineEdit::focusInEvent( TQFocusEvent* tqfe ) } if( !hasSelectedText() || tqstyle().tqstyleHint( TQStyle::SH_BlinkCursorWhenTextSelected ) ) d->setCursorVisible( TRUE ); + if ( d->hasIMSelection() ) + d->cursor = d->imselstart; d->updateMicroFocusHint(); } @@ -1934,6 +1982,14 @@ void TQLineEdit::drawContents( TQPainter *p ) } else if (d->hscroll < 0) { d->hscroll = 0; } + // This updateMicroFocusHint() is corresponding to update() at + // IMCompose event. Although the function is invoked from various + // other points, some situations such as "candidate selection on + // AlignHCenter'ed text" need this invocation because + // updateMicroFocusHint() requires updated contentsRect(), and + // there are no other chances in such situation that invoke the + // function. + d->updateMicroFocusHint(); // the y offset is there to keep the baseline constant in case we have script changes in the text. TQPoint topLeft = lineRect.topLeft() - TQPoint(d->hscroll, d->ascent-fm.ascent()); @@ -1974,7 +2030,7 @@ void TQLineEdit::drawContents( TQPainter *p ) } // input method edit area - if ( d->imstart < d->imend && (last >= d->imstart && first < d->imend ) ) { + if ( d->composeMode() && (last >= d->imstart && first < d->imend ) ) { TQRect highlight = TQRect( TQPoint( tix + ti.cursorToX( TQMAX( d->imstart - first, 0 ) ), lineRect.top() ), TQPoint( tix + ti.cursorToX( TQMIN( d->imend - first, last - first + 1 ) )-1, lineRect.bottom() ) ).normalize(); p->save(); @@ -1987,11 +2043,16 @@ void TQLineEdit::drawContents( TQPainter *p ) imCol.setHsv( h1, s1, ( v1 + v2 ) / 2 ); p->fillRect( highlight, imCol ); p->tqdrawTextItem( topLeft, ti, textflags ); + // draw preedit's underline + if (d->imend - d->imstart > 0) { + p->setPen( cg.text() ); + p->drawLine( highlight.bottomLeft(), highlight.bottomRight() ); + } p->restore(); } // input method selection - if ( d->imselstart < d->imselend && (last >= d->imselstart && first < d->imselend ) ) { + if ( d->hasIMSelection() && (last >= d->imselstart && first < d->imselend ) ) { TQRect highlight = TQRect( TQPoint( tix + ti.cursorToX( TQMAX( d->imselstart - first, 0 ) ), lineRect.top() ), TQPoint( tix + ti.cursorToX( TQMIN( d->imselend - first, last - first + 1 ) )-1, lineRect.bottom() ) ).normalize(); p->save(); @@ -2019,7 +2080,11 @@ void TQLineEdit::drawContents( TQPainter *p ) } // draw cursor - if ( d->cursorVisible && !supressCursor ) { + // + // Asian users regard IM selection text as cursor on candidate + // selection phase of input method, so ordinary cursor should be + // invisible if IM selection text exists. + if ( d->cursorVisible && !supressCursor && !d->hasIMSelection() ) { TQPoint from( topLeft.x() + cix, lineRect.top() ); TQPoint to = from + TQPoint( 0, lineRect.height() ); p->drawLine( from, to ); @@ -2134,6 +2199,10 @@ enum { IdUndo, IdRedo, IdSep1, IdCut, IdCopy, IdPaste, IdClear, IdSep2, IdSelect void TQLineEdit::contextMenuEvent( TQContextMenuEvent * e ) { #ifndef TQT_NO_POPUPMENU +#ifndef TQT_NO_IM + if ( d->composeMode() ) + return; +#endif d->separate(); TQPopupMenu *menu = createPopupMenu(); if (!menu) @@ -2187,6 +2256,13 @@ TQPopupMenu *TQLineEdit::createPopupMenu() + ACCEL_KEY( A ) #endif ); + +#ifndef TQT_NO_IM + TQInputContext *qic = getInputContext(); + if ( qic ) + qic->addMenusTo( popup ); +#endif + popup->setItemEnabled( id - IdUndo, d->isUndoAvailable() ); popup->setItemEnabled( id - IdRedo, d->isRedoAvailable() ); #ifndef TQT_NO_CLIPBOARD @@ -2320,7 +2396,7 @@ void TQLineEditPrivate::updateTextLayout() textLayout.endLine(0, 0, TQt::AlignLeft|TQt::SingleLine, &ascent); } -int TQLineEditPrivate::xToPos( int x, TQTextItem::CursorPosition betweenOrOn ) const +int TQLineEditPrivate::xToPosInternal( int x, TQTextItem::CursorPosition betweenOrOn ) const { x-= q->contentsRect().x() - hscroll + innerMargin; for ( int i = 0; i < textLayout.numItems(); ++i ) { @@ -2329,7 +2405,13 @@ int TQLineEditPrivate::xToPos( int x, TQTextItem::CursorPosition betweenOrOn ) c if ( x >= tir.left() && x <= tir.right() ) return ti.xToCursor( x - tir.x(), betweenOrOn ) + ti.from(); } - return x < 0 ? 0 : text.length(); + return x < 0 ? -1 : text.length(); +} + +int TQLineEditPrivate::xToPos( int x, TQTextItem::CursorPosition betweenOrOn ) const +{ + int pos = xToPosInternal( x, betweenOrOn ); + return ( pos < 0 ) ? 0 : pos; } @@ -2350,9 +2432,19 @@ TQRect TQLineEditPrivate::cursorRect() const void TQLineEditPrivate::updateMicroFocusHint() { + // To reduce redundant microfocus update notification, we remember + // the old rect and update the microfocus if actual update is + // required. The rect o is intentionally static because some + // notifyee requires the microfocus information as global update + // rather than per notifyee update to place shared widget around + // microfocus. + static TQRect o; if ( q->hasFocus() ) { - TQRect r = cursorRect(); - q->setMicroFocusHint( r.x(), r.y(), r.width(), r.height() ); + TQRect r = cursorRect(); + if ( o != r ) { + o = r; + q->setMicroFocusHint( r.x(), r.y(), r.width(), r.height() ); + } } } diff --git a/tqtinterface/qt4/src/widgets/tqlineedit.h b/tqtinterface/qt4/src/widgets/tqlineedit.h index a8c3242..0b7fd52 100644 --- a/tqtinterface/qt4/src/widgets/tqlineedit.h +++ b/tqtinterface/qt4/src/widgets/tqlineedit.h @@ -202,6 +202,7 @@ protected: void dropEvent( TQDropEvent * ); #endif void contextMenuEvent( TQContextMenuEvent * ); + bool sendMouseEventToInputContext( TQMouseEvent *e ); virtual TQPopupMenu *createPopupMenu(); void windowActivationChange( bool ); #ifndef TQT_NO_COMPAT diff --git a/tqtinterface/qt4/src/widgets/tqlistview.cpp b/tqtinterface/qt4/src/widgets/tqlistview.cpp index bd706e9..46060c8 100644 --- a/tqtinterface/qt4/src/widgets/tqlistview.cpp +++ b/tqtinterface/qt4/src/widgets/tqlistview.cpp @@ -4569,6 +4569,7 @@ void TQListView::contentsMouseReleaseEventEx( TQMouseEvent * e ) } emitClicked = emitClicked && d->pressedItem == i; d->pressedItem = 0; + d->highlighted = 0; if ( emitClicked ) { if ( !i || ( i && i->isEnabled() ) ) { @@ -7597,21 +7598,21 @@ TQListViewItemIterator::~TQListViewItemIterator() TQListViewItemIterator &TQListViewItemIterator::operator++() { - if ( !curr ) - return *this; + do { + if ( !curr ) + return *this; - TQListViewItem *item = curr->firstChild(); - if ( !item ) { - while ( (item = curr->nextSibling()) == 0 ) { - curr = curr->tqparent(); - if ( curr == 0 ) - break; + TQListViewItem *item = curr->firstChild(); + if ( !item ) { + while ( (item = curr->nextSibling()) == 0 ) { + curr = curr->tqparent(); + if ( curr == 0 ) + break; + } } - } - curr = item; - // if the next one doesn't match the flags we try one more ahead - if ( curr && !matchesFlags( curr ) ) - ++( *this ); + curr = item; + // if the next one doesn't match the flags we try one more ahead + } while ( curr && !matchesFlags( curr ) ); return *this; } diff --git a/tqtinterface/qt4/src/widgets/tqmenubar.cpp b/tqtinterface/qt4/src/widgets/tqmenubar.cpp index aadb3ee..c8fed6d 100644 --- a/tqtinterface/qt4/src/widgets/tqmenubar.cpp +++ b/tqtinterface/qt4/src/widgets/tqmenubar.cpp @@ -231,6 +231,10 @@ static const int motifItemFrame = 2; // menu item frame width static const int motifItemHMargin = 5; // menu item hor text margin static const int motifItemVMargin = 4; // menu item ver text margin +// The others are 0 +static const int gtkItemHMargin = 8; +static const int gtkItemVMargin = 8; + /* +----------------------------- @@ -295,7 +299,14 @@ TQMenuBar::TQMenuBar( TQWidget *tqparent, const char *name ) setFrameStyle( TQFrame::MenuBarPanel | TQFrame::Raised ); TQFontMetrics fm = fontMetrics(); - int h = 2*motifBarVMargin + fm.height() + motifItemVMargin + 2*frameWidth() + 2*motifItemFrame; + + int h; + int gs = style().tqstyleHint(TQStyle::SH_GUIStyle); + if (gs == GtkStyle) { + h = fm.height() + gtkItemVMargin; + } else { + h = 2*motifBarVMargin + fm.height() + motifItemVMargin + 2*frameWidth() + 2*motifItemFrame; + } setGeometry( 0, 0, width(), h ); @@ -949,12 +960,19 @@ int TQMenuBar::calculateRects( int max_width ) h = TQMAX( mi->pixmap()->height() + 4, TQApplication::globalStrut().height() ); } else if ( !mi->text().isNull() ) { // text item TQString s = mi->text(); - w = fm.boundingRect( s ).width() - + 2*motifItemHMargin; + if ( gs == GtkStyle ) { + w = fm.boundingRect( s ).width() + 2*gtkItemHMargin; + } else { + w = fm.boundingRect( s ).width() + 2*motifItemHMargin; + } w -= s.tqcontains('&')*fm.width('&'); w += s.tqcontains("&&")*fm.width('&'); w = TQMAX( w, TQApplication::globalStrut().width() ); - h = TQMAX( fm.height() + motifItemVMargin, TQApplication::globalStrut().height() ); + if (gs == GtkStyle ) { + h = TQMAX( fm.height() + gtkItemVMargin, TQApplication::globalStrut().height() ); + } else { + h = TQMAX( fm.height() + motifItemVMargin, TQApplication::globalStrut().height() ); + } } else if ( mi->isSeparator() ) { // separator item if ( tqstyle().tqstyleHint(TQStyle::SH_GUIStyle) == TQt::MotifStyle ) separator = i; //### only motif? diff --git a/tqtinterface/qt4/src/widgets/tqpopupmenu.cpp b/tqtinterface/qt4/src/widgets/tqpopupmenu.cpp index bbfdb60..993c065 100644 --- a/tqtinterface/qt4/src/widgets/tqpopupmenu.cpp +++ b/tqtinterface/qt4/src/widgets/tqpopupmenu.cpp @@ -224,6 +224,8 @@ static TQMenuItem* whatsThisItem = 0; Pop-Up\endlink */ +static const int gtkArrowHMargin = 0; // arrow horizontal margin +static const int gtkArrowVMargin = 0; // arrow vertical margin /*! \fn void TQPopupMenu::aboutToShow() @@ -272,6 +274,8 @@ public: } scroll; TQSize calcSize; TQRegion mouseMoveBuffer; + uint hasmouse : 1; + TQPoint ignoremousepos; }; static TQPopupMenu* active_popup_menu = 0; @@ -291,6 +295,7 @@ TQPopupMenu::TQPopupMenu( TQWidget *tqparent, const char *name ) d->scroll.scrollableSize = d->scroll.topScrollableIndex = 0; d->scroll.scrollable = TQPopupMenuPrivate::Scroll::ScrollNone; d->scroll.scrolltimer = 0; + d->hasmouse = 0; isPopupMenu = TRUE; #ifndef TQT_NO_ACCEL autoaccel = 0; @@ -314,6 +319,9 @@ TQPopupMenu::TQPopupMenu( TQWidget *tqparent, const char *name ) connectModalRecursionSafety = 0; setFocusPolicy( Qt::StrongFocus ); +#ifdef TQ_WS_X11 + x11SetWindowType( X11WindowTypePopup ); +#endif } /*! @@ -473,6 +481,15 @@ void TQPopupMenu::frameChanged() menuContentsChanged(); } +TQRect TQPopupMenu::screenRect( const TQPoint& pos ) +{ + int screen_num = TQApplication::desktop()->screenNumber( pos ); +#ifdef TQ_WS_MAC + return TQApplication::desktop()->availableGeometry( screen_num ); +#else + return TQApplication::desktop()->screenGeometry( screen_num ); +#endif +} /*! Displays the popup menu so that the item number \a indexAtPoint will be at the specified \e global position \a pos. To translate a @@ -517,6 +534,15 @@ void TQPopupMenu::popup( const TQPoint &pos, int indexAtPoint ) // point. #endif + TQRect screen = screenRect( tqgeometry().center()); + TQRect screen2 = screenRect( TQApplication::reverseLayout() + ? pos+TQPoint(width(),0) : pos ); + // if the widget is not in the screen given by the position, move it + // there, so that updateSize() uses the right size of the screen + if( screen != screen2 ) { + screen = screen2; + move( screen.x(), screen.y()); + } if(d->scroll.scrollable) { d->scroll.scrollable = TQPopupMenuPrivate::Scroll::ScrollNone; d->scroll.topScrollableIndex = d->scroll.scrollableSize = 0; @@ -536,18 +562,6 @@ void TQPopupMenu::popup( const TQPoint &pos, int indexAtPoint ) updateSize(TRUE); } - int screen_num; - if (TQApplication::desktop()->isVirtualDesktop()) - screen_num = - TQApplication::desktop()->screenNumber( TQApplication::reverseLayout() ? - pos+TQPoint(width(),0) : pos ); - else - screen_num = TQApplication::desktop()->screenNumber( this ); -#ifdef TQ_WS_MAC - TQRect screen = TQApplication::desktop()->availableGeometry( screen_num ); -#else - TQRect screen = TQApplication::desktop()->screenGeometry( screen_num ); -#endif int sw = screen.width(); // screen width int sh = screen.height(); // screen height int sx = screen.x(); // screen pos @@ -571,6 +585,29 @@ void TQPopupMenu::popup( const TQPoint &pos, int indexAtPoint ) if ( y < sy ) y = sy; } +#ifdef TQ_WS_X11 +#ifndef TQT_NO_MENUBAR + TQMenuData *top = this; // find top level + while ( top->parentMenu ) + top = top->parentMenu; + if( top->isMenuBar ) + x11SetWindowType( X11WindowTypeDropdown ); + if( parentMenu && parentMenu->isMenuBar ) + x11SetWindowTransient( static_cast< TQMenuBar* >( parentMenu )->tqtopLevelWidget()); +#endif + if( parentMenu && !parentMenu->isMenuBar ) + x11SetWindowTransient( static_cast< TQPopupMenu* >( parentMenu )); + if( !parentMenu ) { + // hackish ... try to find the main window related to this popup + TQWidget* tqparent = parentWidget() ? parentWidget()->tqtopLevelWidget() : NULL; + if( tqparent == NULL ) + tqparent = TQApplication::widgetAt( pos ); + if( tqparent == NULL ) + tqparent = tqApp->activeWindow(); + if( tqparent != NULL ) + x11SetWindowTransient( tqparent ); + } +#endif if ( x+w > sx+sw ) // the complete widget must x = sx+sw - w; // be visible @@ -1075,7 +1112,7 @@ TQSize TQPopupMenu::updateSize(bool force_update, bool do_resize) mi->iconSet()->pixmap( TQIconSet::Small, TQIconSet::Normal ).width() + 4 ); } - int dh = TQApplication::desktop()->height(); + int dh = screenRect( tqgeometry().center()).height(); ncols = 1; for ( TQMenuItemListIt it2( *mitems ); it2.current(); ++it2 ) { @@ -1389,6 +1426,7 @@ void TQPopupMenu::show() popupActive = -1; if(tqstyle().tqstyleHint(TQStyle::SH_PopupMenu_SubMenuPopupDelay, this)) d->mouseMoveBuffer = TQRegion(); + d->ignoremousepos = TQCursor::pos(); } /*! @@ -1414,6 +1452,13 @@ void TQPopupMenu::hide() mouseBtDn = FALSE; // mouse button up #if defined(TQT_ACCESSIBILITY_SUPPORT) TQAccessible::updateAccessibility( this, 0, TQAccessible::PopupMenuEnd ); +#endif +#ifndef TQT_NO_MENUBAR + TQMenuData *top = this; // find top level + while ( top->parentMenu ) + top = top->parentMenu; + if( top->isMenuBar ) + x11SetWindowType( X11WindowTypePopup ); // reset #endif parentMenu = 0; hidePopups(); @@ -1738,6 +1783,11 @@ void TQPopupMenu::mouseReleaseEvent( TQMouseEvent *e ) void TQPopupMenu::mouseMoveEvent( TQMouseEvent *e ) { + if( e->globalPos() == d->ignoremousepos ) { + return; + } + d->ignoremousepos = TQPoint(); + motion++; if ( parentMenu && parentMenu->isPopupMenu ) { @@ -1778,6 +1828,11 @@ void TQPopupMenu::mouseMoveEvent( TQMouseEvent *e ) int item = itemAtPos( e->pos() ); if ( item == -1 ) { // no valid item + if( !d->hasmouse ) { + tryMenuBar( e ); + return; + } + d->hasmouse = 0; int lastActItem = actItem; actItem = -1; if ( lastActItem >= 0 ) @@ -1789,6 +1844,7 @@ void TQPopupMenu::mouseMoveEvent( TQMouseEvent *e ) } } else { // mouse on valid item // but did not register mouse press + d->hasmouse = 1; if ( (e->state() & Qt::MouseButtonMask) && !mouseBtDn ) mouseBtDn = TRUE; // so mouseReleaseEvent will pop down @@ -2200,6 +2256,7 @@ void TQPopupMenu::timerEvent( TQTimerEvent *e ) */ void TQPopupMenu::leaveEvent( TQEvent * ) { + d->hasmouse = 0; if ( testWFlags( TQt::WStyle_Tool ) && tqstyle().tqstyleHint(TQStyle::SH_PopupMenu_MouseTracking, this) ) { int lastActItem = actItem; actItem = -1; @@ -2329,27 +2386,37 @@ void TQPopupMenu::subMenuTimer() { TQRect r( itemGeometry( actItem ) ); TQPoint p; TQSize ps = popup->tqsizeHint(); + // GUI Style + int gs = style().tqstyleHint(TQStyle::SH_GUIStyle); + int arrowHMargin, arrowVMargin; + if (gs == GtkStyle) { + arrowHMargin = gtkArrowHMargin; + arrowVMargin = gtkArrowVMargin; + } else { + arrowHMargin = motifArrowHMargin; + arrowVMargin = motifArrowVMargin; + } if( TQApplication::reverseLayout() ) { - p = TQPoint( r.left() + motifArrowHMargin - ps.width(), r.top() + motifArrowVMargin ); + p = TQPoint( r.left() + arrowHMargin - ps.width(), r.top() + arrowVMargin ); p = mapToGlobal( p ); bool right = FALSE; if ( ( parentMenu && parentMenu->isPopupMenu && ((TQPopupMenu*)parentMenu)->tqgeometry().x() < tqgeometry().x() ) || - p.x() < 0 ) + p.x() < screenRect( p ).left()) right = TRUE; - if ( right && (ps.width() > TQApplication::desktop()->width() - mapToGlobal( r.topRight() ).x() ) ) + if ( right && (ps.width() > screenRect( p ).right() - mapToGlobal( r.topRight() ).x() ) ) right = FALSE; if ( right ) p.setX( mapToGlobal( r.topRight() ).x() ); } else { - p = TQPoint( r.right() - motifArrowHMargin, r.top() + motifArrowVMargin ); + p = TQPoint( r.right() - arrowHMargin, r.top() + arrowVMargin ); p = mapToGlobal( p ); bool left = FALSE; if ( ( parentMenu && parentMenu->isPopupMenu && ((TQPopupMenu*)parentMenu)->tqgeometry().x() > tqgeometry().x() ) || - p.x() + ps.width() > TQApplication::desktop()->width() ) + p.x() + ps.width() > screenRect( p ).right() ) left = TRUE; if ( left && (ps.width() > mapToGlobal( r.topLeft() ).x() ) ) left = FALSE; @@ -2357,8 +2424,8 @@ void TQPopupMenu::subMenuTimer() { p.setX( mapToGlobal( r.topLeft() ).x() - ps.width() ); } TQRect pr = popup->itemGeometry(popup->count() - 1); - if (p.y() + ps.height() > TQApplication::desktop()->height() && - p.y() - ps.height() + (TQCOORD) pr.height() >= 0) + if (p.y() + ps.height() > screenRect( p ).bottom() && + p.y() - ps.height() + (TQCOORD) pr.height() >= screenRect( p ).top()) p.setY( p.y() - ps.height() + (TQCOORD) pr.height()); if ( tqstyle().tqstyleHint(TQStyle::SH_PopupMenu_SloppySubMenus, this )) { @@ -2569,7 +2636,7 @@ TQSize TQPopupMenu::tqsizeHint() const constPolish(); TQPopupMenu* that = (TQPopupMenu*) this; //We do not need a resize here, just the tqsizeHint.. - return that->updateSize(FALSE, FALSE).expandedTo( TQApplication::globalStrut() ); + return that->updateSize(FALSE).expandedTo( TQApplication::globalStrut() ); } @@ -2730,6 +2797,9 @@ void TQPopupMenu::toggleTearOff() tqgeometry().topLeft(), FALSE ); p->mitems->setAutoDelete( FALSE ); p->tornOff = TRUE; +#ifdef TQ_WS_X11 + p->x11SetWindowType( X11WindowTypeMenu ); +#endif for ( TQMenuItemListIt it( *mitems ); it.current(); ++it ) { if ( it.current()->id() != TQMenuData::d->aInt && !it.current()->widget() ) p->mitems->append( it.current() ); diff --git a/tqtinterface/qt4/src/widgets/tqpopupmenu.h b/tqtinterface/qt4/src/widgets/tqpopupmenu.h index 0dd00b5..8863cd5 100644 --- a/tqtinterface/qt4/src/widgets/tqpopupmenu.h +++ b/tqtinterface/qt4/src/widgets/tqpopupmenu.h @@ -156,6 +156,7 @@ private: TQSize updateSize(bool force_recalc=FALSE, bool do_resize=TRUE); void updateRow( int row ); + TQRect screenRect(const TQPoint& pos); #ifndef TQT_NO_ACCEL void updateAccel( TQWidget * ); void enableAccel( bool ); diff --git a/tqtinterface/qt4/src/widgets/tqscrollview.cpp b/tqtinterface/qt4/src/widgets/tqscrollview.cpp index 49c5b4d..3ba7eec 100644 --- a/tqtinterface/qt4/src/widgets/tqscrollview.cpp +++ b/tqtinterface/qt4/src/widgets/tqscrollview.cpp @@ -1553,6 +1553,9 @@ bool TQScrollView::eventFilter( TQObject *obj, TQEvent *e ) case TQEvent::LayoutHint: d->autoRetqsizeHint(this); break; + case TQEvent::WindowActivate: + case TQEvent::WindowDeactivate: + return TRUE; default: break; } @@ -1865,7 +1868,7 @@ void TQScrollView::viewportWheelEvent( TQWheelEvent* e ) the event itself. */ TQWheelEvent ce( viewportToContents(e->pos()), - e->globalPos(), e->delta(), e->state()); + e->globalPos(), e->delta(), e->state(), e->orientation()); contentsWheelEvent(&ce); if ( ce.isAccepted() ) e->accept(); diff --git a/tqtinterface/qt4/src/widgets/tqtextedit.cpp b/tqtinterface/qt4/src/widgets/tqtextedit.cpp index 62c1d5f..e299348 100644 --- a/tqtinterface/qt4/src/widgets/tqtextedit.cpp +++ b/tqtinterface/qt4/src/widgets/tqtextedit.cpp @@ -42,6 +42,11 @@ #ifndef TQT_NO_TEXTEDIT +// Keep this position to avoid patch rejection +#ifndef TQT_NO_IM +#include "tqinputcontext.h" +#endif + #include "../kernel/tqrichtext_p.h" #include "tqpainter.h" #include "tqpen.h" @@ -111,6 +116,8 @@ public: int id[ 7 ]; int preeditStart; int preeditLength; + bool composeMode() const { return ( preeditLength > 0 ); } + uint ensureCursorVisibleInShowEvent : 1; uint tabChangesFocus : 1; TQString scrollToAnchor; // used to deferr scrollToAnchor() until the show event when we are resized @@ -1081,6 +1088,10 @@ void TQTextEdit::drawContents( TQPainter *p, int cx, int cy, int cw, int ch ) l += v; } } + + // This invocation is required to follow dragging of active window + // by the showed candidate window. + updateMicroFocusHint(); } /*! @@ -1555,6 +1566,35 @@ void TQTextEdit::keyPressEvent( TQKeyEvent *e ) e->ignore(); } +/*! + This function is not intended as polymorphic usage. Just a shared code + fragment that calls TQWidget::sendMouseEventToInputContext() easily for this + class. + */ +bool TQTextEdit::sendMouseEventToInputContext( TQMouseEvent *e ) +{ +#ifndef TQT_NO_IM + if ( d->composeMode() ) { + TQTextCursor c( doc ); + if ( c.place( e->pos(), doc->firstParagraph(), FALSE, FALSE, FALSE ) ) { + int mousePos = c.index() - d->preeditStart; + if ( cursor->globalY() == c.globalY() && + mousePos >= 0 && mousePos < d->preeditLength ) { + TQWidget::sendMouseEventToInputContext( mousePos, e->type(), + e->button(), e->state() ); + } + } else if ( e->type() != TQEvent::MouseMove ) { + // send button events on out of preedit + TQWidget::sendMouseEventToInputContext( -1, e->type(), + e->button(), e->state() ); + } + return TRUE; + } +#endif + return FALSE; +} + + /*! \reimp */ @@ -1585,11 +1625,17 @@ void TQTextEdit::imComposeEvent( TQIMEvent *e ) doc->removeSelection( TQTextDocument::IMCompositionText ); doc->removeSelection( TQTextDocument::IMSelectionText ); - if ( d->preeditLength > 0 && cursor->paragraph() ) + if ( d->composeMode() && cursor->paragraph() ) cursor->paragraph()->remove( d->preeditStart, d->preeditLength ); cursor->setIndex( d->preeditStart ); d->preeditLength = e->text().length(); - insert( e->text() ); + + int sellen = e->selectionLength(); + uint insertionFlags = CheckNewLines | RemoveSelected | AsIMCompositionText; + if ( sellen > 0 ) { + insertionFlags |= WithIMSelection; + } + insert( e->text(), insertionFlags ); // insert can trigger an imEnd event as it emits a textChanged signal, so better // be careful if(d->preeditStart != -1) { @@ -1601,14 +1647,20 @@ void TQTextEdit::imComposeEvent( TQIMEvent *e ) cursor->setIndex( d->preeditStart + e->cursorPos() ); - int sellen = e->selectionLength(); if ( sellen > 0 ) { cursor->setIndex( d->preeditStart + e->cursorPos() + sellen ); c = *cursor; cursor->setIndex( d->preeditStart + e->cursorPos() ); doc->setSelectionStart( TQTextDocument::IMSelectionText, *cursor ); doc->setSelectionEnd( TQTextDocument::IMSelectionText, c ); +#if 0 + // Disabled for Asian input method that shows candidate + // window. This behavior is same as TQt/E 2.3.7 which supports + // Asian input methods. Asian input methods need start point + // of IM selection text to place candidate window as adjacent + // to the selection text. cursor->setIndex( d->preeditStart + d->preeditLength ); +#endif } } @@ -1632,11 +1684,12 @@ void TQTextEdit::imEndEvent( TQIMEvent *e ) if (undoRedoInfo.type == UndoRedoInfo::IME) undoRedoInfo.type = UndoRedoInfo::Invalid; - if ( d->preeditLength > 0 && cursor->paragraph() ) + if ( d->composeMode() && cursor->paragraph() ) cursor->paragraph()->remove( d->preeditStart, d->preeditLength ); if ( d->preeditStart >= 0 ) { cursor->setIndex( d->preeditStart ); - insert( e->text() ); + //TODO: TQt 4 we should use the new virtual insert function + insert( e->text(), FALSE ); } d->preeditStart = d->preeditLength = -1; @@ -2127,6 +2180,13 @@ void TQTextEdit::drawCursor( bool visible ) isReadOnly() ) return; + // Asian users regard selection text as cursor on candidate + // selection phase of input method, so ordinary cursor should be + // invisible if IM selection text exists. + if ( doc->hasSelection( TQTextDocument::IMSelectionText ) ) { + visible = FALSE; + } + TQPainter p( viewport() ); TQRect r( cursor->topParagraph()->rect() ); cursor->paragraph()->setChanged( TRUE ); @@ -2201,6 +2261,9 @@ void TQTextEdit::contentsMousePressEvent( TQMouseEvent *e ) } #endif + if ( sendMouseEventToInputContext( e ) ) + return; + if ( d->trippleClickTimer->isActive() && ( e->globalPos() - d->trippleClickPoint ).manhattanLength() < TQApplication::startDragDistance() ) { @@ -2306,7 +2369,9 @@ void TQTextEdit::contentsMouseMoveEvent( TQMouseEvent *e ) return; } #endif - if ( mousePressed ) { + if ( sendMouseEventToInputContext( e ) ) { + // don't return from here to avoid cursor vanishing + } else if ( mousePressed ) { #ifndef TQT_NO_DRAGANDDROP if ( mightStartDrag ) { dragStartTimer->stop(); @@ -2363,7 +2428,7 @@ void TQTextEdit::copyToClipboard() void TQTextEdit::contentsMouseReleaseEvent( TQMouseEvent * e ) { - if ( !inDoubleClick ) { // could be the release of a dblclick + if ( !inDoubleClick && !d->composeMode() ) { // could be the release of a dblclick int para = 0; int index = charAt( e->pos(), ¶ ); emit clicked( para, index ); @@ -2374,6 +2439,8 @@ void TQTextEdit::contentsMouseReleaseEvent( TQMouseEvent * e ) return; } #endif + if ( sendMouseEventToInputContext( e ) ) + return; TQTextCursor oldCursor = *cursor; if ( scrollTimer->isActive() ) scrollTimer->stop(); @@ -2467,7 +2534,7 @@ void TQTextEdit::contentsMouseReleaseEvent( TQMouseEvent * e ) void TQTextEdit::contentsMouseDoubleClickEvent( TQMouseEvent * e ) { - if ( e->button() != Qt::LeftButton ) { + if ( e->button() != Qt::LeftButton && !d->composeMode() ) { e->ignore(); return; } @@ -2498,6 +2565,9 @@ void TQTextEdit::contentsMouseDoubleClickEvent( TQMouseEvent * e ) } else #endif { + if ( sendMouseEventToInputContext( e ) ) + return; + TQTextCursor c1 = *cursor; TQTextCursor c2 = *cursor; #if defined(TQ_OS_MAC) @@ -2673,10 +2743,15 @@ void TQTextEdit::contentsDropEvent( TQDropEvent *e ) */ void TQTextEdit::contentsContextMenuEvent( TQContextMenuEvent *e ) { + e->accept(); +#ifndef TQT_NO_IM + if ( d->composeMode() ) + return; +#endif + clearUndoRedo(); mousePressed = FALSE; - e->accept(); #ifndef TQT_NO_POPUPMENU TQGuardedPtr that = this; TQGuardedPtr popup = createPopupMenu( e->pos() ); @@ -2826,6 +2901,12 @@ void TQTextEdit::placeCursor( const TQPoint &pos, TQTextCursor *c, bool link ) void TQTextEdit::updateMicroFocusHint() { TQTextCursor c( *cursor ); +#if 0 + // Disabled for Asian input method that shows candidate + // window. This behavior is same as TQt/E 2.3.7 which supports + // Asian input methods. Asian input methods need start point of IM + // selection text to place candidate window as adjacent to the + // selection text. if ( d->preeditStart != -1 ) { c.setIndex( d->preeditStart ); if(doc->hasSelection(TQTextDocument::IMSelectionText)) { @@ -2834,7 +2915,8 @@ void TQTextEdit::updateMicroFocusHint() c.setIndex(index); } } - +#endif + if ( hasFocus() || viewport()->hasFocus() ) { int h = c.paragraph()->lineHeightOfChar( cursor->index() ); if ( !readonly ) { @@ -2998,6 +3080,8 @@ void TQTextEdit::insert( const TQString &text, uint insertionFlags ) bool indent = insertionFlags & RedoIndentation; bool checkNewLine = insertionFlags & CheckNewLines; bool removeSelected = insertionFlags & RemoveSelected; + bool imComposition = insertionFlags & AsIMCompositionText; + bool imSelection = insertionFlags & WithIMSelection; TQString txt( text ); drawCursor( FALSE ); if ( !isReadOnly() && doc->hasSelection( TQTextDocument::Standard ) && removeSelected ) @@ -3037,7 +3121,10 @@ void TQTextEdit::insert( const TQString &text, uint insertionFlags ) formatMore(); repaintChanged(); ensureCursorVisible(); - drawCursor( TRUE ); + // Asian users regard selection text as cursor on candidate + // selection phase of input method, so ordinary cursor should be + // invisible if IM selection text exists. + drawCursor( !imSelection ); if ( undoEnabled && !isReadOnly() && undoRedoInfo.type != UndoRedoInfo::IME ) { undoRedoInfo.d->text += txt; @@ -3059,7 +3146,13 @@ void TQTextEdit::insert( const TQString &text, uint insertionFlags ) doc->setSelectionEnd( TQTextDocument::Standard, *cursor ); repaintChanged(); } - updateMicroFocusHint(); + // updateMicroFocusHint() should not be invoked here when this + // function is invoked from imComposeEvent() because cursor + // postion is incorrect yet. imComposeEvent() invokes + // updateMicroFocusHint() later. + if ( !imComposition ) { + updateMicroFocusHint(); + } setModified(); emit textChanged(); } @@ -5571,6 +5664,13 @@ TQPopupMenu *TQTextEdit::createPopupMenu( const TQPoint& pos ) #else d->id[ IdSelectAll ] = popup->insertItem( tr( "Select All" ) + ACCEL_KEY( A ) ); #endif + +#ifndef TQT_NO_IM + TQInputContext *qic = getInputContext(); + if ( qic ) + qic->addMenusTo( popup ); +#endif + popup->setItemEnabled( d->id[ IdUndo ], !isReadOnly() && doc->commands()->isUndoAvailable() ); popup->setItemEnabled( d->id[ IdRedo ], !isReadOnly() && doc->commands()->isRedoAvailable() ); #ifndef TQT_NO_CLIPBOARD diff --git a/tqtinterface/qt4/src/widgets/tqtextedit.h b/tqtinterface/qt4/src/widgets/tqtextedit.h index c78371e..ebca634 100644 --- a/tqtinterface/qt4/src/widgets/tqtextedit.h +++ b/tqtinterface/qt4/src/widgets/tqtextedit.h @@ -216,7 +216,9 @@ public: enum TextInsertionFlags { RedoIndentation = 0x0001, CheckNewLines = 0x0002, - RemoveSelected = 0x0004 + RemoveSelected = 0x0004, + AsIMCompositionText = 0x0008, // internal use + WithIMSelection = 0x0010 // internal use }; TQTextEdit( const TQString& text, const TQString& context = TQString::null, @@ -446,6 +448,7 @@ protected: void contentsDropEvent( TQDropEvent *e ); #endif void contentsContextMenuEvent( TQContextMenuEvent *e ); + bool sendMouseEventToInputContext( TQMouseEvent *e ); bool focusNextPrevChild( bool next ); TQTextDocument *document() const; TQTextCursor *textCursor() const; diff --git a/tqtinterface/qt4/src/widgets/tqtooltip.cpp b/tqtinterface/qt4/src/widgets/tqtooltip.cpp index 1bb37fd..1c82b0e 100644 --- a/tqtinterface/qt4/src/widgets/tqtooltip.cpp +++ b/tqtinterface/qt4/src/widgets/tqtooltip.cpp @@ -76,6 +76,7 @@ public: polish(); setText(text); adjustSize(); + x11SetWindowType( X11WindowTypeTooltip ); } void setWidth( int w ) { resize( sizeForWidth( w ) ); } }; @@ -534,6 +535,10 @@ void TQTipManager::showTip() if (!widget) return; +#ifdef TQ_WS_X11 + label->x11SetWindowTransient( widget->tqtopLevelWidget()); +#endif + #ifdef TQ_WS_MAC TQRect screen = TQApplication::desktop()->availableGeometry( scr ); #else diff --git a/tqtinterface/qt4/tools/designer/tools/createcw/createcw.pro b/tqtinterface/qt4/tools/designer/tools/createcw/createcw.pro index 521f9c7..415c0be 100644 --- a/tqtinterface/qt4/tools/designer/tools/createcw/createcw.pro +++ b/tqtinterface/qt4/tools/designer/tools/createcw/createcw.pro @@ -3,3 +3,6 @@ CONFIG += qt warn_on release HEADERS = SOURCES = main.cpp TARGET = createcw + +target.path = $$bins.path +INSTALLS += target diff --git a/tqtinterface/qt4/tools/designer/uic/form.cpp b/tqtinterface/qt4/tools/designer/uic/form.cpp index 5fbbf14..11a0a69 100644 --- a/tqtinterface/qt4/tools/designer/uic/form.cpp +++ b/tqtinterface/qt4/tools/designer/uic/form.cpp @@ -734,16 +734,7 @@ void Uic::createFormImpl( const TQDomElement &e ) } n2 = n2.nextSibling().toElement(); } - } else if ( n.tagName() == "includehints" ) { - TQDomElement n2 = n.firstChild().toElement(); - while ( !n2.isNull() ) { - if ( n2.tagName() == "includehint" ) { - TQString file = n2.firstChild().toText().data(); - localIncludes += file; - } - n2 = n2.nextSibling().toElement(); - } - } + } } // additional includes (local or global) and forward declaractions diff --git a/tqtinterface/qt4/tools/makeqpf/main.cpp b/tqtinterface/qt4/tools/makeqpf/main.cpp index 00e6cb0..3425549 100644 --- a/tqtinterface/qt4/tools/makeqpf/main.cpp +++ b/tqtinterface/qt4/tools/makeqpf/main.cpp @@ -47,7 +47,7 @@ #include #endif -#include +#include class FontViewItem : public TQListViewItem { @@ -137,8 +137,6 @@ public: } }; -extern TQString qws_topdir(); - class MakeTQPF : public TQMainWindow { TQ_OBJECT @@ -152,7 +150,7 @@ public: view->addColumn("Weight"); view->addColumn("Style"); setCentralWidget(view); - TQString fontdir = qws_topdir() + "/lib/fonts"; + TQString fontdir = TQString(getenv("TQTDIR")) + "/lib/fonts"; readFontDir(fontdir); connect(view,TQT_SIGNAL(selectionChanged(TQListViewItem*)), diff --git a/tqtinterface/qt4/tools/qtconfig/mainwindow.cpp b/tqtinterface/qt4/tools/qtconfig/mainwindow.cpp index 754f139..7aaf211 100644 --- a/tqtinterface/qt4/tools/qtconfig/mainwindow.cpp +++ b/tqtinterface/qt4/tools/qtconfig/mainwindow.cpp @@ -40,6 +40,7 @@ #include #include #include +#include #include #include #include @@ -374,13 +375,73 @@ MainWindow::MainWindow() rtlExtensions->setChecked( settings.readBoolEntry( "/qt/useRtlExtensions", FALSE ) ); -#ifdef TQ_WS_X11 +#if defined(TQ_WS_X11) inputStyle->setCurrentText( settings.readEntry( "/qt/XIMInputStyle", trUtf8( "On The Spot" ) ) ); #else inputStyle->hide(); inputStyleLabel->hide(); #endif +#if defined(TQ_WS_X11) && !defined(TQT_NO_IM_EXTENSIONS) + /* + This code makes it possible to set up default input method. + + The list of identifier names of input method which can be used + is acquired using TQInputContextFactory::keys(). And it is + translated to display name and set to inputMethodCombo which + displays the list of input method. + */ + inputMethodIdentifiers = TQInputContextFactory::keys(); + TQStringList imDispNames; + { + // input method switcher should named with "imsw-" prefix to + // prevent to be listed in ordinary input method list. + TQStringList::Iterator imIt = inputMethodIdentifiers.begin(); + while (imIt != inputMethodIdentifiers.end()) { + if ((*imIt).tqfind("imsw-") == 0) + imIt = inputMethodIdentifiers.remove(imIt); + else + imIt++; + } + // we should not sort the list + //inputMethodIdentifiers.sort(); + for (imIt = inputMethodIdentifiers.begin(); + imIt != inputMethodIdentifiers.end(); + imIt++) { + TQString dispName = TQInputContextFactory::displayName(*imIt); + if (dispName.isNull() || dispName.isEmpty()) + dispName = *imIt; + imDispNames << dispName; + } + } + //inputMethodCombo->insertStringList(inputMethodIdentifiers); + inputMethodCombo->insertStringList(imDispNames); + + /* + input method set up as a default in the past is chosen. + If nothing is set up, default input method in the platform is chosen. + */ + // default input method is XIM in X11. + TQString currentIM = settings.readEntry("/qt/DefaultInputMethod", "xim"); + { + int index = inputMethodIdentifiers.findIndex(currentIM); + // set up Selected input method. + if (0 <= index && index < inputMethodIdentifiers.count()) { + inputMethodCombo->setCurrentItem(index); + } else { + // Give up. this part is executed when specified IM is not + // installed. + TQString dispName = tr("Unknown Input Method") + " (" + currentIM + ")"; + inputMethodCombo->insertItem(dispName); + inputMethodCombo->setCurrentItem(inputMethodCombo->count() - 1); + inputMethodIdentifiers << currentIM; + } + } +#else + inputMethodCombo->hide(); + inputMethodLabel->hide(); +#endif + fontembeddingcheckbox->setChecked( settings.readBoolEntry("/qt/embedFonts", TRUE) ); fontpaths = settings.readListEntry("/qt/fontPath", ':'); fontpathlistbox->insertStringList(fontpaths); @@ -457,6 +518,13 @@ void MainWindow::fileSave() else if ( style == trUtf8( "Root" ) ) str = "Root"; settings.writeEntry( "/qt/XIMInputStyle", inputStyle->currentText() ); + +#if !defined(TQT_NO_IM_EXTENSIONS) + TQString imSwitcher = settings.readEntry("/qt/DefaultInputMethodSwitcher", "imsw-multi"); + settings.writeEntry("/qt/DefaultInputMethodSwitcher", imSwitcher); + int imIndex = inputMethodCombo->currentItem(); + settings.writeEntry("/qt/DefaultInputMethod", inputMethodIdentifiers[imIndex]); +#endif #endif TQStringList effects; diff --git a/tqtinterface/qt4/tools/qtconfig/mainwindow.h b/tqtinterface/qt4/tools/qtconfig/mainwindow.h index 6f22c06..66acb8c 100644 --- a/tqtinterface/qt4/tools/qtconfig/mainwindow.h +++ b/tqtinterface/qt4/tools/qtconfig/mainwindow.h @@ -97,6 +97,7 @@ private: TQPalette editPalette, previewPalette; TQStyle *previewstyle; TQStringList fontpaths; + TQStringList inputMethodIdentifiers; bool modified; }; diff --git a/tqtinterface/qt4/tools/qtconfig/mainwindowbase.ui b/tqtinterface/qt4/tools/qtconfig/mainwindowbase.ui index fb56464..fc770b0 100644 --- a/tqtinterface/qt4/tools/qtconfig/mainwindowbase.ui +++ b/tqtinterface/qt4/tools/qtconfig/mainwindowbase.ui @@ -1029,6 +1029,19 @@ 0 + + + inputMethodLabel + + + Default Input Method: + + + + + inputMethodCombo + + spacer5 @@ -1042,7 +1055,7 @@ 20 - 40 + 30 @@ -1717,6 +1730,12 @@ MainWindowBase somethingModified() + + inputMethodCombo + activated(int) + MainWindowBase + somethingModified() + gstylecombo activated(const TQString&) diff --git a/tqtinterface/qt4/tools/qvfb/pda.skin b/tqtinterface/qt4/tools/qvfb/pda.skin index 135e6b6..bdbf197 100644 --- a/tqtinterface/qt4/tools/qvfb/pda.skin +++ b/tqtinterface/qt4/tools/qvfb/pda.skin @@ -1,4 +1,4 @@ -pda_up.png pda_down.png +/usr/share/qvfb/pda_up.png /usr/share/qvfb/pda_down.png 57 81 240 320 0.5 diff --git a/tqtinterface/qt4/tools/qvfb/qvfb.cpp b/tqtinterface/qt4/tools/qvfb/qvfb.cpp index 8fb4cb1..2c7712c 100644 --- a/tqtinterface/qt4/tools/qvfb/qvfb.cpp +++ b/tqtinterface/qt4/tools/qvfb/qvfb.cpp @@ -94,7 +94,7 @@ void TQVFb::init( int display_id, int w, int h, int d, const TQString &skin_name bool vis = isVisible(); if ( vis ) hide(); menuBar()->hide(); - Skin *skin = new Skin( this, skin_name, w, h ); + Skin *skin = new Skin( this, TQString::tqfromLatin1( "/etc/qt3/qvfb/" ) + skin_name, w, h ); view = new TQVFbView( display_id, w, h, d, skin ); skin->setView( view ); view->setMargin( 0 ); diff --git a/tqtinterface/qt4/tools/qvfb/qvfbview.cpp b/tqtinterface/qt4/tools/qvfb/qvfbview.cpp index f7d0669..bc02db7 100644 --- a/tqtinterface/qt4/tools/qvfb/qvfbview.cpp +++ b/tqtinterface/qt4/tools/qvfb/qvfbview.cpp @@ -128,7 +128,7 @@ TQVFbView::TQVFbView( int display_id, int w, int h, int d, TQWidget *tqparent, data = (unsigned char *)shmat( shmId, 0, 0 ); } - if ( (int)data == -1 ) + if ( (long)data == -1 ) qFatal( "Cannot attach to shared memory" ); hdr = (TQVFbHeader *)data; -- cgit v1.2.3