40 |
#include "gnu_java_awt_peer_gtk_GtkComponentPeer.h" |
#include "gnu_java_awt_peer_gtk_GtkComponentPeer.h" |
41 |
|
|
42 |
#include <gtk/gtkprivate.h> |
#include <gtk/gtkprivate.h> |
43 |
#include <gdk/gdkkeysyms.h> |
|
44 |
|
#define AWT_DEFAULT_CURSOR 0 |
45 |
|
#define AWT_CROSSHAIR_CURSOR 1 |
46 |
|
#define AWT_TEXT_CURSOR 2 |
47 |
|
#define AWT_WAIT_CURSOR 3 |
48 |
|
#define AWT_SW_RESIZE_CURSOR 4 |
49 |
|
#define AWT_SE_RESIZE_CURSOR 5 |
50 |
|
#define AWT_NW_RESIZE_CURSOR 6 |
51 |
|
#define AWT_NE_RESIZE_CURSOR 7 |
52 |
|
#define AWT_N_RESIZE_CURSOR 8 |
53 |
|
#define AWT_S_RESIZE_CURSOR 9 |
54 |
|
#define AWT_W_RESIZE_CURSOR 10 |
55 |
|
#define AWT_E_RESIZE_CURSOR 11 |
56 |
|
#define AWT_HAND_CURSOR 12 |
57 |
|
#define AWT_MOVE_CURSOR 13 |
58 |
|
|
59 |
|
#define AWT_BUTTON1_DOWN_MASK (1 << 10) |
60 |
|
#define AWT_BUTTON2_DOWN_MASK (1 << 11) |
61 |
|
#define AWT_BUTTON3_DOWN_MASK (1 << 12) |
62 |
|
|
63 |
|
/* FIXME: use gtk-double-click-time, gtk-double-click-distance */ |
64 |
|
#define MULTI_CLICK_TIME 250 |
65 |
|
/* as opposed to a MULTI_PASS_TIME :) */ |
66 |
|
|
67 |
|
#define AWT_MOUSE_CLICKED 500 |
68 |
|
#define AWT_MOUSE_PRESSED 501 |
69 |
|
#define AWT_MOUSE_RELEASED 502 |
70 |
|
#define AWT_MOUSE_MOVED 503 |
71 |
|
#define AWT_MOUSE_ENTERED 504 |
72 |
|
#define AWT_MOUSE_EXITED 505 |
73 |
|
#define AWT_MOUSE_DRAGGED 506 |
74 |
|
|
75 |
|
#define AWT_FOCUS_GAINED 1004 |
76 |
|
#define AWT_FOCUS_LOST 1005 |
77 |
|
|
78 |
static GtkWidget *find_fg_color_widget (GtkWidget *widget); |
static GtkWidget *find_fg_color_widget (GtkWidget *widget); |
79 |
static GtkWidget *find_bg_color_widget (GtkWidget *widget); |
static GtkWidget *find_bg_color_widget (GtkWidget *widget); |
|
static gboolean focus_in_cb (GtkWidget *widget, |
|
|
GdkEventFocus *event, |
|
|
jobject peer); |
|
|
static gboolean focus_out_cb (GtkWidget *widget, |
|
|
GdkEventFocus *event, |
|
|
jobject peer); |
|
80 |
|
|
81 |
/* |
static jmethodID postMouseEventID; |
82 |
* This method returns a GDK keyval that corresponds to one of the |
static jmethodID setCursorID; |
83 |
* keysyms in the X keymap table. The return value is only used to |
static jmethodID postExposeEventID; |
84 |
* determine the keyval's corresponding hardware keycode, and doesn't |
static jmethodID postFocusEventID; |
85 |
* reflect an accurate translation of a Java virtual key value to a |
|
86 |
* GDK keyval. |
void |
87 |
*/ |
cp_gtk_component_init_jni (void) |
88 |
#ifdef __GNUC__ |
{ |
89 |
__inline |
jclass gtkcomponentpeer; |
90 |
#endif |
|
91 |
guint |
gtkcomponentpeer = (*cp_gtk_gdk_env())->FindClass (cp_gtk_gdk_env(), |
92 |
awt_keycode_to_keysym (jint keyCode, jint keyLocation) |
"gnu/java/awt/peer/gtk/GtkComponentPeer"); |
93 |
{ |
|
94 |
/* GDK_A through GDK_Z */ |
postMouseEventID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkcomponentpeer, |
95 |
if (keyCode >= VK_A && keyCode <= VK_Z) |
"postMouseEvent", "(IJIIIIZ)V"); |
|
return gdk_keyval_to_lower (keyCode); |
|
|
|
|
|
/* GDK_0 through GDK_9 */ |
|
|
if (keyCode >= VK_0 && keyCode <= VK_9) |
|
|
return keyCode; |
|
96 |
|
|
97 |
switch (keyCode) |
setCursorID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkcomponentpeer, |
98 |
|
"setCursor", "()V"); |
99 |
|
|
100 |
|
postExposeEventID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkcomponentpeer, |
101 |
|
"postExposeEvent", "(IIII)V"); |
102 |
|
|
103 |
|
postFocusEventID = (*cp_gtk_gdk_env())->GetMethodID (cp_gtk_gdk_env(), gtkcomponentpeer, |
104 |
|
"postFocusEvent", "(IZ)V"); |
105 |
|
} |
106 |
|
|
107 |
|
static gboolean component_button_press_cb (GtkWidget *widget, |
108 |
|
GdkEventButton *event, |
109 |
|
jobject peer); |
110 |
|
static gboolean component_button_release_cb (GtkWidget *widget, |
111 |
|
GdkEventButton *event, |
112 |
|
jobject peer); |
113 |
|
static gboolean component_motion_notify_cb (GtkWidget *widget, |
114 |
|
GdkEventMotion *event, |
115 |
|
jobject peer); |
116 |
|
static gboolean component_enter_notify_cb (GtkWidget *widget, |
117 |
|
GdkEventCrossing *event, |
118 |
|
jobject peer); |
119 |
|
static gboolean component_leave_notify_cb (GtkWidget *widget, |
120 |
|
GdkEventCrossing *event, |
121 |
|
jobject peer); |
122 |
|
static gboolean component_expose_cb (GtkWidget *widget, |
123 |
|
GdkEventExpose *event, |
124 |
|
jobject peer); |
125 |
|
static gboolean component_focus_in_cb (GtkWidget *widget, |
126 |
|
GdkEventFocus *event, |
127 |
|
jobject peer); |
128 |
|
static gboolean component_focus_out_cb (GtkWidget *widget, |
129 |
|
GdkEventFocus *event, |
130 |
|
jobject peer); |
131 |
|
|
132 |
|
static jint |
133 |
|
button_to_awt_mods (int button) |
134 |
|
{ |
135 |
|
switch (button) |
136 |
{ |
{ |
137 |
case VK_ENTER: |
case 1: |
138 |
return keyLocation == AWT_KEY_LOCATION_NUMPAD ? GDK_KP_Enter : GDK_Return; |
return AWT_BUTTON1_MASK; |
139 |
case VK_BACK_SPACE: |
case 2: |
140 |
return GDK_BackSpace; |
return AWT_BUTTON2_MASK; |
141 |
case VK_TAB: |
case 3: |
142 |
return GDK_Tab; |
return AWT_BUTTON3_MASK; |
|
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: |
|
|
case VK_AGAIN: |
|
|
case VK_FIND: |
|
|
case VK_PROPS: |
|
|
case VK_STOP: |
|
|
case VK_COMPOSE: |
|
|
case VK_ALT_GRAPH: |
|
|
*/ |
|
|
default: |
|
|
return GDK_VoidSymbol; |
|
143 |
} |
} |
144 |
|
|
145 |
|
return 0; |
146 |
|
} |
147 |
|
|
148 |
|
static jint |
149 |
|
state_to_awt_mods (guint state) |
150 |
|
{ |
151 |
|
jint result = 0; |
152 |
|
|
153 |
|
if (state & GDK_SHIFT_MASK) |
154 |
|
result |= AWT_SHIFT_DOWN_MASK; |
155 |
|
if (state & GDK_CONTROL_MASK) |
156 |
|
result |= AWT_CTRL_DOWN_MASK; |
157 |
|
if (state & GDK_MOD1_MASK) |
158 |
|
result |= AWT_ALT_DOWN_MASK; |
159 |
|
|
160 |
|
return result; |
161 |
|
} |
162 |
|
|
163 |
|
static jint |
164 |
|
state_to_awt_mods_with_button_states (guint state) |
165 |
|
{ |
166 |
|
jint result = 0; |
167 |
|
|
168 |
|
if (state & GDK_SHIFT_MASK) |
169 |
|
result |= AWT_SHIFT_DOWN_MASK; |
170 |
|
if (state & GDK_CONTROL_MASK) |
171 |
|
result |= AWT_CTRL_DOWN_MASK; |
172 |
|
if (state & GDK_MOD1_MASK) |
173 |
|
result |= AWT_ALT_DOWN_MASK; |
174 |
|
if (state & GDK_BUTTON1_MASK) |
175 |
|
result |= AWT_BUTTON1_DOWN_MASK; |
176 |
|
if (state & GDK_BUTTON2_MASK) |
177 |
|
result |= AWT_BUTTON2_DOWN_MASK; |
178 |
|
if (state & GDK_BUTTON3_MASK) |
179 |
|
result |= AWT_BUTTON3_DOWN_MASK; |
180 |
|
|
181 |
|
return result; |
182 |
} |
} |
183 |
|
|
184 |
JNIEXPORT void JNICALL |
JNIEXPORT void JNICALL |
394 |
event->key.length = 0; |
event->key.length = 0; |
395 |
event->key.string = NULL; |
event->key.string = NULL; |
396 |
|
|
397 |
lookup_keyval = awt_keycode_to_keysym (keyCode, keyLocation); |
lookup_keyval = cp_gtk_awt_keycode_to_keysym (keyCode, keyLocation); |
398 |
|
|
399 |
if (!gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (), |
if (!gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (), |
400 |
lookup_keyval, |
lookup_keyval, |
602 |
|
|
603 |
bg = GTK_WIDGET (ptr)->style->bg[GTK_STATE_NORMAL]; |
bg = GTK_WIDGET (ptr)->style->bg[GTK_STATE_NORMAL]; |
604 |
|
|
605 |
|
gdk_threads_leave (); |
606 |
|
|
607 |
array = (*env)->NewIntArray (env, 3); |
array = (*env)->NewIntArray (env, 3); |
608 |
|
|
609 |
|
gdk_threads_enter (); |
610 |
|
|
611 |
rgb = (*env)->GetIntArrayElements (env, array, NULL); |
rgb = (*env)->GetIntArrayElements (env, array, NULL); |
612 |
/* convert color data from 16 bit values down to 8 bit values */ |
/* convert color data from 16 bit values down to 8 bit values */ |
613 |
rgb[0] = bg.red >> 8; |
rgb[0] = bg.red >> 8; |
635 |
|
|
636 |
fg = GTK_WIDGET (ptr)->style->fg[GTK_STATE_NORMAL]; |
fg = GTK_WIDGET (ptr)->style->fg[GTK_STATE_NORMAL]; |
637 |
|
|
638 |
|
gdk_threads_leave (); |
639 |
|
|
640 |
array = (*env)->NewIntArray (env, 3); |
array = (*env)->NewIntArray (env, 3); |
641 |
|
|
642 |
|
gdk_threads_enter (); |
643 |
|
|
644 |
rgb = (*env)->GetIntArrayElements (env, array, NULL); |
rgb = (*env)->GetIntArrayElements (env, array, NULL); |
645 |
/* convert color data from 16 bit values down to 8 bit values */ |
/* convert color data from 16 bit values down to 8 bit values */ |
646 |
rgb[0] = fg.red >> 8; |
rgb[0] = fg.red >> 8; |
802 |
{ |
{ |
803 |
void *ptr; |
void *ptr; |
804 |
jobject *gref; |
jobject *gref; |
805 |
|
|
806 |
|
gdk_threads_enter (); |
807 |
|
|
808 |
ptr = NSA_GET_PTR (env, obj); |
ptr = NSA_GET_PTR (env, obj); |
809 |
gref = NSA_GET_GLOBAL_REF (env, obj); |
gref = NSA_GET_GLOBAL_REF (env, obj); |
810 |
|
|
811 |
gdk_threads_enter (); |
cp_gtk_component_connect_signals (ptr, gref); |
812 |
|
|
813 |
/* Connect EVENT signal, which happens _before_ any specific signal. */ |
gdk_threads_leave (); |
814 |
g_signal_connect (GTK_OBJECT (ptr), "event", |
} |
|
G_CALLBACK (pre_event_handler), *gref); |
|
815 |
|
|
816 |
g_signal_connect (G_OBJECT (ptr), "focus-in-event", |
JNIEXPORT void JNICALL |
817 |
G_CALLBACK (focus_in_cb), *gref); |
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_setNativeEventMask |
818 |
|
(JNIEnv *env, jobject obj) |
819 |
|
{ |
820 |
|
void *ptr; |
821 |
|
|
822 |
g_signal_connect (G_OBJECT (ptr), "focus-out-event", |
gdk_threads_enter (); |
823 |
G_CALLBACK (focus_out_cb), *gref); |
|
824 |
|
ptr = NSA_GET_PTR (env, obj); |
825 |
|
|
826 |
g_signal_connect_after (G_OBJECT (ptr), "realize", |
gtk_widget_add_events (GTK_WIDGET (ptr), |
827 |
G_CALLBACK (connect_awt_hook_cb), *gref); |
GDK_POINTER_MOTION_MASK |
828 |
|
| GDK_BUTTON_MOTION_MASK |
829 |
|
| GDK_BUTTON_PRESS_MASK |
830 |
|
| GDK_BUTTON_RELEASE_MASK |
831 |
|
| GDK_KEY_PRESS_MASK |
832 |
|
| GDK_KEY_RELEASE_MASK |
833 |
|
| GDK_ENTER_NOTIFY_MASK |
834 |
|
| GDK_LEAVE_NOTIFY_MASK |
835 |
|
| GDK_STRUCTURE_MASK |
836 |
|
| GDK_KEY_PRESS_MASK |
837 |
|
| GDK_FOCUS_CHANGE_MASK); |
838 |
|
|
839 |
gdk_threads_leave (); |
gdk_threads_leave (); |
840 |
} |
} |
866 |
return bg_color_widget; |
return bg_color_widget; |
867 |
} |
} |
868 |
|
|
869 |
static gboolean |
void |
870 |
focus_in_cb (GtkWidget *widget __attribute((unused)), |
cp_gtk_component_connect_expose_signals (GObject *ptr, jobject *gref) |
|
GdkEventFocus *event __attribute((unused)), |
|
|
jobject peer) |
|
871 |
{ |
{ |
872 |
gdk_threads_leave (); |
g_signal_connect (G_OBJECT (ptr), "expose-event", |
873 |
|
G_CALLBACK (component_expose_cb), *gref); |
|
(*gdk_env())->CallVoidMethod (gdk_env(), peer, |
|
|
postFocusEventID, |
|
|
AWT_FOCUS_GAINED, |
|
|
JNI_FALSE); |
|
|
|
|
|
gdk_threads_enter (); |
|
|
|
|
|
return FALSE; |
|
874 |
} |
} |
875 |
|
|
876 |
static gboolean |
void |
877 |
focus_out_cb (GtkWidget *widget __attribute((unused)), |
cp_gtk_component_connect_focus_signals (GObject *ptr, jobject *gref) |
|
GdkEventFocus *event __attribute((unused)), |
|
|
jobject peer) |
|
878 |
{ |
{ |
879 |
gdk_threads_leave (); |
g_signal_connect (G_OBJECT (ptr), "focus-in-event", |
880 |
|
G_CALLBACK (component_focus_in_cb), *gref); |
881 |
(*gdk_env())->CallVoidMethod (gdk_env(), peer, |
|
882 |
postFocusEventID, |
g_signal_connect (G_OBJECT (ptr), "focus-out-event", |
883 |
AWT_FOCUS_LOST, |
G_CALLBACK (component_focus_out_cb), *gref); |
|
JNI_FALSE); |
|
|
|
|
|
gdk_threads_enter (); |
|
|
|
|
|
return FALSE; |
|
884 |
} |
} |
885 |
|
|
886 |
void |
void |
887 |
classpath_gtk_component_connect_nonfocus_signals (GObject *ptr __attribute__((unused)), jobject *gref __attribute__((unused))) |
cp_gtk_component_connect_mouse_signals (GObject *ptr, jobject *gref) |
888 |
{ |
{ |
|
/* FIXME */ |
|
|
#if 0 |
|
889 |
g_signal_connect (G_OBJECT (ptr), "button-press-event", |
g_signal_connect (G_OBJECT (ptr), "button-press-event", |
890 |
G_CALLBACK (component_button_press_cb), *gref); |
G_CALLBACK (component_button_press_cb), *gref); |
891 |
|
|
895 |
g_signal_connect (G_OBJECT (ptr), "enter-notify-event", |
g_signal_connect (G_OBJECT (ptr), "enter-notify-event", |
896 |
G_CALLBACK (component_enter_notify_cb), *gref); |
G_CALLBACK (component_enter_notify_cb), *gref); |
897 |
|
|
|
g_signal_connect (G_OBJECT (ptr), "expose-event", |
|
|
G_CALLBACK (component_expose_cb), *gref); |
|
|
|
|
898 |
g_signal_connect (G_OBJECT (ptr), "leave-notify-event", |
g_signal_connect (G_OBJECT (ptr), "leave-notify-event", |
899 |
G_CALLBACK (component_leave_notify_cb), *gref); |
G_CALLBACK (component_leave_notify_cb), *gref); |
900 |
|
|
901 |
g_signal_connect (G_OBJECT (ptr), "motion-notify-event", |
g_signal_connect (G_OBJECT (ptr), "motion-notify-event", |
902 |
G_CALLBACK (component_motion_notify_cb), *gref); |
G_CALLBACK (component_motion_notify_cb), *gref); |
|
#endif |
|
903 |
} |
} |
904 |
|
|
905 |
void |
void |
906 |
classpath_gtk_component_connect_signals (GObject *ptr __attribute__((unused)), jobject *gref __attribute__((unused))) |
cp_gtk_component_connect_signals (GObject *ptr, jobject *gref) |
907 |
{ |
{ |
908 |
/* FIXME */ |
cp_gtk_component_connect_expose_signals (ptr, gref); |
909 |
#if 0 |
cp_gtk_component_connect_focus_signals (ptr, gref); |
910 |
classpath_gtk_component_connect_nonfocus_signals (ptr, gref); |
cp_gtk_component_connect_mouse_signals (ptr, gref); |
911 |
|
} |
912 |
g_signal_connect (G_OBJECT (ptr), "focus-in-event", |
|
913 |
G_CALLBACK (component_focus_in_cb), *gref); |
/* These variables are used to keep track of click counts. The AWT |
914 |
|
allows more than a triple click to occur but GTK doesn't report |
915 |
|
more-than-triple clicks. */ |
916 |
|
static jint click_count = 1; |
917 |
|
static guint32 button_click_time = 0; |
918 |
|
static GdkWindow *button_window = NULL; |
919 |
|
static guint button_number = -1; |
920 |
|
static int hasBeenDragged; |
921 |
|
|
922 |
|
static gboolean |
923 |
|
component_button_press_cb (GtkWidget *widget __attribute__((unused)), |
924 |
|
GdkEventButton *event, |
925 |
|
jobject peer) |
926 |
|
{ |
927 |
|
/* Ignore double and triple click events. */ |
928 |
|
if (event->type == GDK_2BUTTON_PRESS |
929 |
|
|| event->type == GDK_3BUTTON_PRESS) |
930 |
|
return FALSE; |
931 |
|
|
932 |
|
if ((event->time < (button_click_time + MULTI_CLICK_TIME)) |
933 |
|
&& (event->window == button_window) |
934 |
|
&& (event->button == button_number)) |
935 |
|
click_count++; |
936 |
|
else |
937 |
|
click_count = 1; |
938 |
|
|
939 |
|
button_click_time = event->time; |
940 |
|
button_window = event->window; |
941 |
|
button_number = event->button; |
942 |
|
|
943 |
|
gdk_threads_leave (); |
944 |
|
|
945 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, |
946 |
|
postMouseEventID, |
947 |
|
AWT_MOUSE_PRESSED, |
948 |
|
(jlong)event->time, |
949 |
|
state_to_awt_mods (event->state) |
950 |
|
| button_to_awt_mods (event->button), |
951 |
|
(jint)event->x, |
952 |
|
(jint)event->y, |
953 |
|
click_count, |
954 |
|
(event->button == 3) ? JNI_TRUE : |
955 |
|
JNI_FALSE); |
956 |
|
|
957 |
|
gdk_threads_enter (); |
958 |
|
|
959 |
|
hasBeenDragged = FALSE; |
960 |
|
|
961 |
|
return FALSE; |
962 |
|
} |
963 |
|
|
964 |
|
static gboolean |
965 |
|
component_button_release_cb (GtkWidget *widget __attribute__((unused)), |
966 |
|
GdkEventButton *event, |
967 |
|
jobject peer) |
968 |
|
{ |
969 |
|
int width, height; |
970 |
|
|
971 |
|
gdk_threads_leave (); |
972 |
|
|
973 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, |
974 |
|
postMouseEventID, |
975 |
|
AWT_MOUSE_RELEASED, |
976 |
|
(jlong)event->time, |
977 |
|
state_to_awt_mods (event->state) |
978 |
|
| button_to_awt_mods (event->button), |
979 |
|
(jint)event->x, |
980 |
|
(jint)event->y, |
981 |
|
click_count, |
982 |
|
JNI_FALSE); |
983 |
|
|
984 |
|
gdk_threads_enter (); |
985 |
|
|
986 |
|
/* Generate an AWT click event only if the release occured in the |
987 |
|
window it was pressed in, and the mouse has not been dragged since |
988 |
|
the last time it was pressed. */ |
989 |
|
gdk_window_get_size (event->window, &width, &height); |
990 |
|
if (! hasBeenDragged |
991 |
|
&& event->x >= 0 |
992 |
|
&& event->y >= 0 |
993 |
|
&& event->x <= width |
994 |
|
&& event->y <= height) |
995 |
|
{ |
996 |
|
gdk_threads_leave (); |
997 |
|
|
998 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, |
999 |
|
postMouseEventID, |
1000 |
|
AWT_MOUSE_CLICKED, |
1001 |
|
(jlong)event->time, |
1002 |
|
state_to_awt_mods (event->state) |
1003 |
|
| button_to_awt_mods (event->button), |
1004 |
|
(jint)event->x, |
1005 |
|
(jint)event->y, |
1006 |
|
click_count, |
1007 |
|
JNI_FALSE); |
1008 |
|
|
1009 |
|
gdk_threads_enter (); |
1010 |
|
} |
1011 |
|
return FALSE; |
1012 |
|
} |
1013 |
|
|
1014 |
g_signal_connect (G_OBJECT (ptr), "focus-out-event", |
static gboolean |
1015 |
G_CALLBACK (component_focus_out_cb), *gref); |
component_motion_notify_cb (GtkWidget *widget __attribute__((unused)), |
1016 |
#endif |
GdkEventMotion *event, |
1017 |
|
jobject peer) |
1018 |
|
{ |
1019 |
|
if (event->state & (GDK_BUTTON1_MASK |
1020 |
|
| GDK_BUTTON2_MASK |
1021 |
|
| GDK_BUTTON3_MASK |
1022 |
|
| GDK_BUTTON4_MASK |
1023 |
|
| GDK_BUTTON5_MASK)) |
1024 |
|
{ |
1025 |
|
gdk_threads_leave (); |
1026 |
|
|
1027 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, |
1028 |
|
postMouseEventID, |
1029 |
|
AWT_MOUSE_DRAGGED, |
1030 |
|
(jlong)event->time, |
1031 |
|
state_to_awt_mods_with_button_states (event->state), |
1032 |
|
(jint)event->x, |
1033 |
|
(jint)event->y, |
1034 |
|
0, |
1035 |
|
JNI_FALSE); |
1036 |
|
|
1037 |
|
gdk_threads_enter (); |
1038 |
|
|
1039 |
|
hasBeenDragged = TRUE; |
1040 |
|
} |
1041 |
|
else |
1042 |
|
{ |
1043 |
|
gdk_threads_leave (); |
1044 |
|
|
1045 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, postMouseEventID, |
1046 |
|
AWT_MOUSE_MOVED, |
1047 |
|
(jlong)event->time, |
1048 |
|
state_to_awt_mods (event->state), |
1049 |
|
(jint)event->x, |
1050 |
|
(jint)event->y, |
1051 |
|
0, |
1052 |
|
JNI_FALSE); |
1053 |
|
|
1054 |
|
gdk_threads_enter (); |
1055 |
|
} |
1056 |
|
return FALSE; |
1057 |
|
} |
1058 |
|
|
1059 |
|
static gboolean |
1060 |
|
component_enter_notify_cb (GtkWidget *widget __attribute__((unused)), |
1061 |
|
GdkEventCrossing *event, |
1062 |
|
jobject peer) |
1063 |
|
{ |
1064 |
|
/* We are not interested in enter events that are due to |
1065 |
|
grab/ungrab and not to actually crossing boundaries */ |
1066 |
|
if (event->mode == GDK_CROSSING_NORMAL) |
1067 |
|
{ |
1068 |
|
gdk_threads_leave (); |
1069 |
|
|
1070 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, postMouseEventID, |
1071 |
|
AWT_MOUSE_ENTERED, |
1072 |
|
(jlong)event->time, |
1073 |
|
state_to_awt_mods_with_button_states (event->state), |
1074 |
|
(jint)event->x, |
1075 |
|
(jint)event->y, |
1076 |
|
0, |
1077 |
|
JNI_FALSE); |
1078 |
|
|
1079 |
|
gdk_threads_enter (); |
1080 |
|
} |
1081 |
|
return FALSE; |
1082 |
|
} |
1083 |
|
|
1084 |
|
static gboolean |
1085 |
|
component_leave_notify_cb (GtkWidget *widget __attribute__((unused)), |
1086 |
|
GdkEventCrossing *event, |
1087 |
|
jobject peer) |
1088 |
|
{ |
1089 |
|
/* We are not interested in leave events that are due to |
1090 |
|
grab/ungrab and not to actually crossing boundaries */ |
1091 |
|
if (event->mode == GDK_CROSSING_NORMAL) |
1092 |
|
{ |
1093 |
|
gdk_threads_leave (); |
1094 |
|
|
1095 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, |
1096 |
|
postMouseEventID, |
1097 |
|
AWT_MOUSE_EXITED, |
1098 |
|
(jlong)event->time, |
1099 |
|
state_to_awt_mods_with_button_states (event->state), |
1100 |
|
(jint)event->x, |
1101 |
|
(jint)event->y, |
1102 |
|
0, |
1103 |
|
JNI_FALSE); |
1104 |
|
|
1105 |
|
gdk_threads_enter (); |
1106 |
|
} |
1107 |
|
return FALSE; |
1108 |
|
} |
1109 |
|
|
1110 |
|
static gboolean |
1111 |
|
component_expose_cb (GtkWidget *widget __attribute__((unused)), |
1112 |
|
GdkEventExpose *event, |
1113 |
|
jobject peer) |
1114 |
|
{ |
1115 |
|
gdk_threads_leave (); |
1116 |
|
|
1117 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, |
1118 |
|
postExposeEventID, |
1119 |
|
(jint)event->area.x, |
1120 |
|
(jint)event->area.y, |
1121 |
|
(jint)event->area.width, |
1122 |
|
(jint)event->area.height); |
1123 |
|
|
1124 |
|
gdk_threads_enter (); |
1125 |
|
|
1126 |
|
return FALSE; |
1127 |
|
} |
1128 |
|
|
1129 |
|
static gboolean |
1130 |
|
component_focus_in_cb (GtkWidget *widget __attribute((unused)), |
1131 |
|
GdkEventFocus *event __attribute((unused)), |
1132 |
|
jobject peer) |
1133 |
|
{ |
1134 |
|
gdk_threads_leave (); |
1135 |
|
|
1136 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, |
1137 |
|
postFocusEventID, |
1138 |
|
AWT_FOCUS_GAINED, |
1139 |
|
JNI_FALSE); |
1140 |
|
|
1141 |
|
gdk_threads_enter (); |
1142 |
|
|
1143 |
|
return FALSE; |
1144 |
|
} |
1145 |
|
|
1146 |
|
static gboolean |
1147 |
|
component_focus_out_cb (GtkWidget *widget __attribute((unused)), |
1148 |
|
GdkEventFocus *event __attribute((unused)), |
1149 |
|
jobject peer) |
1150 |
|
{ |
1151 |
|
gdk_threads_leave (); |
1152 |
|
|
1153 |
|
(*cp_gtk_gdk_env())->CallVoidMethod (cp_gtk_gdk_env(), peer, |
1154 |
|
postFocusEventID, |
1155 |
|
AWT_FOCUS_LOST, |
1156 |
|
JNI_FALSE); |
1157 |
|
|
1158 |
|
gdk_threads_enter (); |
1159 |
|
|
1160 |
|
return FALSE; |
1161 |
} |
} |