summaryrefslogtreecommitdiff
path: root/libjava/classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c')
-rw-r--r--libjava/classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c2164
1 files changed, 2164 insertions, 0 deletions
diff --git a/libjava/classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c b/libjava/classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c
new file mode 100644
index 000000000..6ba8d4767
--- /dev/null
+++ b/libjava/classpath/native/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkWindowPeer.c
@@ -0,0 +1,2164 @@
+/* gtkwindowpeer.c -- Native implementation of GtkWindowPeer
+ Copyright (C) 1998, 1999, 2002, 2004, 2005, 2006
+ Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+#include "gtkpeer.h"
+#include "gnu_java_awt_peer_gtk_GtkWindowPeer.h"
+#include <gdk/gdkprivate.h>
+#include <gdk/gdkx.h>
+#include <X11/Xatom.h>
+#include <gdk/gdkkeysyms.h>
+
+#define AWT_WINDOW_CLOSING 201
+#define AWT_WINDOW_CLOSED 202
+#define AWT_WINDOW_ICONIFIED 203
+#define AWT_WINDOW_DEICONIFIED 204
+#define AWT_WINDOW_ACTIVATED 205
+#define AWT_WINDOW_DEACTIVATED 206
+#define AWT_WINDOW_GAINED_FOCUS 207
+#define AWT_WINDOW_LOST_FOCUS 208
+#define AWT_WINDOW_STATE_CHANGED 209
+
+#define AWT_FRAME_NORMAL 0
+#define AWT_FRAME_ICONIFIED 1
+#define AWT_FRAME_MAXIMIZED_BOTH 6
+
+/* Virtual Keys */
+/* This list should be kept in the same order as the VK_ field
+ declarations in KeyEvent.java. */
+#define VK_ENTER '\n'
+#define VK_BACK_SPACE '\b'
+#define VK_TAB '\t'
+#define VK_CANCEL 3
+#define VK_CLEAR 12
+#define VK_SHIFT 16
+#define VK_CONTROL 17
+#define VK_ALT 18
+#define VK_PAUSE 19
+#define VK_CAPS_LOCK 20
+#define VK_ESCAPE 27
+#define VK_SPACE ' '
+#define VK_PAGE_UP 33
+#define VK_PAGE_DOWN 34
+#define VK_END 35
+#define VK_HOME 36
+#define VK_LEFT 37
+#define VK_UP 38
+#define VK_RIGHT 39
+#define VK_DOWN 40
+#define VK_COMMA ','
+#define VK_MINUS '-'
+#define VK_PERIOD '.'
+#define VK_SLASH '/'
+#define VK_0 '0'
+#define VK_1 '1'
+#define VK_2 '2'
+#define VK_3 '3'
+#define VK_4 '4'
+#define VK_5 '5'
+#define VK_6 '6'
+#define VK_7 '7'
+#define VK_8 '8'
+#define VK_9 '9'
+#define VK_SEMICOLON ';'
+#define VK_EQUALS '='
+#define VK_A 'A'
+#define VK_B 'B'
+#define VK_C 'C'
+#define VK_D 'D'
+#define VK_E 'E'
+#define VK_F 'F'
+#define VK_G 'G'
+#define VK_H 'H'
+#define VK_I 'I'
+#define VK_J 'J'
+#define VK_K 'K'
+#define VK_L 'L'
+#define VK_M 'M'
+#define VK_N 'N'
+#define VK_O 'O'
+#define VK_P 'P'
+#define VK_Q 'Q'
+#define VK_R 'R'
+#define VK_S 'S'
+#define VK_T 'T'
+#define VK_U 'U'
+#define VK_V 'V'
+#define VK_W 'W'
+#define VK_X 'X'
+#define VK_Y 'Y'
+#define VK_Z 'Z'
+#define VK_OPEN_BRACKET '['
+#define VK_BACK_SLASH '\\'
+#define VK_CLOSE_BRACKET ']'
+/* See gtkpeer.h */
+/* #define VK_NUMPAD0 96 */
+/* #define VK_NUMPAD1 97 */
+/* #define VK_NUMPAD2 98 */
+/* #define VK_NUMPAD3 99 */
+/* #define VK_NUMPAD4 100 */
+/* #define VK_NUMPAD5 101 */
+/* #define VK_NUMPAD6 102 */
+/* #define VK_NUMPAD7 103 */
+/* #define VK_NUMPAD8 104 */
+/* #define VK_NUMPAD9 105 */
+#define VK_MULTIPLY 106
+#define VK_ADD 107
+#define VK_SEPARATER 108
+#define VK_SEPARATOR 108
+#define VK_SUBTRACT 109
+/* See gtkpeer.h */
+/* #define VK_DECIMAL 110 */
+#define VK_DIVIDE 111
+#define VK_DELETE 127
+#define VK_NUM_LOCK 144
+#define VK_SCROLL_LOCK 145
+#define VK_F1 112
+#define VK_F2 113
+#define VK_F3 114
+#define VK_F4 115
+#define VK_F5 116
+#define VK_F6 117
+#define VK_F7 118
+#define VK_F8 119
+#define VK_F9 120
+#define VK_F10 121
+#define VK_F11 122
+#define VK_F12 123
+#define VK_F13 61440
+#define VK_F14 61441
+#define VK_F15 61442
+#define VK_F16 61443
+#define VK_F17 61444
+#define VK_F18 61445
+#define VK_F19 61446
+#define VK_F20 61447
+#define VK_F21 61448
+#define VK_F22 61449
+#define VK_F23 61450
+#define VK_F24 61451
+#define VK_PRINTSCREEN 154
+#define VK_INSERT 155
+#define VK_HELP 156
+#define VK_META 157
+#define VK_BACK_QUOTE 192
+#define VK_QUOTE 222
+#define VK_KP_UP 224
+#define VK_KP_DOWN 225
+#define VK_KP_LEFT 226
+#define VK_KP_RIGHT 227
+#define VK_DEAD_GRAVE 128
+#define VK_DEAD_ACUTE 129
+#define VK_DEAD_CIRCUMFLEX 130
+#define VK_DEAD_TILDE 131
+#define VK_DEAD_MACRON 132
+#define VK_DEAD_BREVE 133
+#define VK_DEAD_ABOVEDOT 134
+#define VK_DEAD_DIAERESIS 135
+#define VK_DEAD_ABOVERING 136
+#define VK_DEAD_DOUBLEACUTE 137
+#define VK_DEAD_CARON 138
+#define VK_DEAD_CEDILLA 139
+#define VK_DEAD_OGONEK 140
+#define VK_DEAD_IOTA 141
+#define VK_DEAD_VOICED_SOUND 142
+#define VK_DEAD_SEMIVOICED_SOUND 143
+#define VK_AMPERSAND 150
+#define VK_ASTERISK 151
+#define VK_QUOTEDBL 152
+#define VK_LESS 153
+#define VK_GREATER 160
+#define VK_BRACELEFT 161
+#define VK_BRACERIGHT 162
+#define VK_AT 512
+#define VK_COLON 513
+#define VK_CIRCUMFLEX 514
+#define VK_DOLLAR 515
+#define VK_EURO_SIGN 516
+#define VK_EXCLAMATION_MARK 517
+#define VK_INVERTED_EXCLAMATION_MARK 518
+#define VK_LEFT_PARENTHESIS 519
+#define VK_NUMBER_SIGN 520
+#define VK_PLUS 521
+#define VK_RIGHT_PARENTHESIS 522
+#define VK_UNDERSCORE 523
+#define VK_FINAL 24
+#define VK_CONVERT 28
+#define VK_NONCONVERT 29
+#define VK_ACCEPT 30
+#define VK_MODECHANGE 31
+#define VK_KANA 21
+#define VK_KANJI 25
+#define VK_ALPHANUMERIC 240
+#define VK_KATAKANA 241
+#define VK_HIRAGANA 242
+#define VK_FULL_WIDTH 243
+#define VK_HALF_WIDTH 244
+#define VK_ROMAN_CHARACTERS 245
+#define VK_ALL_CANDIDATES 256
+#define VK_PREVIOUS_CANDIDATE 257
+#define VK_CODE_INPUT 258
+#define VK_JAPANESE_KATAKANA 259
+#define VK_JAPANESE_HIRAGANA 260
+#define VK_JAPANESE_ROMAN 261
+#define VK_KANA_LOCK 262
+#define VK_INPUT_METHOD_ON_OFF 263
+#define VK_CUT 65489
+#define VK_COPY 65485
+#define VK_PASTE 65487
+#define VK_UNDO 65483
+#define VK_AGAIN 65481
+#define VK_FIND 65488
+#define VK_PROPS 65482
+#define VK_STOP 65480
+#define VK_COMPOSE 65312
+#define VK_ALT_GRAPH 65406
+#define VK_UNDEFINED 0
+#define VK_BEGIN 65368
+#define VK_CONTEXT_MENU 525
+#define VK_WINDOWS 524
+
+
+#define AWT_KEY_CHAR_UNDEFINED 0
+
+#define AWT_FRAME_STATE_NORMAL 0
+#define AWT_FRAME_STATE_ICONIFIED 1
+#define AWT_FRAME_STATE_MAXIMIZED_HORIZ 2
+#define AWT_FRAME_STATE_MAXIMIZED_VERT 4
+#define AWT_FRAME_STATE_MAXIMIZED_BOTH 6
+
+static jmethodID postKeyEventID;
+static jmethodID postWindowEventID;
+static jmethodID postConfigureEventID;
+static jmethodID postInsetsChangedEventID;
+static jmethodID windowGetWidthID;
+static jmethodID windowGetHeightID;
+
+void
+cp_gtk_window_init_jni (void)
+{
+ jclass gtkwindowpeer;
+
+ gtkwindowpeer = (*cp_gtk_gdk_env())->FindClass (cp_gtk_gdk_env(),
+ "gnu/java/awt/peer/gtk/GtkWindowPeer");
+
+ postKeyEventID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkwindowpeer,
+ "postKeyEvent", "(IJIICI)V");
+
+ postWindowEventID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkwindowpeer,
+ "postWindowEvent",
+ "(ILjava/awt/Window;I)V");
+
+ postConfigureEventID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkwindowpeer,
+ "postConfigureEvent", "(IIII)V");
+
+ postInsetsChangedEventID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkwindowpeer,
+ "postInsetsChangedEvent",
+ "(IIII)V");
+
+ windowGetWidthID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkwindowpeer,
+ "getWidth", "()I");
+
+ windowGetHeightID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkwindowpeer,
+ "getHeight", "()I");
+
+ gtkwindowpeer = (*cp_gtk_gdk_env())->FindClass (cp_gtk_gdk_env(),
+ "gnu/java/awt/peer/gtk/GtkWindowPeer");
+}
+
+/* Get the first keyval in the keymap for this event's keycode. The
+ first keyval corresponds roughly to Java's notion of a virtual key.
+ Returns the uppercase version of the first keyval or -1 if no
+ keyval was found for the given hardware keycode. */
+static gint
+get_first_keyval_from_keymap (GdkEventKey *event)
+{
+ guint keyval;
+ guint *keyvals;
+ gint n_entries;
+
+ if (!gdk_keymap_get_entries_for_keycode (NULL,
+ event->hardware_keycode,
+ NULL,
+ &keyvals,
+ &n_entries))
+ {
+ /* No keyval found for hardware keycode */
+ return -1;
+ }
+ keyval = keyvals[0];
+ g_free (keyvals);
+
+ return gdk_keyval_to_upper (keyval);
+}
+
+/* Return the AWT key code for the given keysym or -1 if no keyval was
+ found for the given hardware keycode. */
+#ifdef __GNUC__
+__inline
+#endif
+static jint
+keysym_to_awt_keycode (GdkEventKey *event)
+{
+ gint ukeyval;
+ guint state;
+
+ ukeyval = get_first_keyval_from_keymap (event);
+
+ if (ukeyval < 0)
+ return -1;
+
+ state = event->state;
+
+ /* VK_A through VK_Z */
+ if (ukeyval >= GDK_A && ukeyval <= GDK_Z)
+ return ukeyval;
+
+ /* VK_0 through VK_9 */
+ if (ukeyval >= GDK_0 && ukeyval <= GDK_9)
+ return ukeyval;
+
+ switch (ukeyval)
+ {
+ case GDK_Return:
+ case GDK_KP_Enter:
+ return VK_ENTER;
+ case GDK_BackSpace:
+ return VK_BACK_SPACE;
+ case GDK_Tab:
+ return VK_TAB;
+ case GDK_Cancel:
+ return VK_CANCEL;
+ case GDK_Clear:
+ return VK_CLEAR;
+ case GDK_Shift_L:
+ case GDK_Shift_R:
+ return VK_SHIFT;
+ case GDK_Control_L:
+ case GDK_Control_R:
+ return VK_CONTROL;
+ case GDK_Alt_L:
+ case GDK_Alt_R:
+ return VK_ALT;
+ case GDK_Pause:
+ return VK_PAUSE;
+ case GDK_Caps_Lock:
+ return VK_CAPS_LOCK;
+ case GDK_Escape:
+ return VK_ESCAPE;
+ case GDK_space:
+ return VK_SPACE;
+ case GDK_KP_Page_Up:
+ /* For keys on the numeric keypad, the JVM produces one of two
+ virtual keys, depending on the num lock state. */
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD9;
+ else
+ return VK_PAGE_UP;
+ case GDK_Page_Up:
+ return VK_PAGE_UP;
+ case GDK_KP_Page_Down:
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD3;
+ else
+ return VK_PAGE_DOWN;
+ case GDK_Page_Down:
+ return VK_PAGE_DOWN;
+ case GDK_KP_End:
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD1;
+ else
+ return VK_END;
+ case GDK_End:
+ return VK_END;
+ case GDK_KP_Home:
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD7;
+ else
+ return VK_HOME;
+ case GDK_Home:
+ return VK_HOME;
+ case GDK_KP_Begin:
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD5;
+ else
+ return VK_UNDEFINED;
+ case GDK_Left:
+ return VK_LEFT;
+ case GDK_Up:
+ return VK_UP;
+ case GDK_Right:
+ return VK_RIGHT;
+ case GDK_Down:
+ return VK_DOWN;
+ case GDK_comma:
+ return VK_COMMA;
+ case GDK_minus:
+ return VK_MINUS;
+ case GDK_period:
+ return VK_PERIOD;
+ case GDK_slash:
+ return VK_SLASH;
+ /*
+ return VK_0;
+ return VK_1;
+ return VK_2;
+ return VK_3;
+ return VK_4;
+ return VK_5;
+ return VK_6;
+ return VK_7;
+ return VK_8;
+ return VK_9;
+ */
+ case GDK_semicolon:
+ return VK_SEMICOLON;
+ case GDK_equal:
+ return VK_EQUALS;
+ /*
+ return VK_A;
+ return VK_B;
+ return VK_C;
+ return VK_D;
+ return VK_E;
+ return VK_F;
+ return VK_G;
+ return VK_H;
+ return VK_I;
+ return VK_J;
+ return VK_K;
+ return VK_L;
+ return VK_M;
+ return VK_N;
+ return VK_O;
+ return VK_P;
+ return VK_Q;
+ return VK_R;
+ return VK_S;
+ return VK_T;
+ return VK_U;
+ return VK_V;
+ return VK_W;
+ return VK_X;
+ return VK_Y;
+ return VK_Z;
+ */
+ case GDK_bracketleft:
+ return VK_OPEN_BRACKET;
+ case GDK_backslash:
+ return VK_BACK_SLASH;
+ case GDK_bracketright:
+ return VK_CLOSE_BRACKET;
+ case GDK_KP_0:
+ return VK_NUMPAD0;
+ case GDK_KP_1:
+ return VK_NUMPAD1;
+ case GDK_KP_2:
+ return VK_NUMPAD2;
+ case GDK_KP_3:
+ return VK_NUMPAD3;
+ case GDK_KP_4:
+ return VK_NUMPAD4;
+ case GDK_KP_5:
+ return VK_NUMPAD5;
+ case GDK_KP_6:
+ return VK_NUMPAD6;
+ case GDK_KP_7:
+ return VK_NUMPAD7;
+ case GDK_KP_8:
+ return VK_NUMPAD8;
+ case GDK_KP_9:
+ return VK_NUMPAD9;
+ case GDK_KP_Multiply:
+ return VK_MULTIPLY;
+ case GDK_KP_Add:
+ return VK_ADD;
+ /*
+ return VK_SEPARATER;
+ */
+ case GDK_KP_Separator:
+ return VK_SEPARATOR;
+ case GDK_KP_Subtract:
+ return VK_SUBTRACT;
+ case GDK_KP_Decimal:
+ return VK_DECIMAL;
+ case GDK_KP_Divide:
+ return VK_DIVIDE;
+ case GDK_KP_Delete:
+ if (state & GDK_MOD2_MASK)
+ return VK_DECIMAL;
+ else
+ return VK_DELETE;
+ case GDK_Delete:
+ return VK_DELETE;
+ case GDK_Num_Lock:
+ return VK_NUM_LOCK;
+ case GDK_Scroll_Lock:
+ return VK_SCROLL_LOCK;
+ case GDK_F1:
+ return VK_F1;
+ case GDK_F2:
+ return VK_F2;
+ case GDK_F3:
+ return VK_F3;
+ case GDK_F4:
+ return VK_F4;
+ case GDK_F5:
+ return VK_F5;
+ case GDK_F6:
+ return VK_F6;
+ case GDK_F7:
+ return VK_F7;
+ case GDK_F8:
+ return VK_F8;
+ case GDK_F9:
+ return VK_F9;
+ case GDK_F10:
+ return VK_F10;
+ case GDK_F11:
+ return VK_F11;
+ case GDK_F12:
+ return VK_F12;
+ case GDK_F13:
+ return VK_F13;
+ case GDK_F14:
+ return VK_F14;
+ case GDK_F15:
+ return VK_F15;
+ case GDK_F16:
+ return VK_F16;
+ case GDK_F17:
+ return VK_F17;
+ case GDK_F18:
+ return VK_F18;
+ case GDK_F19:
+ return VK_F19;
+ case GDK_F20:
+ return VK_F20;
+ case GDK_F21:
+ return VK_F21;
+ case GDK_F22:
+ return VK_F22;
+ case GDK_F23:
+ return VK_F23;
+ case GDK_F24:
+ return VK_F24;
+ case GDK_Print:
+ return VK_PRINTSCREEN;
+ case GDK_KP_Insert:
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD0;
+ else
+ return VK_INSERT;
+ case GDK_Insert:
+ return VK_INSERT;
+ case GDK_Help:
+ return VK_HELP;
+ case GDK_Meta_L:
+ case GDK_Meta_R:
+ return VK_META;
+ case GDK_grave:
+ return VK_BACK_QUOTE;
+ case GDK_apostrophe:
+ return VK_QUOTE;
+ case GDK_KP_Up:
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD8;
+ else
+ return VK_KP_UP;
+ case GDK_KP_Down:
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD2;
+ else
+ return VK_KP_DOWN;
+ case GDK_KP_Left:
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD4;
+ else
+ return VK_KP_LEFT;
+ case GDK_KP_Right:
+ if (state & GDK_MOD2_MASK)
+ return VK_NUMPAD6;
+ else
+ return VK_KP_RIGHT;
+ case GDK_dead_grave:
+ return VK_DEAD_GRAVE;
+ case GDK_dead_acute:
+ return VK_DEAD_ACUTE;
+ case GDK_dead_circumflex:
+ return VK_DEAD_CIRCUMFLEX;
+ case GDK_dead_tilde:
+ return VK_DEAD_TILDE;
+ case GDK_dead_macron:
+ return VK_DEAD_MACRON;
+ case GDK_dead_breve:
+ return VK_DEAD_BREVE;
+ case GDK_dead_abovedot:
+ return VK_DEAD_ABOVEDOT;
+ case GDK_dead_diaeresis:
+ return VK_DEAD_DIAERESIS;
+ case GDK_dead_abovering:
+ return VK_DEAD_ABOVERING;
+ case GDK_dead_doubleacute:
+ return VK_DEAD_DOUBLEACUTE;
+ case GDK_dead_caron:
+ return VK_DEAD_CARON;
+ case GDK_dead_cedilla:
+ return VK_DEAD_CEDILLA;
+ case GDK_dead_ogonek:
+ return VK_DEAD_OGONEK;
+ case GDK_dead_iota:
+ return VK_DEAD_IOTA;
+ case GDK_dead_voiced_sound:
+ return VK_DEAD_VOICED_SOUND;
+ case GDK_dead_semivoiced_sound:
+ return VK_DEAD_SEMIVOICED_SOUND;
+ case GDK_ampersand:
+ return VK_AMPERSAND;
+ case GDK_asterisk:
+ return VK_ASTERISK;
+ case GDK_quotedbl:
+ return VK_QUOTEDBL;
+ case GDK_less:
+ return VK_LESS;
+ case GDK_greater:
+ return VK_GREATER;
+ case GDK_braceleft:
+ return VK_BRACELEFT;
+ case GDK_braceright:
+ return VK_BRACERIGHT;
+ case GDK_at:
+ return VK_AT;
+ case GDK_colon:
+ return VK_COLON;
+ case GDK_asciicircum:
+ return VK_CIRCUMFLEX;
+ case GDK_dollar:
+ return VK_DOLLAR;
+ case GDK_EuroSign:
+ return VK_EURO_SIGN;
+ case GDK_exclam:
+ return VK_EXCLAMATION_MARK;
+ case GDK_exclamdown:
+ return VK_INVERTED_EXCLAMATION_MARK;
+ case GDK_parenleft:
+ return VK_LEFT_PARENTHESIS;
+ case GDK_numbersign:
+ return VK_NUMBER_SIGN;
+ case GDK_plus:
+ return VK_PLUS;
+ case GDK_parenright:
+ return VK_RIGHT_PARENTHESIS;
+ case GDK_underscore:
+ return VK_UNDERSCORE;
+ /*
+ return VK_FINAL;
+ return VK_CONVERT;
+ return VK_NONCONVERT;
+ return VK_ACCEPT;
+ */
+ case GDK_Mode_switch:
+ return VK_MODECHANGE;
+ /*
+ return VK_KANA;
+ */
+ case GDK_Kanji:
+ return VK_KANJI;
+ /*
+ return VK_ALPHANUMERIC;
+ */
+ case GDK_Katakana:
+ return VK_KATAKANA;
+ case GDK_Hiragana:
+ return VK_HIRAGANA;
+ /*
+ return VK_FULL_WIDTH;
+ return VK_HALF_WIDTH;
+ return VK_ROMAN_CHARACTERS;
+ return VK_ALL_CANDIDATES;
+ */
+ case GDK_PreviousCandidate:
+ return VK_PREVIOUS_CANDIDATE;
+ case GDK_Codeinput:
+ return VK_CODE_INPUT;
+ /*
+ return VK_JAPANESE_KATAKANA;
+ return VK_JAPANESE_HIRAGANA;
+ return VK_JAPANESE_ROMAN;
+ */
+ case GDK_Kana_Lock:
+ return VK_KANA_LOCK;
+ /*
+ return VK_INPUT_METHOD_ON_OFF;
+ return VK_CUT;
+ return VK_COPY;
+ return VK_PASTE;
+ */
+ case GDK_Undo:
+ return VK_UNDO;
+ case GDK_Redo:
+ return VK_AGAIN;
+ /*
+ return VK_FIND;
+ return VK_PROPS;
+ return VK_STOP;
+ return VK_COMPOSE;
+ */
+ case GDK_ISO_Level3_Shift:
+ return VK_ALT_GRAPH;
+ /*
+ case VK_BEGIN:
+ */
+ case GDK_Menu:
+ return VK_CONTEXT_MENU;
+ case GDK_Super_L:
+ case GDK_Super_R:
+ return VK_WINDOWS;
+
+ default:
+ return VK_UNDEFINED;
+ }
+}
+
+/* Return the AWT key location code for the given keysym or -1 if no
+ keyval was found for the given hardware keycode. */
+static jint
+keysym_to_awt_keylocation (GdkEventKey *event)
+{
+ gint ukeyval;
+
+ ukeyval = get_first_keyval_from_keymap (event);
+
+ if (ukeyval < 0)
+ return -1;
+
+ /* VK_A through VK_Z */
+ if (ukeyval >= GDK_A && ukeyval <= GDK_Z)
+ return AWT_KEY_LOCATION_STANDARD;
+
+ /* VK_0 through VK_9 */
+ if (ukeyval >= GDK_0 && ukeyval <= GDK_9)
+ return AWT_KEY_LOCATION_STANDARD;
+
+ switch (ukeyval)
+ {
+ case GDK_Shift_L:
+ case GDK_Control_L:
+ case GDK_Alt_L:
+ case GDK_Meta_L:
+ return AWT_KEY_LOCATION_LEFT;
+
+ case GDK_Shift_R:
+ case GDK_Control_R:
+ case GDK_Alt_R:
+ case GDK_Meta_R:
+ return AWT_KEY_LOCATION_RIGHT;
+
+ case GDK_Return:
+ case GDK_BackSpace:
+ case GDK_Tab:
+ case GDK_Cancel:
+ case GDK_Clear:
+ case GDK_Pause:
+ case GDK_Caps_Lock:
+ case GDK_Escape:
+ case GDK_space:
+ case GDK_Page_Up:
+ case GDK_Page_Down:
+ case GDK_End:
+ case GDK_Home:
+ case GDK_Left:
+ case GDK_Up:
+ case GDK_Right:
+ case GDK_Down:
+ case GDK_comma:
+ case GDK_minus:
+ case GDK_period:
+ case GDK_slash:
+ case GDK_semicolon:
+ case GDK_equal:
+ case GDK_bracketleft:
+ case GDK_backslash:
+ case GDK_bracketright:
+ case GDK_Delete:
+ case GDK_Scroll_Lock:
+ case GDK_F1:
+ case GDK_F2:
+ case GDK_F3:
+ case GDK_F4:
+ case GDK_F5:
+ case GDK_F6:
+ case GDK_F7:
+ case GDK_F8:
+ case GDK_F9:
+ case GDK_F10:
+ case GDK_F11:
+ case GDK_F12:
+ case GDK_F13:
+ case GDK_F14:
+ case GDK_F15:
+ case GDK_F16:
+ case GDK_F17:
+ case GDK_F18:
+ case GDK_F19:
+ case GDK_F20:
+ case GDK_F21:
+ case GDK_F22:
+ case GDK_F23:
+ case GDK_F24:
+ case GDK_Print:
+ case GDK_Insert:
+ case GDK_Help:
+ case GDK_grave:
+ case GDK_apostrophe:
+ case GDK_dead_grave:
+ case GDK_dead_acute:
+ case GDK_dead_circumflex:
+ case GDK_dead_tilde:
+ case GDK_dead_macron:
+ case GDK_dead_breve:
+ case GDK_dead_abovedot:
+ case GDK_dead_diaeresis:
+ case GDK_dead_abovering:
+ case GDK_dead_doubleacute:
+ case GDK_dead_caron:
+ case GDK_dead_cedilla:
+ case GDK_dead_ogonek:
+ case GDK_dead_iota:
+ case GDK_dead_voiced_sound:
+ case GDK_dead_semivoiced_sound:
+ case GDK_ampersand:
+ case GDK_asterisk:
+ case GDK_quotedbl:
+ case GDK_less:
+ case GDK_greater:
+ case GDK_braceleft:
+ case GDK_braceright:
+ case GDK_at:
+ case GDK_colon:
+ case GDK_asciicircum:
+ case GDK_dollar:
+ case GDK_EuroSign:
+ case GDK_exclam:
+ case GDK_exclamdown:
+ case GDK_parenleft:
+ case GDK_numbersign:
+ case GDK_plus:
+ case GDK_parenright:
+ case GDK_underscore:
+ case GDK_Mode_switch:
+ case GDK_Kanji:
+ case GDK_Katakana:
+ case GDK_Hiragana:
+ case GDK_PreviousCandidate:
+ case GDK_Codeinput:
+ case GDK_Kana_Lock:
+ return AWT_KEY_LOCATION_STANDARD;
+
+ case GDK_KP_Enter:
+ case GDK_KP_Page_Up:
+ case GDK_KP_Page_Down:
+ case GDK_KP_End:
+ case GDK_KP_Home:
+ case GDK_KP_Begin:
+ case GDK_KP_0:
+ case GDK_KP_1:
+ case GDK_KP_2:
+ case GDK_KP_3:
+ case GDK_KP_4:
+ case GDK_KP_5:
+ case GDK_KP_6:
+ case GDK_KP_7:
+ case GDK_KP_8:
+ case GDK_KP_9:
+ case GDK_KP_Multiply:
+ case GDK_KP_Add:
+ case GDK_KP_Separator:
+ case GDK_KP_Subtract:
+ case GDK_KP_Decimal:
+ case GDK_KP_Divide:
+ case GDK_KP_Delete:
+ case GDK_Num_Lock:
+ case GDK_KP_Insert:
+ case GDK_KP_Up:
+ case GDK_KP_Down:
+ case GDK_KP_Left:
+ case GDK_KP_Right:
+ return AWT_KEY_LOCATION_NUMPAD;
+
+ default:
+ return AWT_KEY_LOCATION_UNKNOWN;
+ }
+}
+
+static jchar
+keyevent_to_awt_keychar (GdkEventKey *event)
+{
+ if (event->length > 0)
+ {
+ /* Translate GDK carriage return to Java linefeed. */
+ if (event->string[0] == 13)
+ return VK_ENTER;
+ else
+ return event->string[0];
+ }
+ else
+ {
+ switch (event->keyval)
+ {
+ case GDK_BackSpace:
+ return VK_BACK_SPACE;
+ case GDK_Tab:
+ return VK_TAB;
+ case GDK_Delete:
+ case GDK_KP_Delete:
+ return VK_DELETE;
+ default:
+ return AWT_KEY_CHAR_UNDEFINED;
+ }
+ }
+}
+
+/* Modifier key events need special treatment. In Sun's peer
+ implementation, when a modifier key is pressed, the KEY_PRESSED
+ event has that modifier in its modifiers list. The corresponding
+ KEY_RELEASED event's modifier list does not contain the modifier.
+ For example, pressing and releasing the shift key will produce a
+ key press event with modifiers=Shift, and a key release event with
+ no modifiers. GDK's key events behave in the exact opposite way,
+ so this translation code is needed. */
+static jint
+keyevent_state_to_awt_mods (GdkEventKey *event)
+{
+ jint result = 0;
+ guint state;
+
+ if (event->type == GDK_KEY_PRESS)
+ {
+ state = event->state;
+
+ if (event->keyval == GDK_Shift_L
+ || event->keyval == GDK_Shift_R)
+ result |= AWT_SHIFT_DOWN_MASK | AWT_SHIFT_MASK;
+ else
+ {
+ if (state & GDK_SHIFT_MASK)
+ result |= AWT_SHIFT_DOWN_MASK | AWT_SHIFT_MASK;
+ }
+
+ if (event->keyval == GDK_Control_L
+ || event->keyval == GDK_Control_R)
+ result |= AWT_CTRL_DOWN_MASK | AWT_CTRL_MASK;
+ else
+ {
+ if (state & GDK_CONTROL_MASK)
+ result |= AWT_CTRL_DOWN_MASK | AWT_CTRL_MASK;
+ }
+
+ if (event->keyval == GDK_Alt_L
+ || event->keyval == GDK_Alt_R)
+ result |= AWT_ALT_DOWN_MASK | AWT_ALT_MASK;
+ else
+ {
+ if (state & GDK_MOD1_MASK)
+ result |= AWT_ALT_DOWN_MASK | AWT_ALT_MASK;
+ }
+ }
+ else if (event->type == GDK_KEY_RELEASE)
+ {
+ state = event->state;
+
+ if (event->keyval != GDK_Shift_L
+ && event->keyval != GDK_Shift_R)
+ {
+ if (state & GDK_SHIFT_MASK)
+ result |= AWT_SHIFT_DOWN_MASK | AWT_SHIFT_MASK;
+ }
+ if (event->keyval != GDK_Control_L
+ && event->keyval != GDK_Control_R)
+ {
+ if (state & GDK_CONTROL_MASK)
+ result |= AWT_CTRL_DOWN_MASK | AWT_CTRL_MASK;
+ }
+
+ if (event->keyval != GDK_Alt_L
+ && event->keyval != GDK_Alt_R)
+ {
+ if (state & GDK_MOD1_MASK)
+ result |= AWT_ALT_DOWN_MASK | AWT_ALT_MASK;
+ }
+ }
+
+ return result;
+}
+
+static gboolean window_configure_cb (GtkWidget *widget,
+ GdkEventConfigure *event,
+ jobject peer);
+
+/* FIXME: we're currently seeing the double-activation that occurs
+ with metacity and GTK. See
+ http://bugzilla.gnome.org/show_bug.cgi?id=140977 for details. */
+
+static void window_get_frame_extents (GtkWidget *window,
+ int *top, int *left,
+ int *bottom, int *right);
+
+static void request_frame_extents (GtkWidget *window);
+
+static Bool property_notify_predicate (Display *display,
+ XEvent *xevent,
+ XPointer arg);
+
+static gboolean window_delete_cb (GtkWidget *widget, GdkEvent *event,
+ jobject peer);
+static void window_destroy_cb (GtkWidget *widget, GdkEvent *event,
+ jobject peer);
+static void window_focus_state_change_cb (GtkWidget *widget,
+ GParamSpec *pspec,
+ jobject peer);
+static gboolean window_focus_in_cb (GtkWidget * widget,
+ GdkEventFocus *event,
+ jobject peer);
+static gboolean window_focus_out_cb (GtkWidget * widget,
+ GdkEventFocus *event,
+ jobject peer);
+static gboolean window_window_state_cb (GtkWidget *widget,
+ GdkEvent *event,
+ jobject peer);
+static gboolean window_property_changed_cb (GtkWidget *widget,
+ GdkEventProperty *event,
+ jobject peer);
+static void realize_cb (GtkWidget *widget, jobject peer);
+
+static gboolean
+window_configure_cb (GtkWidget *widget __attribute__((unused)),
+ GdkEventConfigure *event,
+ jobject peer)
+{
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postConfigureEventID,
+ (jint) event->x,
+ (jint) event->y,
+ (jint) event->width,
+ (jint) event->height);
+
+ return FALSE;
+}
+
+static gboolean
+key_press_cb (GtkWidget *widget __attribute__((unused)),
+ GdkEventKey *event,
+ jobject peer)
+{
+ jint keycode;
+ jint keylocation;
+
+ keycode = keysym_to_awt_keycode (event);
+ keylocation = keysym_to_awt_keylocation (event);
+
+ /* Return immediately if an error occurs translating a hardware
+ keycode to a keyval. */
+ if (keycode < 0 || keylocation < 0)
+ return TRUE;
+
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postKeyEventID,
+ (jint) AWT_KEY_PRESSED,
+ (jlong) event->time,
+ keyevent_state_to_awt_mods (event),
+ keycode,
+ keyevent_to_awt_keychar (event),
+ keylocation);
+
+ /* FIXME: generation of key typed events needs to be moved
+ to GtkComponentPeer.postKeyEvent. If the key in a key
+ press event is not an "action" key
+ (KeyEvent.isActionKey) and is not a modifier key, then
+ it should generate a key typed event. */
+ return TRUE;
+}
+
+
+static gboolean
+key_release_cb (GtkWidget *widget __attribute__((unused)),
+ GdkEventKey *event,
+ jobject peer)
+{
+ jint keycode;
+ jint keylocation;
+
+ keycode = keysym_to_awt_keycode (event);
+ keylocation = keysym_to_awt_keylocation (event);
+
+ /* Return immediately if an error occurs translating a hardware
+ keycode to a keyval. */
+ if (keycode < 0 || keylocation < 0)
+ return TRUE;
+
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postKeyEventID,
+ (jint) AWT_KEY_RELEASED,
+ (jlong) event->time,
+ keyevent_state_to_awt_mods (event),
+ keycode,
+ keyevent_to_awt_keychar (event),
+ keylocation);
+
+ return TRUE;
+}
+
+/* Union used for type punning. */
+union extents_union
+{
+ guchar **gu_extents;
+ unsigned long **extents;
+};
+
+union atom_list_union
+{
+ guchar **gu_extents;
+ Atom **atom_list;
+};
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_create
+ (JNIEnv *env, jobject obj, jint type, jboolean decorated, jobject parent)
+{
+ GtkWidget *window_widget;
+ GtkWindow *window;
+ void *window_parent;
+ GtkWidget *fixed;
+
+ gdk_threads_enter ();
+
+ gtkpeer_set_global_ref (env, obj);
+
+ window_widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ window = GTK_WINDOW (window_widget);
+
+ /* Keep this window in front of its parent, if it has one. */
+ if (parent)
+ {
+ window_parent = gtkpeer_get_widget (env, parent);
+ gtk_window_set_transient_for (window, GTK_WINDOW(window_parent));
+ }
+
+ gtk_window_set_decorated (window, decorated);
+
+ gtk_window_set_type_hint (window, type);
+
+ gtk_window_group_add_window (cp_gtk_global_window_group, window);
+
+ fixed = gtk_fixed_new ();
+
+ gtk_container_add (GTK_CONTAINER (window_widget), fixed);
+
+ gtk_widget_show (fixed);
+
+ gtkpeer_set_widget (env, obj, window_widget);
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_gtkWindowSetTitle
+ (JNIEnv *env, jobject obj, jstring title)
+{
+ const char *c_title;
+ void *ptr;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ c_title = (*env)->GetStringUTFChars (env, title, NULL);
+
+ gtk_window_set_title (GTK_WINDOW (ptr), c_title);
+
+ (*env)->ReleaseStringUTFChars (env, title, c_title);
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_gtkWindowSetResizable
+ (JNIEnv *env, jobject obj, jboolean resizable)
+{
+ void *ptr;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+ gtk_window_set_resizable (GTK_WINDOW (ptr), resizable);
+ g_object_set (G_OBJECT (ptr), "allow-shrink", resizable, NULL);
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_gtkWindowSetModal
+ (JNIEnv *env, jobject obj, jboolean modal)
+{
+ void *ptr;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ gtk_window_set_modal (GTK_WINDOW (ptr), modal);
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_gtkWindowSetAlwaysOnTop
+ (JNIEnv *env, jobject obj, jboolean alwaysOnTop)
+{
+ void *ptr;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ gtk_window_set_keep_above (GTK_WINDOW (ptr), alwaysOnTop);
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_gtkWindowHasFocus
+(JNIEnv *env, jobject obj)
+{
+ void *ptr;
+ jboolean retval;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ retval = gtk_window_has_toplevel_focus (GTK_WINDOW (ptr));
+
+ gdk_threads_leave ();
+ return retval;
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_setVisibleNative
+ (JNIEnv *env, jobject obj, jboolean visible)
+{
+ gdk_threads_enter ();
+
+ Java_gnu_java_awt_peer_gtk_GtkWindowPeer_setVisibleNativeUnlocked
+ (env, obj, visible);
+
+ gdk_flush ();
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_setVisibleNativeUnlocked
+ (JNIEnv *env, jobject obj, jboolean visible)
+{
+ void *ptr;
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ if (visible)
+ gtk_widget_show (GTK_WIDGET (ptr));
+ else
+ gtk_widget_hide (GTK_WIDGET (ptr));
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_connectSignals
+ (JNIEnv *env, jobject obj)
+{
+ void *ptr;
+ jobject gref;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+ gref = (jobject) gtkpeer_get_global_ref (env, obj);
+
+ g_signal_connect (G_OBJECT (ptr), "delete-event",
+ G_CALLBACK (window_delete_cb), gref);
+
+ g_signal_connect (G_OBJECT (ptr), "destroy-event",
+ G_CALLBACK (window_destroy_cb), gref);
+
+ g_signal_connect (G_OBJECT (ptr), "notify::has-toplevel-focus",
+ G_CALLBACK (window_focus_state_change_cb), gref);
+
+ g_signal_connect (G_OBJECT (ptr), "focus-in-event",
+ G_CALLBACK (window_focus_in_cb), gref);
+
+ g_signal_connect (G_OBJECT (ptr), "focus-out-event",
+ G_CALLBACK (window_focus_out_cb), gref);
+
+ g_signal_connect (G_OBJECT (ptr), "window-state-event",
+ G_CALLBACK (window_window_state_cb), gref);
+
+ g_signal_connect (G_OBJECT (ptr), "property-notify-event",
+ G_CALLBACK (window_property_changed_cb), gref);
+
+ g_signal_connect_after (G_OBJECT (ptr), "realize",
+ G_CALLBACK (realize_cb), gref);
+
+ g_signal_connect (G_OBJECT (ptr), "key-press-event",
+ G_CALLBACK (key_press_cb), gref);
+
+ g_signal_connect (G_OBJECT (ptr), "key-release-event",
+ G_CALLBACK (key_release_cb), gref);
+
+ g_signal_connect_after (G_OBJECT (ptr), "window-state-event",
+ G_CALLBACK (window_window_state_cb), gref);
+
+ g_signal_connect (G_OBJECT (ptr), "configure-event",
+ G_CALLBACK (window_configure_cb), gref);
+
+ cp_gtk_component_connect_expose_signals (ptr, gref);
+ cp_gtk_component_connect_mouse_signals (ptr, gref);
+
+ /* FIXME: override focus signals here to prevent child fixed repaint? */
+
+ gdk_threads_leave ();
+}
+
+/* Realize the window here so that its frame extents are known now.
+ That way Window.pack can operate with the accurate insets returned
+ by the window manager rather than the default estimates. */
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_realize (JNIEnv *env, jobject obj)
+{
+ void *ptr;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ gtk_widget_realize (GTK_WIDGET (ptr));
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_toBack (JNIEnv *env,
+ jobject obj)
+{
+ void *ptr;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ gdk_window_lower (GTK_WIDGET (ptr)->window);
+ gdk_flush ();
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_toFront (JNIEnv *env,
+ jobject obj)
+{
+ void *ptr;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ gdk_window_raise (GTK_WIDGET (ptr)->window);
+ gdk_flush ();
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_setSize
+ (JNIEnv *env, jobject obj, jint width, jint height)
+{
+ void *ptr;
+
+ gdk_threads_enter ();
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ /* Avoid GTK runtime assertion failures. */
+ width = (width < 1) ? 1 : width;
+ height = (height < 1) ? 1 : height;
+
+ gtk_widget_set_size_request (GTK_WIDGET(ptr), width, height);
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_nativeSetBounds
+ (JNIEnv *env, jobject obj, jint x, jint y, jint width, jint height)
+{
+ gdk_threads_enter ();
+
+ Java_gnu_java_awt_peer_gtk_GtkWindowPeer_nativeSetBoundsUnlocked
+ (env, obj, x, y, width, height);
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_nativeSetLocationUnlocked
+ (JNIEnv *env, jobject obj, jint x, jint y)
+{
+ void *ptr;
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ gtk_window_move (GTK_WINDOW(ptr), x, y);
+
+ if (GTK_WIDGET (ptr)->window != NULL)
+ gdk_window_move (GTK_WIDGET (ptr)->window, x, y);
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_nativeSetLocation
+ (JNIEnv *env, jobject obj, jint x, jint y)
+{
+ gdk_threads_enter ();
+
+ Java_gnu_java_awt_peer_gtk_GtkWindowPeer_nativeSetLocationUnlocked
+ (env, obj, x, y);
+
+ gdk_threads_leave ();
+}
+
+JNIEXPORT void JNICALL
+Java_gnu_java_awt_peer_gtk_GtkWindowPeer_nativeSetBoundsUnlocked
+ (JNIEnv *env, jobject obj, jint x, jint y, jint width, jint height)
+{
+ void *ptr;
+ gint current_width;
+ gint current_height;
+
+ ptr = gtkpeer_get_widget (env, obj);
+
+ /* Avoid GTK runtime assertion failures. */
+ width = (width < 1) ? 1 : width;
+ height = (height < 1) ? 1 : height;
+
+ gtk_window_move (GTK_WINDOW(ptr), x, y);
+ /* The call to gdk_window_move is needed in addition to the call to
+ gtk_window_move. If gdk_window_move isn't called, then the
+ following set of operations doesn't give the expected results:
+
+ 1. show a window
+ 2. manually move it to another position on the screen
+ 3. hide the window
+ 4. reposition the window with Component.setLocation
+ 5. show the window
+
+ Instead of being at the position set by setLocation, the window
+ is reshown at the position to which it was moved manually. */
+ if (GTK_WIDGET (ptr)->window != NULL)
+ gdk_window_move (GTK_WIDGET (ptr)->window, x, y);
+
+ /* Only request resizing if the actual width or height change, otherwise
+ * we get unnecessary flickers because resizing causes GTK to clear the
+ * window content, even if the actual size doesn't change. */
+ gtk_window_get_size(GTK_WINDOW(ptr), &current_width, &current_height);
+ if (current_width != width || current_height != height)
+ {
+ /* Need to change the widget's request size. */
+ gtk_widget_set_size_request (GTK_WIDGET(ptr), width, height);
+ /* Also need to call gtk_window_resize. If the resize is requested
+ by the program and the window's "resizable" property is true then
+ the size request will not be honoured. */
+ gtk_window_resize (GTK_WINDOW (ptr), width, height);
+ }
+}
+
+static void
+window_get_frame_extents (GtkWidget *window,
+ int *top, int *left, int *bottom, int *right)
+{
+ unsigned long *extents = NULL;
+ union extents_union gu_ex;
+
+ /* Guess frame extents in case _NET_FRAME_EXTENTS is not
+ supported. */
+ if (!gtk_window_get_decorated (GTK_WINDOW (window)))
+ {
+ *top = 0;
+ *left = 0;
+ *bottom = 0;
+ *right = 0;
+
+ return;
+ }
+
+ *top = 23;
+ *left = 6;
+ *bottom = 6;
+ *right = 6;
+
+ /* Request that the window manager set window's
+ _NET_FRAME_EXTENTS property. */
+ request_frame_extents (window);
+
+ /* Attempt to retrieve window's frame extents. */
+ gu_ex.extents = &extents;
+ if (gdk_property_get (window->window,
+ gdk_atom_intern ("_NET_FRAME_EXTENTS", FALSE),
+ gdk_atom_intern ("CARDINAL", FALSE),
+ 0,
+ sizeof (unsigned long) * 4,
+ FALSE,
+ NULL,
+ NULL,
+ NULL,
+ gu_ex.gu_extents))
+ {
+ *left = extents [0];
+ *right = extents [1];
+ *top = extents [2];
+ *bottom = extents [3];
+ }
+}
+
+static Atom extents_atom = 0;
+
+/* Requests that the window manager set window's
+ _NET_FRAME_EXTENTS property. */
+static void
+request_frame_extents (GtkWidget *window)
+{
+ const char *request_str = "_NET_REQUEST_FRAME_EXTENTS";
+ GdkAtom request_extents = gdk_atom_intern (request_str, FALSE);
+
+ /* Check if the current window manager supports
+ _NET_REQUEST_FRAME_EXTENTS. */
+ if (gdk_net_wm_supports (request_extents))
+ {
+ GdkDisplay *display = gtk_widget_get_display (window);
+ Display *xdisplay = GDK_DISPLAY_XDISPLAY (display);
+
+ GdkWindow *root_window = gdk_get_default_root_window ();
+ Window xroot_window = GDK_WINDOW_XID (root_window);
+
+ Atom extents_request_atom =
+ gdk_x11_get_xatom_by_name_for_display (display, request_str);
+
+ XEvent xevent;
+ XEvent notify_xevent;
+
+ unsigned long window_id = GDK_WINDOW_XID (GDK_DRAWABLE(window->window));
+
+ if (!extents_atom)
+ {
+ const char *extents_str = "_NET_FRAME_EXTENTS";
+ extents_atom =
+ gdk_x11_get_xatom_by_name_for_display (display, extents_str);
+ }
+
+ xevent.xclient.type = ClientMessage;
+ xevent.xclient.message_type = extents_request_atom;
+ xevent.xclient.display = xdisplay;
+ xevent.xclient.window = window_id;
+ xevent.xclient.format = 32;
+ xevent.xclient.data.l[0] = 0;
+ xevent.xclient.data.l[1] = 0;
+ xevent.xclient.data.l[2] = 0;
+ xevent.xclient.data.l[3] = 0;
+ xevent.xclient.data.l[4] = 0;
+
+ XSendEvent (xdisplay, xroot_window, False,
+ (SubstructureRedirectMask | SubstructureNotifyMask),
+ &xevent);
+
+ XIfEvent(xdisplay, &notify_xevent,
+ property_notify_predicate, (XPointer) &window_id);
+ }
+}
+
+static Bool
+property_notify_predicate (Display *xdisplay __attribute__((unused)),
+ XEvent *event,
+ XPointer window_id)
+{
+ unsigned long *window = (unsigned long *) window_id;
+
+ if (event->xany.type == PropertyNotify
+ && event->xany.window == *window
+ && event->xproperty.atom == extents_atom)
+ return True;
+ else
+ return False;
+}
+
+static gboolean
+window_delete_cb (GtkWidget *widget __attribute__((unused)),
+ GdkEvent *event __attribute__((unused)),
+ jobject peer)
+{
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postWindowEventID,
+ (jint) AWT_WINDOW_CLOSING,
+ (jobject) NULL, (jint) 0);
+
+ /* Prevents that the Window dissappears ("destroy"
+ not being signalled). This is necessary because it
+ should be up to a WindowListener implementation
+ how the AWT Frame responds to close requests. */
+ return TRUE;
+}
+
+static void
+window_destroy_cb (GtkWidget *widget __attribute__((unused)),
+ GdkEvent *event __attribute__((unused)),
+ jobject peer)
+{
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postWindowEventID,
+ (jint) AWT_WINDOW_CLOSED,
+ (jobject) NULL, (jint) 0);
+}
+
+static void
+window_focus_state_change_cb (GtkWidget *widget,
+ GParamSpec *pspec __attribute__((unused)),
+ jobject peer)
+{
+ if (GTK_WINDOW (widget)->has_toplevel_focus)
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postWindowEventID,
+ (jint) AWT_WINDOW_ACTIVATED,
+ (jobject) NULL, (jint) 0);
+ else
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postWindowEventID,
+ (jint) AWT_WINDOW_DEACTIVATED,
+ (jobject) NULL, (jint) 0);
+}
+
+static gboolean
+window_focus_in_cb (GtkWidget * widget __attribute__((unused)),
+ GdkEventFocus *event __attribute__((unused)),
+ jobject peer)
+{
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postWindowEventID,
+ (jint) AWT_WINDOW_GAINED_FOCUS,
+ (jobject) NULL, (jint) 0);
+
+ return FALSE;
+}
+
+static gboolean
+window_focus_out_cb (GtkWidget * widget __attribute__((unused)),
+ GdkEventFocus *event __attribute__((unused)),
+ jobject peer)
+{
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postWindowEventID,
+ (jint) AWT_WINDOW_LOST_FOCUS,
+ (jobject) NULL, (jint) 0);
+
+ return FALSE;
+}
+
+static gboolean
+window_window_state_cb (GtkWidget *widget __attribute__((unused)),
+ GdkEvent *event,
+ jobject peer)
+{
+ jint new_java_state = 0;
+ /* Put together the new state and let the java side figure out what
+ * to post */
+ GdkWindowState new_state = event->window_state.new_window_state;
+ /* The window can be either iconfified, maximized, iconified + maximized
+ * or normal. */
+ if ((new_state & GDK_WINDOW_STATE_ICONIFIED) != 0)
+ new_java_state |= AWT_FRAME_ICONIFIED;
+ if ((new_state & GDK_WINDOW_STATE_MAXIMIZED) != 0)
+ new_java_state |= AWT_FRAME_MAXIMIZED_BOTH;
+ if ((new_state & (GDK_WINDOW_STATE_MAXIMIZED | GDK_WINDOW_STATE_ICONIFIED))
+ == 0)
+ new_java_state = AWT_FRAME_NORMAL;
+
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postWindowEventID,
+ (jint) AWT_WINDOW_STATE_CHANGED,
+ (jobject) NULL, new_java_state);
+
+ return TRUE;
+}
+
+static gboolean
+window_property_changed_cb (GtkWidget *widget __attribute__((unused)),
+ GdkEventProperty *event,
+ jobject peer)
+{
+ unsigned long *extents;
+ union extents_union gu_ex;
+
+ gu_ex.extents = &extents;
+ if (gdk_atom_intern ("_NET_FRAME_EXTENTS", FALSE) == event->atom
+ && gdk_property_get (event->window,
+ gdk_atom_intern ("_NET_FRAME_EXTENTS", FALSE),
+ gdk_atom_intern ("CARDINAL", FALSE),
+ 0,
+ sizeof (unsigned long) * 4,
+ FALSE,
+ NULL,
+ NULL,
+ NULL,
+ gu_ex.gu_extents))
+ {
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postInsetsChangedEventID,
+ (jint) extents[2], /* top */
+ (jint) extents[0], /* left */
+ (jint) extents[3], /* bottom */
+ (jint) extents[1]); /* right */
+ }
+
+
+ return FALSE;
+}
+
+static void
+realize_cb (GtkWidget *widget, jobject peer)
+{
+ jint top = 0;
+ jint left = 0;
+ jint bottom = 0;
+ jint right = 0;
+ jint width = 0;
+ jint height = 0;
+
+ width = (*cp_gtk_gdk_env())->CallIntMethod (cp_gtk_gdk_env(), peer, windowGetWidthID);
+ height = (*cp_gtk_gdk_env())->CallIntMethod (cp_gtk_gdk_env(), peer, windowGetHeightID);
+
+ window_get_frame_extents (widget, &top, &left, &bottom, &right);
+
+ (*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer,
+ postInsetsChangedEventID,
+ top, left, bottom, right);
+
+ gtk_window_set_default_size (GTK_WINDOW (widget),
+ MAX (1, width - left - right),
+ MAX (1, height - top - bottom));
+
+ /* set the size like we do in nativeSetBounds */
+ gtk_widget_set_size_request (widget,
+ MAX (1, width - left - right),
+ MAX (1, height - top - bottom));
+
+ gtk_window_resize (GTK_WINDOW (widget),
+ MAX (1, width - left - right),
+ MAX (1, height - top - bottom));
+}
+
+/*
+ * This method returns a GDK keyval that corresponds to one of the
+ * keysyms in the X keymap table. The return value is only used to
+ * determine the keyval's corresponding hardware keycode, and doesn't
+ * reflect an accurate translation of a Java virtual key value to a
+ * GDK keyval.
+ */
+#ifdef __GNUC__
+__inline
+#endif
+guint
+cp_gtk_awt_keycode_to_keysym (jint keyCode, jint keyLocation)
+{
+ /* GDK_A through GDK_Z */
+ if (keyCode >= VK_A && keyCode <= VK_Z)
+ return gdk_keyval_to_lower (keyCode);
+
+ /* GDK_0 through GDK_9 */
+ if (keyCode >= VK_0 && keyCode <= VK_9)
+ return keyCode;
+
+ switch (keyCode)
+ {
+ case VK_ENTER:
+ return keyLocation == AWT_KEY_LOCATION_NUMPAD ? GDK_KP_Enter : GDK_Return;
+ case VK_BACK_SPACE:
+ return GDK_BackSpace;
+ case VK_TAB:
+ return GDK_Tab;
+ case VK_CANCEL:
+ return GDK_Cancel;
+ case VK_CLEAR:
+ return GDK_Clear;
+ case VK_SHIFT:
+ return keyLocation == AWT_KEY_LOCATION_LEFT ? GDK_Shift_L : GDK_Shift_R;
+ case VK_CONTROL:
+ return keyLocation == AWT_KEY_LOCATION_LEFT ? GDK_Control_L : GDK_Control_R;
+ case VK_ALT:
+ return keyLocation == AWT_KEY_LOCATION_LEFT ? GDK_Alt_L : GDK_Alt_R;
+ case VK_PAUSE:
+ return GDK_Pause;
+ case VK_CAPS_LOCK:
+ return GDK_Caps_Lock;
+ case VK_ESCAPE:
+ return GDK_Escape;
+ case VK_SPACE:
+ return GDK_space;
+ case VK_PAGE_UP:
+ return keyLocation == AWT_KEY_LOCATION_NUMPAD ? GDK_KP_Page_Up : GDK_Page_Up;
+ case VK_PAGE_DOWN:
+ return keyLocation == AWT_KEY_LOCATION_NUMPAD ? GDK_KP_Page_Down : GDK_Page_Down;
+ case VK_END:
+ return keyLocation == AWT_KEY_LOCATION_NUMPAD ? GDK_KP_End : GDK_End;
+ case VK_HOME:
+ return keyLocation == AWT_KEY_LOCATION_NUMPAD ? GDK_KP_Home : GDK_Home;
+ case VK_LEFT:
+ return GDK_Left;
+ case VK_UP:
+ return GDK_Up;
+ case VK_RIGHT:
+ return GDK_Right;
+ case VK_DOWN:
+ return GDK_Down;
+ case VK_COMMA:
+ return GDK_comma;
+ case VK_MINUS:
+ return GDK_minus;
+ case VK_PERIOD:
+ return GDK_period;
+ case VK_SLASH:
+ return GDK_slash;
+ /*
+ case VK_0:
+ case VK_1:
+ case VK_2:
+ case VK_3:
+ case VK_4:
+ case VK_5:
+ case VK_6:
+ case VK_7:
+ case VK_8:
+ case VK_9:
+ */
+ case VK_SEMICOLON:
+ return GDK_semicolon;
+ case VK_EQUALS:
+ return GDK_equal;
+ /*
+ case VK_A:
+ case VK_B:
+ case VK_C:
+ case VK_D:
+ case VK_E:
+ case VK_F:
+ case VK_G:
+ case VK_H:
+ case VK_I:
+ case VK_J:
+ case VK_K:
+ case VK_L:
+ case VK_M:
+ case VK_N:
+ case VK_O:
+ case VK_P:
+ case VK_Q:
+ case VK_R:
+ case VK_S:
+ case VK_T:
+ case VK_U:
+ case VK_V:
+ case VK_W:
+ case VK_X:
+ case VK_Y:
+ case VK_Z:
+ */
+ case VK_OPEN_BRACKET:
+ return GDK_bracketleft;
+ case VK_BACK_SLASH:
+ return GDK_backslash;
+ case VK_CLOSE_BRACKET:
+ return GDK_bracketright;
+ case VK_NUMPAD0:
+ return GDK_KP_0;
+ case VK_NUMPAD1:
+ return GDK_KP_1;
+ case VK_NUMPAD2:
+ return GDK_KP_2;
+ case VK_NUMPAD3:
+ return GDK_KP_3;
+ case VK_NUMPAD4:
+ return GDK_KP_4;
+ case VK_NUMPAD5:
+ return GDK_KP_5;
+ case VK_NUMPAD6:
+ return GDK_KP_6;
+ case VK_NUMPAD7:
+ return GDK_KP_7;
+ case VK_NUMPAD8:
+ return GDK_KP_8;
+ case VK_NUMPAD9:
+ return GDK_KP_9;
+ case VK_MULTIPLY:
+ return GDK_KP_Multiply;
+ case VK_ADD:
+ return GDK_KP_Add;
+ /*
+ case VK_SEPARATER:
+ */
+ case VK_SEPARATOR:
+ return GDK_KP_Separator;
+ case VK_SUBTRACT:
+ return GDK_KP_Subtract;
+ case VK_DECIMAL:
+ return GDK_KP_Decimal;
+ case VK_DIVIDE:
+ return GDK_KP_Divide;
+ case VK_DELETE:
+ return keyLocation == AWT_KEY_LOCATION_NUMPAD ? GDK_KP_Delete : GDK_Delete;
+ case VK_NUM_LOCK:
+ return GDK_Num_Lock;
+ case VK_SCROLL_LOCK:
+ return GDK_Scroll_Lock;
+ case VK_F1:
+ return GDK_F1;
+ case VK_F2:
+ return GDK_F2;
+ case VK_F3:
+ return GDK_F3;
+ case VK_F4:
+ return GDK_F4;
+ case VK_F5:
+ return GDK_F5;
+ case VK_F6:
+ return GDK_F6;
+ case VK_F7:
+ return GDK_F7;
+ case VK_F8:
+ return GDK_F8;
+ case VK_F9:
+ return GDK_F9;
+ case VK_F10:
+ return GDK_F10;
+ case VK_F11:
+ return GDK_F11;
+ case VK_F12:
+ return GDK_F12;
+ case VK_F13:
+ return GDK_F13;
+ case VK_F14:
+ return GDK_F14;
+ case VK_F15:
+ return GDK_F15;
+ case VK_F16:
+ return GDK_F16;
+ case VK_F17:
+ return GDK_F17;
+ case VK_F18:
+ return GDK_F18;
+ case VK_F19:
+ return GDK_F19;
+ case VK_F20:
+ return GDK_F20;
+ case VK_F21:
+ return GDK_F21;
+ case VK_F22:
+ return GDK_F22;
+ case VK_F23:
+ return GDK_F23;
+ case VK_F24:
+ return GDK_F24;
+ case VK_PRINTSCREEN:
+ return GDK_Print;
+ case VK_INSERT:
+ return keyLocation == AWT_KEY_LOCATION_NUMPAD ? GDK_KP_Insert : GDK_Insert;
+ case VK_HELP:
+ return GDK_Help;
+ case VK_META:
+ return keyLocation == AWT_KEY_LOCATION_LEFT ? GDK_Meta_L : GDK_Meta_R;
+ case VK_BACK_QUOTE:
+ return GDK_grave;
+ case VK_QUOTE:
+ return GDK_apostrophe;
+ case VK_KP_UP:
+ return GDK_KP_Up;
+ case VK_KP_DOWN:
+ return GDK_KP_Down;
+ case VK_KP_LEFT:
+ return GDK_KP_Left;
+ case VK_KP_RIGHT:
+ return GDK_KP_Right;
+ case VK_DEAD_GRAVE:
+ return GDK_dead_grave;
+ case VK_DEAD_ACUTE:
+ return GDK_dead_acute;
+ case VK_DEAD_CIRCUMFLEX:
+ return GDK_dead_circumflex;
+ case VK_DEAD_TILDE:
+ return GDK_dead_tilde;
+ case VK_DEAD_MACRON:
+ return GDK_dead_macron;
+ case VK_DEAD_BREVE:
+ return GDK_dead_breve;
+ case VK_DEAD_ABOVEDOT:
+ return GDK_dead_abovedot;
+ case VK_DEAD_DIAERESIS:
+ return GDK_dead_diaeresis;
+ case VK_DEAD_ABOVERING:
+ return GDK_dead_abovering;
+ case VK_DEAD_DOUBLEACUTE:
+ return GDK_dead_doubleacute;
+ case VK_DEAD_CARON:
+ return GDK_dead_caron;
+ case VK_DEAD_CEDILLA:
+ return GDK_dead_cedilla;
+ case VK_DEAD_OGONEK:
+ return GDK_dead_ogonek;
+ case VK_DEAD_IOTA:
+ return GDK_dead_iota;
+ case VK_DEAD_VOICED_SOUND:
+ return GDK_dead_voiced_sound;
+ case VK_DEAD_SEMIVOICED_SOUND:
+ return GDK_dead_semivoiced_sound;
+ case VK_AMPERSAND:
+ return GDK_ampersand;
+ case VK_ASTERISK:
+ return GDK_asterisk;
+ case VK_QUOTEDBL:
+ return GDK_quotedbl;
+ case VK_LESS:
+ return GDK_less;
+ case VK_GREATER:
+ return GDK_greater;
+ case VK_BRACELEFT:
+ return GDK_braceleft;
+ case VK_BRACERIGHT:
+ return GDK_braceright;
+ case VK_AT:
+ return GDK_at;
+ case VK_COLON:
+ return GDK_colon;
+ case VK_CIRCUMFLEX:
+ return GDK_asciicircum;
+ case VK_DOLLAR:
+ return GDK_dollar;
+ case VK_EURO_SIGN:
+ return GDK_EuroSign;
+ case VK_EXCLAMATION_MARK:
+ return GDK_exclam;
+ case VK_INVERTED_EXCLAMATION_MARK:
+ return GDK_exclamdown;
+ case VK_LEFT_PARENTHESIS:
+ return GDK_parenleft;
+ case VK_NUMBER_SIGN:
+ return GDK_numbersign;
+ case VK_PLUS:
+ return GDK_plus;
+ case VK_RIGHT_PARENTHESIS:
+ return GDK_parenright;
+ case VK_UNDERSCORE:
+ return GDK_underscore;
+ /*
+ case VK_FINAL:
+ case VK_CONVERT:
+ case VK_NONCONVERT:
+ case VK_ACCEPT:
+ */
+ case VK_MODECHANGE:
+ return GDK_Mode_switch;
+ /*
+ case VK_KANA:
+ */
+ case VK_KANJI:
+ return GDK_Kanji;
+ /*
+ case VK_ALPHANUMERIC:
+ */
+ case VK_KATAKANA:
+ return GDK_Katakana;
+ case VK_HIRAGANA:
+ return GDK_Hiragana;
+ /*
+ case VK_FULL_WIDTH:
+ case VK_HALF_WIDTH:
+ case VK_ROMAN_CHARACTERS:
+ case VK_ALL_CANDIDATES:
+ */
+ case VK_PREVIOUS_CANDIDATE:
+ return GDK_PreviousCandidate;
+ case VK_CODE_INPUT:
+ return GDK_Codeinput;
+ /*
+ case VK_JAPANESE_KATAKANA:
+ case VK_JAPANESE_HIRAGANA:
+ case VK_JAPANESE_ROMAN:
+ */
+ case VK_KANA_LOCK:
+ return GDK_Kana_Lock;
+ /*
+ case VK_INPUT_METHOD_ON_OFF:
+ case VK_CUT:
+ case VK_COPY:
+ case VK_PASTE:
+ */
+ case VK_UNDO:
+ return GDK_Undo;
+ case VK_AGAIN:
+ return GDK_Redo;
+ /*
+ case VK_FIND:
+ case VK_PROPS:
+ case VK_STOP:
+ case VK_COMPOSE:
+ */
+ case VK_ALT_GRAPH:
+ return GDK_ISO_Level3_Shift;
+ /*
+ case VK_BEGIN:
+ */
+ case VK_CONTEXT_MENU:
+ return GDK_Menu;
+ case VK_WINDOWS:
+ return GDK_Super_R;
+
+ default:
+ return GDK_VoidSymbol;
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-08 05:41:34 +0000