]> git.saurik.com Git - wxWidgets.git/blame - src/gtk/window.cpp
Correct measurement for owner drawn menu items with only unchecked bitmap.
[wxWidgets.git] / src / gtk / window.cpp
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
faa94f3e 2// Name: src/gtk/window.cpp
9a33c3ef 3// Purpose: wxWindowGTK implementation
c801d85f 4// Author: Robert Roebling
c67d8618 5// Id: $Id$
01111366 6// Copyright: (c) 1998 Robert Roebling, Julian Smart
65571936 7// Licence: wxWindows licence
c801d85f
KB
8/////////////////////////////////////////////////////////////////////////////
9
14f355c2
VS
10// For compilers that support precompilation, includes "wx.h".
11#include "wx/wxprec.h"
12
d02af7bb
JJ
13#ifdef __VMS
14#define XWarpPointer XWARPPOINTER
15#endif
16
c801d85f 17#include "wx/window.h"
88a7a4e1
WS
18
19#ifndef WX_PRECOMP
e4db172a 20 #include "wx/log.h"
670f9935 21 #include "wx/app.h"
cca410b3 22 #include "wx/toplevel.h"
ed4b0fdc 23 #include "wx/dcclient.h"
3b3dc801 24 #include "wx/menu.h"
9eddec69 25 #include "wx/settings.h"
246c5004 26 #include "wx/msgdlg.h"
18680f86 27 #include "wx/math.h"
88a7a4e1
WS
28#endif
29
bfeeb7f3
PC
30#include "wx/dnd.h"
31#include "wx/tooltip.h"
32#include "wx/caret.h"
48d011c8 33#include "wx/fontutil.h"
8ab7b4c5 34#include "wx/sysopt.h"
b4071e91 35
fab591c5 36#include <ctype.h>
c801d85f 37
9e691f46 38#include "wx/gtk/private.h"
bbd92d1d 39#include "wx/gtk/private/win_gtk.h"
3ac8d3bc 40#include <gdk/gdkkeysyms.h>
3ac8d3bc 41#include <gdk/gdkx.h>
6bc8a1c8 42
87ec008f
VS
43#if !GTK_CHECK_VERSION(2,10,0)
44 // GTK+ can reliably detect Meta key state only since 2.10 when
45 // GDK_META_MASK was introduced -- there wasn't any way to detect it
46 // in older versions. wxGTK used GDK_MOD2_MASK for this purpose, but
47 // GDK_MOD2_MASK is documented as:
48 //
49 // the fifth modifier key (it depends on the modifier mapping of the X
50 // server which key is interpreted as this modifier)
51 //
52 // In other words, it isn't guaranteed to map to Meta. This is a real
53 // problem: it is common to map NumLock to it (in fact, it's an exception
54 // if the X server _doesn't_ use it for NumLock). So the old code caused
55 // wxKeyEvent::MetaDown() to always return true as long as NumLock was on
56 // on many systems, which broke all applications using
57 // wxKeyEvent::GetModifiers() to check modifiers state (see e.g. here:
58 // http://tinyurl.com/56lsk2).
59 //
60 // Because of this, it's better to not detect Meta key state at all than
61 // to detect it incorrectly. Hence the following #define, which causes
62 // m_metaDown to be always set to false.
63 #define GDK_META_MASK 0
64#endif
65
868a2826
RR
66//-----------------------------------------------------------------------------
67// documentation on internals
68//-----------------------------------------------------------------------------
69
70/*
71 I have been asked several times about writing some documentation about
77ffb593 72 the GTK port of wxWidgets, especially its internal structures. Obviously,
868a2826 73 you cannot understand wxGTK without knowing a little about the GTK, but
47d67540 74 some more information about what the wxWindow, which is the base class
868a2826 75 for all other window classes, does seems required as well.
47d67540 76
30760ce7
RR
77 I)
78
868a2826 79 What does wxWindow do? It contains the common interface for the following
e380f72b 80 jobs of its descendants:
47d67540 81
868a2826 82 1) Define the rudimentary behaviour common to all window classes, such as
e380f72b
RR
83 resizing, intercepting user input (so as to make it possible to use these
84 events for special purposes in a derived class), window names etc.
868a2826
RR
85
86 2) Provide the possibility to contain and manage children, if the derived
87 class is allowed to contain children, which holds true for those window
e380f72b 88 classes which do not display a native GTK widget. To name them, these
868a2826 89 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
47d67540 90 work classes are a special case and are handled a bit differently from
e380f72b 91 the rest. The same holds true for the wxNotebook class.
47d67540 92
868a2826
RR
93 3) Provide the possibility to draw into a client area of a window. This,
94 too, only holds true for classes that do not display a native GTK widget
95 as above.
47d67540 96
e380f72b
RR
97 4) Provide the entire mechanism for scrolling widgets. This actual inter-
98 face for this is usually in wxScrolledWindow, but the GTK implementation
868a2826 99 is in this class.
47d67540 100
868a2826
RR
101 5) A multitude of helper or extra methods for special purposes, such as
102 Drag'n'Drop, managing validators etc.
47d67540 103
30760ce7
RR
104 6) Display a border (sunken, raised, simple or none).
105
77ffb593 106 Normally one might expect, that one wxWidgets window would always correspond
6a17b868 107 to one GTK widget. Under GTK, there is no such all-round widget that has all
868a2826
RR
108 the functionality. Moreover, the GTK defines a client area as a different
109 widget from the actual widget you are handling. Last but not least some
110 special classes (e.g. wxFrame) handle different categories of widgets and
111 still have the possibility to draw something in the client area.
112 It was therefore required to write a special purpose GTK widget, that would
77ffb593 113 represent a client area in the sense of wxWidgets capable to do the jobs
868a2826
RR
114 2), 3) and 4). I have written this class and it resides in win_gtk.c of
115 this directory.
47d67540 116
868a2826 117 All windows must have a widget, with which they interact with other under-
e380f72b 118 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
90e572f1 119 the wxWindow class has a member variable called m_widget which holds a
e380f72b
RR
120 pointer to this widget. When the window class represents a GTK native widget,
121 this is (in most cases) the only GTK widget the class manages. E.g. the
f8e045e2 122 wxStaticText class handles only a GtkLabel widget a pointer to which you
e380f72b 123 can find in m_widget (defined in wxWindow)
8bbe427f 124
e380f72b 125 When the class has a client area for drawing into and for containing children
08f53168
PC
126 it has to handle the client area widget (of the type wxPizza, defined in
127 win_gtk.cpp), but there could be any number of widgets, handled by a class.
8bbe427f
VZ
128 The common rule for all windows is only, that the widget that interacts with
129 the rest of GTK must be referenced in m_widget and all other widgets must be
130 children of this widget on the GTK level. The top-most widget, which also
131 represents the client area, must be in the m_wxwindow field and must be of
08f53168 132 the type wxPizza.
47d67540 133
868a2826
RR
134 As I said, the window classes that display a GTK native widget only have
135 one widget, so in the case of e.g. the wxButton class m_widget holds a
136 pointer to a GtkButton widget. But windows with client areas (for drawing
137 and children) have a m_widget field that is a pointer to a GtkScrolled-
08f53168 138 Window and a m_wxwindow field that is pointer to a wxPizza and this
868a2826 139 one is (in the GTK sense) a child of the GtkScrolledWindow.
47d67540 140
868a2826 141 If the m_wxwindow field is set, then all input to this widget is inter-
77ffb593 142 cepted and sent to the wxWidgets class. If not, all input to the widget
868a2826 143 that gets pointed to by m_widget gets intercepted and sent to the class.
148cd9b6 144
30760ce7 145 II)
148cd9b6 146
77ffb593 147 The design of scrolling in wxWidgets is markedly different from that offered
30760ce7
RR
148 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
149 clicking on a scrollbar belonging to scrolled window will inevitably move
77ffb593 150 the window. In wxWidgets, the scrollbar will only emit an event, send this
30760ce7 151 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
08f53168 152 which actually moves the window and its sub-windows. Note that wxPizza
77ffb593 153 memorizes how much it has been scrolled but that wxWidgets forgets this
30760ce7 154 so that the two coordinates systems have to be kept in synch. This is done
08f53168 155 in various places using the pizza->m_scroll_x and pizza->m_scroll_y values.
148cd9b6
VZ
156
157 III)
158
6a17b868 159 Singularly the most broken code in GTK is the code that is supposed to
30760ce7
RR
160 inform subwindows (child windows) about new positions. Very often, duplicate
161 events are sent without changes in size or position, equally often no
162 events are sent at all (All this is due to a bug in the GtkContainer code
163 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
164 GTK's own system and it simply waits for size events for toplevel windows
165 and then iterates down the respective size events to all window. This has
90e572f1 166 the disadvantage that windows might get size events before the GTK widget
30760ce7 167 actually has the reported size. This doesn't normally pose any problem, but
90e572f1 168 the OpenGL drawing routines rely on correct behaviour. Therefore, I have
30760ce7
RR
169 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
170 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
90e572f1 171 window that is used for OpenGL output really has that size (as reported by
30760ce7
RR
172 GTK).
173
174 IV)
148cd9b6 175
30760ce7 176 If someone at some point of time feels the immense desire to have a look at,
90e572f1
MR
177 change or attempt to optimise the Refresh() logic, this person will need an
178 intimate understanding of what "draw" and "expose" events are and what
179 they are used for, in particular when used in connection with GTK's
30760ce7 180 own windowless widgets. Beware.
148cd9b6 181
30760ce7 182 V)
148cd9b6 183
30760ce7
RR
184 Cursors, too, have been a constant source of pleasure. The main difficulty
185 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
c2246a38
RR
186 for the parent. To prevent this from doing too much harm, SetCursor calls
187 GTKUpdateCursor, which will recursively re-set the cursors of all child windows.
30760ce7
RR
188 Also don't forget that cursors (like much else) are connected to GdkWindows,
189 not GtkWidgets and that the "window" field of a GtkWidget might very well
90e572f1 190 point to the GdkWindow of the parent widget (-> "window-less widget") and
30760ce7 191 that the two obviously have very different meanings.
868a2826
RR
192*/
193
f03fc89f
VZ
194//-----------------------------------------------------------------------------
195// data
196//-----------------------------------------------------------------------------
197
b541538f
PC
198// Don't allow event propagation during drag
199bool g_blockEventsOnDrag;
200// Don't allow mouse event propagation during scroll
201bool g_blockEventsOnScroll;
238d735d 202extern wxCursor g_globalCursor;
f68586e5 203
1e6feb95
VZ
204// mouse capture state: the window which has it and if the mouse is currently
205// inside it
d3b9f782 206static wxWindowGTK *g_captureWindow = NULL;
0a164d4c 207static bool g_captureWindowHasMouse = false;
1e6feb95 208
22f43cb5
VS
209// The window that currently has focus:
210static wxWindowGTK *gs_currentFocus = NULL;
211// The window that is scheduled to get focus in the next event loop iteration
212// or NULL if there's no pending focus change:
213static wxWindowGTK *gs_pendingFocus = NULL;
1e6feb95 214
bd2e08d0
VS
215// the window that has deferred focus-out event pending, if any (see
216// GTKAddDeferredFocusOut() for details)
217static wxWindowGTK *gs_deferredFocusOut = NULL;
d7fa7eaa 218
5e513780
RR
219// global variables because GTK+ DnD want to have the
220// mouse event that caused it
d3b9f782 221GdkEvent *g_lastMouseEvent = NULL;
5e513780 222int g_lastButtonNumber = 0;
8f9850dd 223
2e563988
RR
224//-----------------------------------------------------------------------------
225// debug
226//-----------------------------------------------------------------------------
227
6cad4f1b 228// the trace mask used for the focus debugging messages
9a83f860 229#define TRACE_FOCUS wxT("focus")
6cad4f1b 230
85eb36c2
RR
231//-----------------------------------------------------------------------------
232// missing gdk functions
233//-----------------------------------------------------------------------------
234
235void
236gdk_window_warp_pointer (GdkWindow *window,
c50f1fb9
VZ
237 gint x,
238 gint y)
85eb36c2 239{
85eb36c2 240 if (!window)
2454dc8a 241 window = gdk_get_default_root_window();
c50f1fb9 242
dd00f3f6
OK
243 if (!GDK_WINDOW_DESTROYED(window))
244 {
245 XWarpPointer (GDK_WINDOW_XDISPLAY(window),
246 None, /* not source window -> move from anywhere */
247 GDK_WINDOW_XID(window), /* dest window */
248 0, 0, 0, 0, /* not source window -> move from anywhere */
249 x, y );
250 }
85eb36c2
RR
251}
252
f6bcfd97 253
47c93b63
RR
254//-----------------------------------------------------------------------------
255// "size_request" of m_widget
256//-----------------------------------------------------------------------------
257
865bb325 258extern "C" {
9800347d
FM
259static void
260wxgtk_window_size_request_callback(GtkWidget * WXUNUSED(widget),
261 GtkRequisition *requisition,
262 wxWindow * win)
47c93b63 263{
e1f448ee 264 int w, h;
47c93b63 265 win->GetSize( &w, &h );
e1f448ee
VZ
266 if (w < 2)
267 w = 2;
268 if (h < 2)
269 h = 2;
1e6feb95 270
47c93b63
RR
271 requisition->height = h;
272 requisition->width = w;
273}
865bb325 274}
47c93b63 275
c801d85f 276//-----------------------------------------------------------------------------
034be888 277// "expose_event" of m_wxwindow
c801d85f
KB
278//-----------------------------------------------------------------------------
279
865bb325 280extern "C" {
7f7beb1d 281static gboolean
f089940f 282gtk_window_expose_callback( GtkWidget*,
7f7beb1d
MR
283 GdkEventExpose *gdk_event,
284 wxWindow *win )
47d67540 285{
f089940f 286 if (gdk_event->window == win->GTKGetDrawingWindow())
3d2d8da1 287 {
8d49fda6
PC
288 win->GetUpdateRegion() = wxRegion( gdk_event->region );
289 win->GtkSendPaintEvents();
3d2d8da1 290 }
90e572f1 291 // Let parent window draw window-less widgets
2109c024 292 return FALSE;
b6fa52db 293}
865bb325 294}
b6fa52db 295
75f661bb 296#ifndef __WXUNIVERSAL__
08f53168 297//-----------------------------------------------------------------------------
75f661bb 298// "expose_event" from m_wxwindow->parent, for drawing border
08f53168
PC
299//-----------------------------------------------------------------------------
300
08f53168
PC
301extern "C" {
302static gboolean
6de67633 303expose_event_border(GtkWidget* widget, GdkEventExpose* gdk_event, wxWindow* win)
08f53168 304{
f089940f 305 if (gdk_event->window != gtk_widget_get_parent_window(win->m_wxwindow))
75f661bb
PC
306 return false;
307
6e7cf3bd
PC
308 if (!win->IsShown())
309 return false;
310
75f661bb
PC
311 const GtkAllocation& alloc = win->m_wxwindow->allocation;
312 const int x = alloc.x;
313 const int y = alloc.y;
314 const int w = alloc.width;
315 const int h = alloc.height;
316
317 if (w <= 0 || h <= 0)
08f53168
PC
318 return false;
319
08f53168
PC
320 if (win->HasFlag(wxBORDER_SIMPLE))
321 {
830910cc
PC
322 gdk_draw_rectangle(gdk_event->window,
323 widget->style->black_gc, false, x, y, w - 1, h - 1);
08f53168
PC
324 }
325 else
326 {
327 GtkShadowType shadow = GTK_SHADOW_IN;
328 if (win->HasFlag(wxBORDER_RAISED))
329 shadow = GTK_SHADOW_OUT;
03eaa52a
PC
330
331 // Style detail to use
332 const char* detail;
75f661bb 333 if (win->m_widget == win->m_wxwindow)
03eaa52a
PC
334 // for non-scrollable wxWindows
335 detail = "entry";
336 else
337 // for scrollable ones
338 detail = "viewport";
339
08f53168 340 gtk_paint_shadow(
830910cc
PC
341 win->m_wxwindow->style, gdk_event->window, GTK_STATE_NORMAL,
342 shadow, NULL, wxGTKPrivate::GetEntryWidget(), detail, x, y, w, h);
08f53168 343 }
75f661bb
PC
344 return false;
345}
346}
347
348//-----------------------------------------------------------------------------
349// "parent_set" from m_wxwindow
350//-----------------------------------------------------------------------------
08f53168 351
75f661bb
PC
352extern "C" {
353static void
354parent_set(GtkWidget* widget, GtkObject* old_parent, wxWindow* win)
355{
356 if (old_parent)
357 {
358 g_signal_handlers_disconnect_by_func(
359 old_parent, (void*)expose_event_border, win);
360 }
361 if (widget->parent)
362 {
363 g_signal_connect_after(widget->parent, "expose_event",
364 G_CALLBACK(expose_event_border), win);
365 }
08f53168
PC
366}
367}
368#endif // !__WXUNIVERSAL__
369
c801d85f 370//-----------------------------------------------------------------------------
b292e2f5 371// "key_press_event" from any window
c801d85f 372//-----------------------------------------------------------------------------
c801d85f 373
7da1b5f9
RD
374// These are used when transforming Ctrl-alpha to ascii values 1-26
375inline bool wxIsLowerChar(int code)
376{
377 return (code >= 'a' && code <= 'z' );
378}
379
380inline bool wxIsUpperChar(int code)
381{
382 return (code >= 'A' && code <= 'Z' );
383}
384
385
74710601 386// set WXTRACE to this to see the key event codes on the console
9a83f860 387#define TRACE_KEYS wxT("keyevent")
f17393f1 388
1c6896d7
VZ
389// translates an X key symbol to WXK_XXX value
390//
391// if isChar is true it means that the value returned will be used for EVT_CHAR
392// event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
393// for example, while if it is false it means that the value is going to be
394// used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
395// WXK_NUMPAD_DIVIDE
396static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
397{
398 long key_code;
399
400 switch ( keysym )
401 {
402 // Shift, Control and Alt don't generate the CHAR events at all
403 case GDK_Shift_L:
404 case GDK_Shift_R:
405 key_code = isChar ? 0 : WXK_SHIFT;
406 break;
407 case GDK_Control_L:
408 case GDK_Control_R:
409 key_code = isChar ? 0 : WXK_CONTROL;
410 break;
411 case GDK_Meta_L:
412 case GDK_Meta_R:
413 case GDK_Alt_L:
414 case GDK_Alt_R:
415 case GDK_Super_L:
416 case GDK_Super_R:
417 key_code = isChar ? 0 : WXK_ALT;
418 break;
419
420 // neither do the toggle modifies
421 case GDK_Scroll_Lock:
422 key_code = isChar ? 0 : WXK_SCROLL;
423 break;
424
425 case GDK_Caps_Lock:
426 key_code = isChar ? 0 : WXK_CAPITAL;
427 break;
428
429 case GDK_Num_Lock:
430 key_code = isChar ? 0 : WXK_NUMLOCK;
431 break;
432
433
434 // various other special keys
435 case GDK_Menu:
436 key_code = WXK_MENU;
437 break;
438
439 case GDK_Help:
440 key_code = WXK_HELP;
441 break;
442
443 case GDK_BackSpace:
444 key_code = WXK_BACK;
445 break;
446
447 case GDK_ISO_Left_Tab:
448 case GDK_Tab:
449 key_code = WXK_TAB;
450 break;
451
452 case GDK_Linefeed:
453 case GDK_Return:
454 key_code = WXK_RETURN;
455 break;
456
457 case GDK_Clear:
458 key_code = WXK_CLEAR;
459 break;
460
461 case GDK_Pause:
462 key_code = WXK_PAUSE;
463 break;
464
465 case GDK_Select:
466 key_code = WXK_SELECT;
467 break;
468
469 case GDK_Print:
470 key_code = WXK_PRINT;
471 break;
472
473 case GDK_Execute:
474 key_code = WXK_EXECUTE;
475 break;
476
477 case GDK_Escape:
478 key_code = WXK_ESCAPE;
479 break;
480
481 // cursor and other extended keyboard keys
482 case GDK_Delete:
483 key_code = WXK_DELETE;
484 break;
485
486 case GDK_Home:
487 key_code = WXK_HOME;
488 break;
489
490 case GDK_Left:
491 key_code = WXK_LEFT;
492 break;
493
494 case GDK_Up:
495 key_code = WXK_UP;
496 break;
497
498 case GDK_Right:
499 key_code = WXK_RIGHT;
500 break;
501
502 case GDK_Down:
503 key_code = WXK_DOWN;
504 break;
505
506 case GDK_Prior: // == GDK_Page_Up
faa94f3e 507 key_code = WXK_PAGEUP;
1c6896d7
VZ
508 break;
509
510 case GDK_Next: // == GDK_Page_Down
faa94f3e 511 key_code = WXK_PAGEDOWN;
1c6896d7
VZ
512 break;
513
514 case GDK_End:
515 key_code = WXK_END;
516 break;
517
518 case GDK_Begin:
519 key_code = WXK_HOME;
520 break;
521
522 case GDK_Insert:
523 key_code = WXK_INSERT;
524 break;
525
526
527 // numpad keys
528 case GDK_KP_0:
529 case GDK_KP_1:
530 case GDK_KP_2:
531 case GDK_KP_3:
532 case GDK_KP_4:
533 case GDK_KP_5:
534 case GDK_KP_6:
535 case GDK_KP_7:
536 case GDK_KP_8:
537 case GDK_KP_9:
2a230426 538 key_code = (isChar ? '0' : int(WXK_NUMPAD0)) + keysym - GDK_KP_0;
1c6896d7
VZ
539 break;
540
541 case GDK_KP_Space:
2a230426 542 key_code = isChar ? ' ' : int(WXK_NUMPAD_SPACE);
1c6896d7
VZ
543 break;
544
545 case GDK_KP_Tab:
546 key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
547 break;
548
549 case GDK_KP_Enter:
550 key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
551 break;
552
553 case GDK_KP_F1:
554 key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
555 break;
556
557 case GDK_KP_F2:
558 key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
559 break;
560
561 case GDK_KP_F3:
562 key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
563 break;
564
565 case GDK_KP_F4:
566 key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
567 break;
568
569 case GDK_KP_Home:
570 key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
571 break;
572
573 case GDK_KP_Left:
574 key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
575 break;
576
577 case GDK_KP_Up:
578 key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
579 break;
580
581 case GDK_KP_Right:
582 key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
583 break;
584
585 case GDK_KP_Down:
586 key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
587 break;
588
589 case GDK_KP_Prior: // == GDK_KP_Page_Up
faa94f3e 590 key_code = isChar ? WXK_PAGEUP : WXK_NUMPAD_PAGEUP;
1c6896d7
VZ
591 break;
592
593 case GDK_KP_Next: // == GDK_KP_Page_Down
faa94f3e 594 key_code = isChar ? WXK_PAGEDOWN : WXK_NUMPAD_PAGEDOWN;
1c6896d7
VZ
595 break;
596
597 case GDK_KP_End:
598 key_code = isChar ? WXK_END : WXK_NUMPAD_END;
599 break;
600
601 case GDK_KP_Begin:
602 key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
603 break;
604
605 case GDK_KP_Insert:
606 key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
607 break;
608
609 case GDK_KP_Delete:
610 key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
611 break;
612
613 case GDK_KP_Equal:
2a230426 614 key_code = isChar ? '=' : int(WXK_NUMPAD_EQUAL);
1c6896d7
VZ
615 break;
616
617 case GDK_KP_Multiply:
2a230426 618 key_code = isChar ? '*' : int(WXK_NUMPAD_MULTIPLY);
1c6896d7
VZ
619 break;
620
621 case GDK_KP_Add:
2a230426 622 key_code = isChar ? '+' : int(WXK_NUMPAD_ADD);
1c6896d7
VZ
623 break;
624
625 case GDK_KP_Separator:
626 // FIXME: what is this?
2a230426 627 key_code = isChar ? '.' : int(WXK_NUMPAD_SEPARATOR);
1c6896d7
VZ
628 break;
629
630 case GDK_KP_Subtract:
2a230426 631 key_code = isChar ? '-' : int(WXK_NUMPAD_SUBTRACT);
1c6896d7
VZ
632 break;
633
634 case GDK_KP_Decimal:
2a230426 635 key_code = isChar ? '.' : int(WXK_NUMPAD_DECIMAL);
1c6896d7
VZ
636 break;
637
638 case GDK_KP_Divide:
2a230426 639 key_code = isChar ? '/' : int(WXK_NUMPAD_DIVIDE);
1c6896d7
VZ
640 break;
641
642
643 // function keys
644 case GDK_F1:
645 case GDK_F2:
646 case GDK_F3:
647 case GDK_F4:
648 case GDK_F5:
649 case GDK_F6:
650 case GDK_F7:
651 case GDK_F8:
652 case GDK_F9:
653 case GDK_F10:
654 case GDK_F11:
655 case GDK_F12:
656 key_code = WXK_F1 + keysym - GDK_F1;
657 break;
658
659 default:
660 key_code = 0;
661 }
662
663 return key_code;
664}
665
666static inline bool wxIsAsciiKeysym(KeySym ks)
667{
668 return ks < 256;
669}
670
a3c15d89
VS
671static void wxFillOtherKeyEventFields(wxKeyEvent& event,
672 wxWindowGTK *win,
673 GdkEventKey *gdk_event)
674{
675 int x = 0;
676 int y = 0;
677 GdkModifierType state;
678 if (gdk_event->window)
679 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
680
681 event.SetTimestamp( gdk_event->time );
cfa8c7d6 682 event.SetId(win->GetId());
d0fb62a6 683
a3c15d89
VS
684 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
685 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
686 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
87ec008f 687 event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0;
d0fb62a6
VZ
688
689 // Normally we take the state of modifiers directly from the low level GDK
690 // event but unfortunately GDK uses a different convention from MSW for the
691 // key events corresponding to the modifier keys themselves: in it, when
692 // e.g. Shift key is pressed, GDK_SHIFT_MASK is not set while it is set
693 // when Shift is released. Under MSW the situation is exactly reversed and
694 // the modifier corresponding to the key is set when it is pressed and
695 // unset when it is released. To ensure consistent behaviour between
696 // platforms (and because it seems to make slightly more sense, although
697 // arguably both behaviours are reasonable) we follow MSW here.
698 //
699 // Final notice: we set the flags to the desired value instead of just
700 // inverting them because they are not set correctly (i.e. in the same way
701 // as for the real events generated by the user) for wxUIActionSimulator-
702 // produced events and it seems better to keep that class code the same
703 // among all platforms and fix the discrepancy here instead of adding
704 // wxGTK-specific code to wxUIActionSimulator.
705 const bool isPress = gdk_event->type == GDK_KEY_PRESS;
706 switch ( gdk_event->keyval )
707 {
708 case GDK_Shift_L:
709 case GDK_Shift_R:
710 event.m_shiftDown = isPress;
711 break;
712
713 case GDK_Control_L:
714 case GDK_Control_R:
715 event.m_controlDown = isPress;
716 break;
717
718 case GDK_Alt_L:
719 case GDK_Alt_R:
720 event.m_altDown = isPress;
721 break;
722
723 case GDK_Meta_L:
724 case GDK_Meta_R:
725 case GDK_Super_L:
726 case GDK_Super_R:
727 event.m_metaDown = isPress;
728 break;
729 }
730
a3c15d89 731 event.m_rawCode = (wxUint32) gdk_event->keyval;
5995a84f 732 event.m_rawFlags = gdk_event->hardware_keycode;
d0fb62a6 733
c958d025
RR
734 wxGetMousePosition( &x, &y );
735 win->ScreenToClient( &x, &y );
a3c15d89
VS
736 event.m_x = x;
737 event.m_y = y;
738 event.SetEventObject( win );
739}
740
741
74710601
VZ
742static bool
743wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
744 wxWindowGTK *win,
745 GdkEventKey *gdk_event)
47d67540 746{
1c6896d7
VZ
747 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
748 // but only event->keyval which is quite useless to us, so remember
749 // the last character from GDK_KEY_PRESS and reuse it as last resort
750 //
751 // NB: should be MT-safe as we're always called from the main thread only
752 static struct
753 {
754 KeySym keysym;
755 long keycode;
756 } s_lastKeyPress = { 0, 0 };
757
758 KeySym keysym = gdk_event->keyval;
0a62b197 759
9a83f860
VZ
760 wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %ld"),
761 event.GetEventType() == wxEVT_KEY_UP ? wxT("release")
762 : wxT("press"),
0a62b197
VZ
763 keysym);
764
0a164d4c 765 long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */);
1c6896d7
VZ
766
767 if ( !key_code )
768 {
769 // do we have the translation or is it a plain ASCII character?
770 if ( (gdk_event->length == 1) || wxIsAsciiKeysym(keysym) )
771 {
772 // we should use keysym if it is ASCII as X does some translations
773 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
774 // which we don't want here (but which we do use for OnChar())
775 if ( !wxIsAsciiKeysym(keysym) )
776 {
777 keysym = (KeySym)gdk_event->string[0];
778 }
a2053b27 779
1c6896d7 780 // we want to always get the same key code when the same key is
90e572f1 781 // pressed regardless of the state of the modifiers, i.e. on a
1c6896d7
VZ
782 // standard US keyboard pressing '5' or '%' ('5' key with
783 // Shift) should result in the same key code in OnKeyDown():
784 // '5' (although OnChar() will get either '5' or '%').
785 //
786 // to do it we first translate keysym to keycode (== scan code)
787 // and then back but always using the lower register
788 Display *dpy = (Display *)wxGetDisplay();
789 KeyCode keycode = XKeysymToKeycode(dpy, keysym);
0a62b197 790
9a83f860 791 wxLogTrace(TRACE_KEYS, wxT("\t-> keycode %d"), keycode);
0a62b197 792
1c6896d7
VZ
793 KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
794
795 // use the normalized, i.e. lower register, keysym if we've
796 // got one
797 key_code = keysymNormalized ? keysymNormalized : keysym;
798
799 // as explained above, we want to have lower register key codes
800 // normally but for the letter keys we want to have the upper ones
801 //
802 // NB: don't use XConvertCase() here, we want to do it for letters
803 // only
804 key_code = toupper(key_code);
805 }
806 else // non ASCII key, what to do?
807 {
808 // by default, ignore it
809 key_code = 0;
810
811 // but if we have cached information from the last KEY_PRESS
812 if ( gdk_event->type == GDK_KEY_RELEASE )
813 {
814 // then reuse it
815 if ( keysym == s_lastKeyPress.keysym )
816 {
817 key_code = s_lastKeyPress.keycode;
818 }
819 }
820 }
821
822 if ( gdk_event->type == GDK_KEY_PRESS )
823 {
824 // remember it to be reused for KEY_UP event later
825 s_lastKeyPress.keysym = keysym;
826 s_lastKeyPress.keycode = key_code;
827 }
828 }
829
9a83f860 830 wxLogTrace(TRACE_KEYS, wxT("\t-> wxKeyCode %ld"), key_code);
c801d85f 831
74710601 832 // sending unknown key events doesn't really make sense
1c6896d7 833 if ( !key_code )
0a164d4c 834 return false;
3d6f7261 835
276f883f
VZ
836 event.m_keyCode = key_code;
837
7333c0ef
VZ
838#if wxUSE_UNICODE
839 event.m_uniChar = gdk_keyval_to_unicode(key_code ? key_code : keysym);
840 if ( !event.m_uniChar && event.m_keyCode <= WXK_DELETE )
841 {
842 // Set Unicode key code to the ASCII equivalent for compatibility. E.g.
843 // let RETURN generate the key event with both key and Unicode key
844 // codes of 13.
845 event.m_uniChar = event.m_keyCode;
846 }
847#endif // wxUSE_UNICODE
848
1c6896d7 849 // now fill all the other fields
a3c15d89 850 wxFillOtherKeyEventFields(event, win, gdk_event);
0a164d4c 851
0a164d4c 852 return true;
74710601
VZ
853}
854
7c5e6fc6 855
a3c15d89
VS
856struct wxGtkIMData
857{
858 GtkIMContext *context;
859 GdkEventKey *lastKeyEvent;
860
861 wxGtkIMData()
862 {
863 context = gtk_im_multicontext_new();
864 lastKeyEvent = NULL;
865 }
866 ~wxGtkIMData()
867 {
3fe39b0c 868 g_object_unref (context);
a3c15d89
VS
869 }
870};
a3c15d89 871
2933f70a
VZ
872namespace
873{
874
875// Send wxEVT_CHAR_HOOK event to the parent of the window and if it wasn't
876// processed, send wxEVT_CHAR to the window itself. Return true if either of
877// them was handled.
878bool
879SendCharHookAndCharEvents(const wxKeyEvent& event, wxWindow *win)
880{
881 // wxEVT_CHAR_HOOK must be sent to the top level parent window to allow it
882 // to handle key events in all of its children.
883 wxWindow * const parent = wxGetTopLevelParent(win);
884 if ( parent )
885 {
886 // We need to make a copy of the event object because it is
887 // modified while it's handled, notably its WasProcessed() flag
888 // is set after it had been processed once.
889 wxKeyEvent eventCharHook(event);
890 eventCharHook.SetEventType(wxEVT_CHAR_HOOK);
891 if ( parent->HandleWindowEvent(eventCharHook) )
892 return true;
893 }
894
895 // As above, make a copy of the event first.
896 wxKeyEvent eventChar(event);
897 eventChar.SetEventType(wxEVT_CHAR);
898 return win->HandleWindowEvent(eventChar);
899}
900
901} // anonymous namespace
902
865bb325 903extern "C" {
7f7beb1d 904static gboolean
3591d10f 905gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget),
7f7beb1d
MR
906 GdkEventKey *gdk_event,
907 wxWindow *win )
74710601 908{
1c6896d7
VZ
909 if (!win->m_hasVMT)
910 return FALSE;
911 if (g_blockEventsOnDrag)
912 return FALSE;
f1272160 913
f1272160
RR
914 wxKeyEvent event( wxEVT_KEY_DOWN );
915 bool ret = false;
916 bool return_after_IM = false;
917
84dc821c
JS
918 if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
919 {
920 // Emit KEY_DOWN event
937013e0 921 ret = win->HandleWindowEvent( event );
84dc821c
JS
922 }
923 else
f1272160
RR
924 {
925 // Return after IM processing as we cannot do
926 // anything with it anyhow.
927 return_after_IM = true;
928 }
929
9cbe96d0 930 if (!ret && win->m_imData)
f6fca1f8 931 {
9cbe96d0
VZ
932 win->m_imData->lastKeyEvent = gdk_event;
933
f1272160
RR
934 // We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
935 // docs, if IM filter returns true, no further processing should be done.
0a164d4c 936 // we should send the key_down event anyway.
f1272160 937 bool intercepted_by_IM = gtk_im_context_filter_keypress(win->m_imData->context, gdk_event);
f6fca1f8 938 win->m_imData->lastKeyEvent = NULL;
f1272160
RR
939 if (intercepted_by_IM)
940 {
9a83f860 941 wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
7f7beb1d 942 return TRUE;
f1272160 943 }
f6fca1f8 944 }
68567a96 945
f1272160 946 if (return_after_IM)
7f7beb1d 947 return FALSE;
68567a96 948
50b58dec
RD
949#if wxUSE_ACCEL
950 if (!ret)
951 {
952 wxWindowGTK *ancestor = win;
953 while (ancestor)
954 {
955 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
956 if (command != -1)
957 {
b1bb04c5
VS
958 wxCommandEvent menu_event( wxEVT_COMMAND_MENU_SELECTED, command );
959 ret = ancestor->HandleWindowEvent( menu_event );
960
961 if ( !ret )
962 {
963 // if the accelerator wasn't handled as menu event, try
964 // it as button click (for compatibility with other
965 // platforms):
966 wxCommandEvent button_event( wxEVT_COMMAND_BUTTON_CLICKED, command );
967 ret = ancestor->HandleWindowEvent( button_event );
968 }
969
50b58dec
RD
970 break;
971 }
972 if (ancestor->IsTopLevel())
973 break;
974 ancestor = ancestor->GetParent();
975 }
976 }
977#endif // wxUSE_ACCEL
978
1ec3a984
RR
979 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
980 // will only be sent if it is not in an accelerator table.
2dde25b9 981 if (!ret)
d728dd40 982 {
7c5e6fc6 983 long key_code;
1c6896d7 984 KeySym keysym = gdk_event->keyval;
36025bcc 985 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
0a164d4c 986 key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);
36025bcc 987 if ( !key_code )
1c6896d7 988 {
0b187670 989 if ( wxIsAsciiKeysym(keysym) )
1ec3a984 990 {
36025bcc
VS
991 // ASCII key
992 key_code = (unsigned char)keysym;
993 }
0b187670
RR
994 // gdk_event->string is actually deprecated
995 else if ( gdk_event->length == 1 )
996 {
997 key_code = (unsigned char)gdk_event->string[0];
998 }
36025bcc 999 }
7c5e6fc6 1000
36025bcc
VS
1001 if ( key_code )
1002 {
9a83f860 1003 wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
7c5e6fc6 1004
36025bcc 1005 event.m_keyCode = key_code;
7c5e6fc6 1006
1dabdced
RD
1007 // To conform to the docs we need to translate Ctrl-alpha
1008 // characters to values in the range 1-26.
7da1b5f9
RD
1009 if ( event.ControlDown() &&
1010 ( wxIsLowerChar(key_code) || wxIsUpperChar(key_code) ))
1dabdced 1011 {
7da1b5f9
RD
1012 if ( wxIsLowerChar(key_code) )
1013 event.m_keyCode = key_code - 'a' + 1;
1014 if ( wxIsUpperChar(key_code) )
1015 event.m_keyCode = key_code - 'A' + 1;
1dabdced
RD
1016#if wxUSE_UNICODE
1017 event.m_uniChar = event.m_keyCode;
1018#endif
7f7beb1d 1019 }
1dabdced 1020
2933f70a 1021 ret = SendCharHookAndCharEvents(event, win);
f17393f1 1022 }
d728dd40 1023 }
4d3ab2a0 1024
c7b2e494 1025 return ret;
2b5f62a0 1026}
865bb325 1027}
2b5f62a0 1028
865bb325 1029extern "C" {
7f7beb1d 1030static void
e4161a2a 1031gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
7f7beb1d
MR
1032 const gchar *str,
1033 wxWindow *window)
2b5f62a0 1034{
2b5f62a0
VZ
1035 wxKeyEvent event( wxEVT_KEY_DOWN );
1036
a3c15d89
VS
1037 // take modifiers, cursor position, timestamp etc. from the last
1038 // key_press_event that was fed into Input Method:
1039 if (window->m_imData->lastKeyEvent)
1040 {
1041 wxFillOtherKeyEventFields(event,
1042 window, window->m_imData->lastKeyEvent);
1043 }
28c513cb
RR
1044 else
1045 {
1046 event.SetEventObject( window );
1047 }
a3c15d89 1048
6256849f
VS
1049 const wxString data(wxGTK_CONV_BACK_SYS(str));
1050 if( data.empty() )
5bfaca1b 1051 return;
7c5e6fc6 1052
6256849f 1053 for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )
7c5e6fc6 1054 {
5bfaca1b
VS
1055#if wxUSE_UNICODE
1056 event.m_uniChar = *pstr;
f6fca1f8 1057 // Backward compatible for ISO-8859-1
5bfaca1b 1058 event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
9a83f860 1059 wxLogTrace(TRACE_KEYS, wxT("IM sent character '%c'"), event.m_uniChar);
5bfaca1b 1060#else
6256849f 1061 event.m_keyCode = (char)*pstr;
5bfaca1b 1062#endif // wxUSE_UNICODE
1dabdced
RD
1063
1064 // To conform to the docs we need to translate Ctrl-alpha
1065 // characters to values in the range 1-26.
7da1b5f9
RD
1066 if ( event.ControlDown() &&
1067 ( wxIsLowerChar(*pstr) || wxIsUpperChar(*pstr) ))
1dabdced 1068 {
7da1b5f9
RD
1069 if ( wxIsLowerChar(*pstr) )
1070 event.m_keyCode = *pstr - 'a' + 1;
1071 if ( wxIsUpperChar(*pstr) )
1072 event.m_keyCode = *pstr - 'A' + 1;
1073
1dabdced
RD
1074 event.m_keyCode = *pstr - 'a' + 1;
1075#if wxUSE_UNICODE
1076 event.m_uniChar = event.m_keyCode;
7f7beb1d
MR
1077#endif
1078 }
1dabdced 1079
2933f70a 1080 SendCharHookAndCharEvents(event, window);
2b5f62a0
VZ
1081 }
1082}
865bb325 1083}
2b5f62a0
VZ
1084
1085
b666df2c
RR
1086//-----------------------------------------------------------------------------
1087// "key_release_event" from any window
1088//-----------------------------------------------------------------------------
1089
865bb325 1090extern "C" {
7f7beb1d 1091static gboolean
e4161a2a 1092gtk_window_key_release_callback( GtkWidget * WXUNUSED(widget),
7f7beb1d
MR
1093 GdkEventKey *gdk_event,
1094 wxWindowGTK *win )
b666df2c 1095{
74710601
VZ
1096 if (!win->m_hasVMT)
1097 return FALSE;
b666df2c 1098
74710601
VZ
1099 if (g_blockEventsOnDrag)
1100 return FALSE;
b666df2c
RR
1101
1102 wxKeyEvent event( wxEVT_KEY_UP );
74710601 1103 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
b666df2c 1104 {
90e572f1 1105 // unknown key pressed, ignore (the event would be useless anyhow)
74710601 1106 return FALSE;
b666df2c
RR
1107 }
1108
97687291 1109 return win->GTKProcessEvent(event);
b666df2c 1110}
865bb325 1111}
b666df2c 1112
c5f9d156
VS
1113// ============================================================================
1114// the mouse events
1115// ============================================================================
1116
d1f2ac45
VZ
1117// ----------------------------------------------------------------------------
1118// mouse event processing helpers
1119// ----------------------------------------------------------------------------
1120
50f00d0c
VS
1121// init wxMouseEvent with the info from GdkEventXXX struct
1122template<typename T> void InitMouseEvent(wxWindowGTK *win,
1123 wxMouseEvent& event,
1124 T *gdk_event)
1125{
1126 event.SetTimestamp( gdk_event->time );
c4021a79
PC
1127 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
1128 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
1129 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
1130 event.m_metaDown = (gdk_event->state & GDK_META_MASK) != 0;
1131 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK) != 0;
1132 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK) != 0;
1133 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK) != 0;
1134 event.m_aux1Down = (gdk_event->state & GDK_BUTTON4_MASK) != 0;
1135 event.m_aux2Down = (gdk_event->state & GDK_BUTTON5_MASK) != 0;
50f00d0c
VS
1136
1137 wxPoint pt = win->GetClientAreaOrigin();
1138 event.m_x = (wxCoord)gdk_event->x - pt.x;
1139 event.m_y = (wxCoord)gdk_event->y - pt.y;
fcb29b23 1140
847dfdb4 1141 if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft))
428f4657
RR
1142 {
1143 // origin in the upper right corner
08f53168 1144 int window_width = win->m_wxwindow->allocation.width;
720a0aab 1145 event.m_x = window_width - event.m_x;
428f4657 1146 }
50f00d0c
VS
1147
1148 event.SetEventObject( win );
1149 event.SetId( win->GetId() );
1150 event.SetTimestamp( gdk_event->time );
1151}
c5f9d156 1152
2daa0ce9
VZ
1153static void AdjustEventButtonState(wxMouseEvent& event)
1154{
1155 // GDK reports the old state of the button for a button press event, but
1156 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1157 // for a LEFT_DOWN event, not FALSE, so we will invert
1158 // left/right/middleDown for the corresponding click events
1e6feb95 1159
1a8caf94
RR
1160 if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1161 (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1162 (event.GetEventType() == wxEVT_LEFT_UP))
1163 {
1164 event.m_leftDown = !event.m_leftDown;
1165 return;
1166 }
1167
1168 if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1169 (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1170 (event.GetEventType() == wxEVT_MIDDLE_UP))
2daa0ce9 1171 {
1a8caf94
RR
1172 event.m_middleDown = !event.m_middleDown;
1173 return;
1174 }
1175
1176 if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1177 (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1178 (event.GetEventType() == wxEVT_RIGHT_UP))
1179 {
1180 event.m_rightDown = !event.m_rightDown;
1181 return;
2daa0ce9
VZ
1182 }
1183}
1184
d1f2ac45
VZ
1185// find the window to send the mouse event too
1186static
1187wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1188{
7d4909b2
RR
1189 wxCoord xx = x;
1190 wxCoord yy = y;
1191
d1f2ac45
VZ
1192 if (win->m_wxwindow)
1193 {
08f53168
PC
1194 wxPizza* pizza = WX_PIZZA(win->m_wxwindow);
1195 xx += pizza->m_scroll_x;
1196 yy += pizza->m_scroll_y;
d1f2ac45
VZ
1197 }
1198
222ed1d6 1199 wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
d1f2ac45
VZ
1200 while (node)
1201 {
b1d4dd7a 1202 wxWindowGTK *child = node->GetData();
d1f2ac45 1203
b1d4dd7a 1204 node = node->GetNext();
d1f2ac45
VZ
1205 if (!child->IsShown())
1206 continue;
1207
71ead4bf 1208 if (child->GTKIsTransparentForMouse())
d1f2ac45
VZ
1209 {
1210 // wxStaticBox is transparent in the box itself
1211 int xx1 = child->m_x;
1212 int yy1 = child->m_y;
1213 int xx2 = child->m_x + child->m_width;
7408cf7f 1214 int yy2 = child->m_y + child->m_height;
d1f2ac45
VZ
1215
1216 // left
7d4909b2 1217 if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
d1f2ac45 1218 // right
7d4909b2 1219 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
d1f2ac45 1220 // top
7d4909b2 1221 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
d1f2ac45 1222 // bottom
7d4909b2 1223 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
d1f2ac45
VZ
1224 {
1225 win = child;
1226 x -= child->m_x;
1227 y -= child->m_y;
1228 break;
1229 }
1230
1231 }
1232 else
1233 {
d3b9f782 1234 if ((child->m_wxwindow == NULL) &&
7d4909b2
RR
1235 (child->m_x <= xx) &&
1236 (child->m_y <= yy) &&
af3653dd
RR
1237 (child->m_x+child->m_width >= xx) &&
1238 (child->m_y+child->m_height >= yy))
d1f2ac45
VZ
1239 {
1240 win = child;
1241 x -= child->m_x;
1242 y -= child->m_y;
1243 break;
1244 }
1245 }
1246 }
1247
1248 return win;
1249}
1250
ef5c70f9
VZ
1251// ----------------------------------------------------------------------------
1252// common event handlers helpers
1253// ----------------------------------------------------------------------------
1254
97687291
VZ
1255bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
1256{
1257 // nothing special at this level
937013e0 1258 return HandleWindowEvent(event);
97687291
VZ
1259}
1260
02bad830
VZ
1261bool wxWindowGTK::GTKShouldIgnoreEvent() const
1262{
1263 return !m_hasVMT || g_blockEventsOnDrag;
1264}
1265
5478f221 1266int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
ef5c70f9 1267{
ef5c70f9 1268 if (!m_hasVMT)
5478f221 1269 return FALSE;
ef5c70f9 1270 if (g_blockEventsOnDrag)
5478f221 1271 return TRUE;
ef5c70f9 1272 if (g_blockEventsOnScroll)
5478f221 1273 return TRUE;
ef5c70f9
VZ
1274
1275 if (!GTKIsOwnWindow(event->window))
5478f221 1276 return FALSE;
ef5c70f9 1277
5478f221 1278 return -1;
ef5c70f9
VZ
1279}
1280
1281// overloads for all GDK event types we use here: we need to have this as
1282// GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
1283// derives from it in the sense that the structs have the same layout
1284#define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
5478f221 1285 static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
ef5c70f9
VZ
1286 { \
1287 return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
1288 }
1289
1290wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton)
1291wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion)
1292wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing)
1293
1294#undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
1295
5478f221
VZ
1296#define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
1297 const int rc = wxGtkCallbackCommonPrologue(event, win); \
1298 if ( rc != -1 ) \
1299 return rc
1300
ef5c70f9
VZ
1301// all event handlers must have C linkage as they're called from GTK+ C code
1302extern "C"
1303{
1304
c801d85f 1305//-----------------------------------------------------------------------------
2f2aa628
RR
1306// "button_press_event"
1307//-----------------------------------------------------------------------------
c801d85f 1308
7f7beb1d
MR
1309static gboolean
1310gtk_window_button_press_callback( GtkWidget *widget,
1311 GdkEventButton *gdk_event,
1312 wxWindowGTK *win )
903f689b 1313{
5478f221 1314 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
034be888 1315
8f9850dd
RR
1316 g_lastButtonNumber = gdk_event->button;
1317
90e572f1 1318 // GDK sends surplus button down events
2b5f62a0
VZ
1319 // before a double click event. We
1320 // need to filter these out.
1e89eecd 1321 if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow))
2b5f62a0
VZ
1322 {
1323 GdkEvent *peek_event = gdk_event_peek();
1324 if (peek_event)
1325 {
8b8a8e0e
RR
1326 if ((peek_event->type == GDK_2BUTTON_PRESS) ||
1327 (peek_event->type == GDK_3BUTTON_PRESS))
2b5f62a0
VZ
1328 {
1329 gdk_event_free( peek_event );
1330 return TRUE;
1331 }
1332 else
1333 {
1334 gdk_event_free( peek_event );
1335 }
1336 }
1337 }
1338
2daa0ce9 1339 wxEventType event_type = wxEVT_NULL;
47d67540 1340
15475ced
VZ
1341 if ( gdk_event->type == GDK_2BUTTON_PRESS &&
1342 gdk_event->button >= 1 && gdk_event->button <= 3 )
1343 {
1344 // Reset GDK internal timestamp variables in order to disable GDK
1345 // triple click events. GDK will then next time believe no button has
1346 // been clicked just before, and send a normal button click event.
1347 GdkDisplay* display = gtk_widget_get_display (widget);
1348 display->button_click_time[1] = 0;
1349 display->button_click_time[0] = 0;
1350 }
15475ced 1351
f5e27805 1352 if (gdk_event->button == 1)
c801d85f 1353 {
f3f0d961 1354 // note that GDK generates triple click events which are not supported
77ffb593 1355 // by wxWidgets but still have to be passed to the app as otherwise
f3f0d961 1356 // clicks would simply go missing
f5e27805
RR
1357 switch (gdk_event->type)
1358 {
15475ced
VZ
1359 // we shouldn't get triple clicks at all for GTK2 because we
1360 // suppress them artificially using the code above but we still
1361 // should map them to something for GTK1 and not just ignore them
1362 // as this would lose clicks
f3f0d961
VZ
1363 case GDK_3BUTTON_PRESS: // we could also map this to DCLICK...
1364 case GDK_BUTTON_PRESS:
1365 event_type = wxEVT_LEFT_DOWN;
1366 break;
1367
1368 case GDK_2BUTTON_PRESS:
1369 event_type = wxEVT_LEFT_DCLICK;
1370 break;
b1f50e65
VZ
1371
1372 default:
1373 // just to silence gcc warnings
1374 ;
f5e27805 1375 }
362c6693 1376 }
f5e27805 1377 else if (gdk_event->button == 2)
c801d85f 1378 {
f5e27805
RR
1379 switch (gdk_event->type)
1380 {
15475ced 1381 case GDK_3BUTTON_PRESS:
f3f0d961
VZ
1382 case GDK_BUTTON_PRESS:
1383 event_type = wxEVT_MIDDLE_DOWN;
1384 break;
1385
1386 case GDK_2BUTTON_PRESS:
1387 event_type = wxEVT_MIDDLE_DCLICK;
1388 break;
b1f50e65
VZ
1389
1390 default:
1391 ;
f5e27805 1392 }
362c6693 1393 }
f5e27805 1394 else if (gdk_event->button == 3)
c801d85f 1395 {
f5e27805
RR
1396 switch (gdk_event->type)
1397 {
15475ced 1398 case GDK_3BUTTON_PRESS:
f3f0d961
VZ
1399 case GDK_BUTTON_PRESS:
1400 event_type = wxEVT_RIGHT_DOWN;
1401 break;
1402
1403 case GDK_2BUTTON_PRESS:
1404 event_type = wxEVT_RIGHT_DCLICK;
1405 break;
b1f50e65
VZ
1406
1407 default:
1408 ;
2b5f62a0
VZ
1409 }
1410 }
47d67540 1411
2daa0ce9
VZ
1412 if ( event_type == wxEVT_NULL )
1413 {
1414 // unknown mouse button or click type
1415 return FALSE;
1416 }
1417
8f9850dd 1418 g_lastMouseEvent = (GdkEvent*) gdk_event;
fcb29b23 1419
f5e27805 1420 wxMouseEvent event( event_type );
c5f9d156 1421 InitMouseEvent( win, event, gdk_event );
47d67540 1422
2daa0ce9 1423 AdjustEventButtonState(event);
94633ad9 1424
90e572f1
MR
1425 // find the correct window to send the event to: it may be a different one
1426 // from the one which got it at GTK+ level because some controls don't have
d1f2ac45
VZ
1427 // their own X window and thus cannot get any events.
1428 if ( !g_captureWindow )
1429 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
ff8bfdbb 1430
ccb9fa0d
RD
1431 // reset the event object and id in case win changed.
1432 event.SetEventObject( win );
1433 event.SetId( win->GetId() );
670f9935 1434
fcb29b23 1435 bool ret = win->GTKProcessEvent( event );
5e513780 1436 g_lastMouseEvent = NULL;
fcb29b23
VZ
1437 if ( ret )
1438 return TRUE;
47d67540 1439
78cd9c69 1440 if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
22f43cb5 1441 (gs_currentFocus != win) /* && win->IsFocusable() */)
8622e8cd 1442 {
c7bfb76a 1443 win->SetFocus();
8622e8cd
RR
1444 }
1445
ac103441
RR
1446 if (event_type == wxEVT_RIGHT_DOWN)
1447 {
1448 // generate a "context menu" event: this is similar to right mouse
1449 // click under many GUIs except that it is generated differently
1450 // (right up under MSW, ctrl-click under Mac, right down here) and
1451 //
1452 // (a) it's a command event and so is propagated to the parent
1453 // (b) under some ports it can be generated from kbd too
1454 // (c) it uses screen coords (because of (a))
1455 wxContextMenuEvent evtCtx(
1456 wxEVT_CONTEXT_MENU,
1457 win->GetId(),
1458 win->ClientToScreen(event.GetPosition()));
1459 evtCtx.SetEventObject(win);
97687291 1460 return win->GTKProcessEvent(evtCtx);
ac103441
RR
1461 }
1462
034be888 1463 return FALSE;
362c6693 1464}
c801d85f
KB
1465
1466//-----------------------------------------------------------------------------
97b3455a 1467// "button_release_event"
2f2aa628 1468//-----------------------------------------------------------------------------
c801d85f 1469
7f7beb1d 1470static gboolean
71ead4bf 1471gtk_window_button_release_callback( GtkWidget *WXUNUSED(widget),
7f7beb1d
MR
1472 GdkEventButton *gdk_event,
1473 wxWindowGTK *win )
47d67540 1474{
5478f221 1475 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
47d67540 1476
8f9850dd
RR
1477 g_lastButtonNumber = 0;
1478
f5e27805 1479 wxEventType event_type = wxEVT_NULL;
47d67540 1480
f5e27805
RR
1481 switch (gdk_event->button)
1482 {
2b5f62a0
VZ
1483 case 1:
1484 event_type = wxEVT_LEFT_UP;
1485 break;
1486
1487 case 2:
1488 event_type = wxEVT_MIDDLE_UP;
1489 break;
1490
1491 case 3:
1492 event_type = wxEVT_RIGHT_UP;
1493 break;
1494
1495 default:
6a17b868 1496 // unknown button, don't process
2b5f62a0 1497 return FALSE;
f5e27805 1498 }
47d67540 1499
8f9850dd 1500 g_lastMouseEvent = (GdkEvent*) gdk_event;
fcb29b23 1501
f5e27805 1502 wxMouseEvent event( event_type );
c5f9d156 1503 InitMouseEvent( win, event, gdk_event );
f5e27805 1504
2daa0ce9
VZ
1505 AdjustEventButtonState(event);
1506
d1f2ac45
VZ
1507 if ( !g_captureWindow )
1508 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
47d67540 1509
ccb9fa0d
RD
1510 // reset the event object and id in case win changed.
1511 event.SetEventObject( win );
1512 event.SetId( win->GetId() );
1513
e6cac2df 1514 bool ret = win->GTKProcessEvent(event);
f4322df6 1515
e6cac2df 1516 g_lastMouseEvent = NULL;
f4322df6 1517
e6cac2df 1518 return ret;
362c6693 1519}
c801d85f
KB
1520
1521//-----------------------------------------------------------------------------
2f2aa628
RR
1522// "motion_notify_event"
1523//-----------------------------------------------------------------------------
c801d85f 1524
7f7beb1d 1525static gboolean
e4161a2a 1526gtk_window_motion_notify_callback( GtkWidget * WXUNUSED(widget),
7f7beb1d
MR
1527 GdkEventMotion *gdk_event,
1528 wxWindowGTK *win )
47d67540 1529{
5478f221 1530 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
034be888 1531
ff8bfdbb 1532 if (gdk_event->is_hint)
aae24d21 1533 {
f7a11f8c
RR
1534 int x = 0;
1535 int y = 0;
1536 GdkModifierType state;
1537 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1538 gdk_event->x = x;
1539 gdk_event->y = y;
aae24d21 1540 }
ff8bfdbb 1541
8f9850dd
RR
1542 g_lastMouseEvent = (GdkEvent*) gdk_event;
1543
e380f72b 1544 wxMouseEvent event( wxEVT_MOTION );
c5f9d156 1545 InitMouseEvent(win, event, gdk_event);
e380f72b 1546
50382578 1547 if ( g_captureWindow )
2f2aa628 1548 {
6a17b868 1549 // synthesise a mouse enter or leave event if needed
1e6feb95 1550 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
7c5e6fc6 1551 // This seems to be necessary and actually been added to
50382578
RR
1552 // GDK itself in version 2.0.X
1553 gdk_flush();
7c5e6fc6 1554
1e6feb95
VZ
1555 bool hasMouse = winUnderMouse == gdk_event->window;
1556 if ( hasMouse != g_captureWindowHasMouse )
1557 {
1558 // the mouse changed window
1559 g_captureWindowHasMouse = hasMouse;
1560
17a1ebd1
VZ
1561 wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1562 : wxEVT_LEAVE_WINDOW);
1563 InitMouseEvent(win, eventM, gdk_event);
1564 eventM.SetEventObject(win);
97687291 1565 win->GTKProcessEvent(eventM);
1e6feb95
VZ
1566 }
1567 }
1568 else // no capture
1569 {
d1f2ac45 1570 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
ccb9fa0d
RD
1571
1572 // reset the event object and id in case win changed.
1573 event.SetEventObject( win );
1574 event.SetId( win->GetId() );
2f2aa628 1575 }
47d67540 1576
38f69be1
RR
1577 if ( !g_captureWindow )
1578 {
1579 wxSetCursorEvent cevent( event.m_x, event.m_y );
97687291 1580 if (win->GTKProcessEvent( cevent ))
38f69be1 1581 {
ec1e0c66 1582 win->SetCursor( cevent.GetCursor() );
38f69be1
RR
1583 }
1584 }
2e1f5012 1585
5e513780 1586 bool ret = win->GTKProcessEvent(event);
fcb29b23 1587
5e513780
RR
1588 g_lastMouseEvent = NULL;
1589
1590 return ret;
362c6693 1591}
c801d85f 1592
557c9f5b 1593//-----------------------------------------------------------------------------
40e5ebbf 1594// "scroll_event" (mouse wheel event)
557c9f5b
JS
1595//-----------------------------------------------------------------------------
1596
7f251559
RR
1597static gboolean
1598window_scroll_event_hscrollbar(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
1599{
1600 if (gdk_event->direction != GDK_SCROLL_LEFT &&
1601 gdk_event->direction != GDK_SCROLL_RIGHT)
1602 {
1603 return false;
1604 }
1605
1606 wxMouseEvent event(wxEVT_MOUSEWHEEL);
1607 InitMouseEvent(win, event, gdk_event);
1608
1609 GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Horz];
1610 if (!range) return FALSE;
1611
1612 if (range && GTK_WIDGET_VISIBLE (range))
1613 {
1614 GtkAdjustment *adj = range->adjustment;
1615 gdouble delta = adj->step_increment * 3;
1616 if (gdk_event->direction == GDK_SCROLL_LEFT)
1617 delta = -delta;
1618
1619 gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
35510e48 1620
7f251559
RR
1621 gtk_adjustment_set_value (adj, new_value);
1622
1623 return TRUE;
1624 }
1625
1626 return FALSE;
1627}
1628
7f7beb1d 1629static gboolean
76e4be8e 1630window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
557c9f5b 1631{
76e4be8e
PC
1632 if (gdk_event->direction != GDK_SCROLL_UP &&
1633 gdk_event->direction != GDK_SCROLL_DOWN)
1634 {
1635 return false;
1636 }
0a164d4c 1637
76e4be8e 1638 wxMouseEvent event(wxEVT_MOUSEWHEEL);
b4e43132 1639 InitMouseEvent(win, event, gdk_event);
c53c7fad
RD
1640
1641 // FIXME: Get these values from GTK or GDK
58d185f7 1642 event.m_linesPerAction = 3;
60773911 1643 event.m_wheelDelta = 120;
557c9f5b
JS
1644 if (gdk_event->direction == GDK_SCROLL_UP)
1645 event.m_wheelRotation = 120;
1646 else
1647 event.m_wheelRotation = -120;
1648
7f251559
RR
1649 if (win->GTKProcessEvent(event))
1650 return TRUE;
35510e48 1651
7f251559
RR
1652 GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
1653 if (!range) return FALSE;
1654
1655 if (range && GTK_WIDGET_VISIBLE (range))
1656 {
1657 GtkAdjustment *adj = range->adjustment;
1658 gdouble delta = adj->step_increment * 3;
1659 if (gdk_event->direction == GDK_SCROLL_UP)
1660 delta = -delta;
1661
1662 gdouble new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
35510e48 1663
7f251559
RR
1664 gtk_adjustment_set_value (adj, new_value);
1665
1666 return TRUE;
1667 }
1668
1669 return FALSE;
557c9f5b 1670}
ac103441
RR
1671
1672//-----------------------------------------------------------------------------
1673// "popup-menu"
1674//-----------------------------------------------------------------------------
ef5c70f9 1675
ac103441
RR
1676static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
1677{
ac9d38d8 1678 wxContextMenuEvent event(wxEVT_CONTEXT_MENU, win->GetId(), wxPoint(-1, -1));
ac103441 1679 event.SetEventObject(win);
97687291 1680 return win->GTKProcessEvent(event);
ac103441 1681}
557c9f5b 1682
c801d85f 1683//-----------------------------------------------------------------------------
2f2aa628
RR
1684// "focus_in_event"
1685//-----------------------------------------------------------------------------
c801d85f 1686
7f7beb1d 1687static gboolean
e4161a2a 1688gtk_window_focus_in_callback( GtkWidget * WXUNUSED(widget),
7f7beb1d 1689 GdkEventFocus *WXUNUSED(event),
bd2e08d0 1690 wxWindowGTK *win )
c801d85f 1691{
bd2e08d0 1692 return win->GTKHandleFocusIn();
362c6693 1693}
c801d85f
KB
1694
1695//-----------------------------------------------------------------------------
2f2aa628
RR
1696// "focus_out_event"
1697//-----------------------------------------------------------------------------
c801d85f 1698
7f7beb1d 1699static gboolean
e4161a2a
VZ
1700gtk_window_focus_out_callback( GtkWidget * WXUNUSED(widget),
1701 GdkEventFocus * WXUNUSED(gdk_event),
7f7beb1d 1702 wxWindowGTK *win )
c801d85f 1703{
bd2e08d0 1704 return win->GTKHandleFocusOut();
362c6693 1705}
c801d85f 1706
bd2e08d0
VS
1707//-----------------------------------------------------------------------------
1708// "focus"
1709//-----------------------------------------------------------------------------
1710
28e88942
VZ
1711static gboolean
1712wx_window_focus_callback(GtkWidget *widget,
e4161a2a 1713 GtkDirectionType WXUNUSED(direction),
28e88942
VZ
1714 wxWindowGTK *win)
1715{
08f53168 1716 // the default handler for focus signal in GtkScrolledWindow sets
28e88942
VZ
1717 // focus to the window itself even if it doesn't accept focus, i.e. has no
1718 // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
1719 // the signal from reaching gtk_scrolled_window_focus() if we don't have
1720 // any children which might accept focus (we know we don't accept the focus
1721 // ourselves as this signal is only connected in this case)
1722 if ( win->GetChildren().empty() )
1723 g_signal_stop_emission_by_name(widget, "focus");
1724
1725 // we didn't change the focus
1726 return FALSE;
1727}
1728
b4071e91
RR
1729//-----------------------------------------------------------------------------
1730// "enter_notify_event"
1731//-----------------------------------------------------------------------------
1732
f3a5f83a
MR
1733static gboolean
1734gtk_window_enter_callback( GtkWidget *widget,
1735 GdkEventCrossing *gdk_event,
1736 wxWindowGTK *win )
b4071e91 1737{
5478f221 1738 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
47d67540 1739
7f5f144a
RR
1740 // Event was emitted after a grab
1741 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
7c5e6fc6 1742
4a33eba6
RR
1743 int x = 0;
1744 int y = 0;
1745 GdkModifierType state = (GdkModifierType)0;
ff8bfdbb 1746
a2053b27 1747 gdk_window_get_pointer( widget->window, &x, &y, &state );
ff8bfdbb 1748
edc1d330 1749 wxMouseEvent event( wxEVT_ENTER_WINDOW );
c5f9d156
VS
1750 InitMouseEvent(win, event, gdk_event);
1751 wxPoint pt = win->GetClientAreaOrigin();
1752 event.m_x = x + pt.x;
1753 event.m_y = y + pt.y;
ff8bfdbb 1754
38f69be1
RR
1755 if ( !g_captureWindow )
1756 {
1757 wxSetCursorEvent cevent( event.m_x, event.m_y );
97687291 1758 if (win->GTKProcessEvent( cevent ))
38f69be1 1759 {
ec1e0c66 1760 win->SetCursor( cevent.GetCursor() );
38f69be1
RR
1761 }
1762 }
2e1f5012 1763
97687291 1764 return win->GTKProcessEvent(event);
b4071e91 1765}
47d67540 1766
b4071e91
RR
1767//-----------------------------------------------------------------------------
1768// "leave_notify_event"
1769//-----------------------------------------------------------------------------
1770
f3a5f83a
MR
1771static gboolean
1772gtk_window_leave_callback( GtkWidget *widget,
1773 GdkEventCrossing *gdk_event,
1774 wxWindowGTK *win )
b4071e91 1775{
5478f221 1776 wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
b292e2f5 1777
7f5f144a
RR
1778 // Event was emitted after an ungrab
1779 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
7c5e6fc6 1780
e380f72b 1781 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
47d67540 1782
4a33eba6
RR
1783 int x = 0;
1784 int y = 0;
1785 GdkModifierType state = (GdkModifierType)0;
ff8bfdbb 1786
4a33eba6 1787 gdk_window_get_pointer( widget->window, &x, &y, &state );
ff8bfdbb 1788
b4e43132 1789 InitMouseEvent(win, event, gdk_event);
ff8bfdbb 1790
97687291 1791 return win->GTKProcessEvent(event);
b4071e91 1792}
47d67540 1793
c801d85f 1794//-----------------------------------------------------------------------------
add7cadd 1795// "value_changed" from scrollbar
2f2aa628 1796//-----------------------------------------------------------------------------
c801d85f 1797
add7cadd
PC
1798static void
1799gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)
47d67540 1800{
71ead4bf 1801 wxEventType eventType = win->GTKGetScrollEventType(range);
add7cadd
PC
1802 if (eventType != wxEVT_NULL)
1803 {
1804 // Convert scroll event type to scrollwin event type
1805 eventType += wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP;
22c9b211
VZ
1806
1807 // find the scrollbar which generated the event
1808 wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range);
35510e48 1809
22c9b211 1810 // generate the corresponding wx event
bfeeb7f3 1811 const int orient = wxWindow::OrientFromScrollDir(dir);
add7cadd
PC
1812 wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
1813 event.SetEventObject(win);
22c9b211 1814
97687291 1815 win->GTKProcessEvent(event);
add7cadd 1816 }
362c6693 1817}
c801d85f 1818
cb43b372
RR
1819//-----------------------------------------------------------------------------
1820// "button_press_event" from scrollbar
1821//-----------------------------------------------------------------------------
1822
7f7beb1d 1823static gboolean
add7cadd 1824gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
cb43b372 1825{
0a164d4c 1826 g_blockEventsOnScroll = true;
add7cadd 1827 win->m_mouseButtonDown = true;
9e691f46 1828
add7cadd 1829 return false;
cb43b372
RR
1830}
1831
c918b2cd
PC
1832//-----------------------------------------------------------------------------
1833// "event_after" from scrollbar
1834//-----------------------------------------------------------------------------
1835
c918b2cd
PC
1836static void
1837gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win)
1838{
1839 if (event->type == GDK_BUTTON_RELEASE)
1840 {
1841 g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win);
1842
bfeeb7f3 1843 const int orient = wxWindow::OrientFromScrollDir(
22c9b211 1844 win->ScrollDirFromRange(range));
74ab5f5b
VZ
1845 wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBRELEASE,
1846 win->GetScrollPos(orient), orient);
1847 evt.SetEventObject(win);
1848 win->GTKProcessEvent(evt);
c918b2cd
PC
1849 }
1850}
c918b2cd 1851
cb43b372
RR
1852//-----------------------------------------------------------------------------
1853// "button_release_event" from scrollbar
1854//-----------------------------------------------------------------------------
1855
7f7beb1d 1856static gboolean
add7cadd 1857gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)
cb43b372 1858{
0a164d4c 1859 g_blockEventsOnScroll = false;
add7cadd
PC
1860 win->m_mouseButtonDown = false;
1861 // If thumb tracking
2a23d363 1862 if (win->m_isScrolling)
88413fec 1863 {
add7cadd 1864 win->m_isScrolling = false;
c918b2cd 1865 // Hook up handler to send thumb release event after this emission is finished.
8ea30e36
PC
1866 // To allow setting scroll position from event handler, sending event must
1867 // be deferred until after the GtkRange handler for this signal has run
c918b2cd 1868 g_signal_handlers_unblock_by_func(range, (void*)gtk_scrollbar_event_after, win);
88413fec
RR
1869 }
1870
add7cadd 1871 return false;
cb43b372 1872}
ca298c88 1873
a2053b27
RR
1874//-----------------------------------------------------------------------------
1875// "realize" from m_widget
1876//-----------------------------------------------------------------------------
1877
7f7beb1d 1878static void
08f53168 1879gtk_window_realized_callback(GtkWidget* widget, wxWindow* win)
a2053b27 1880{
a3c15d89 1881 if (win->m_imData)
2b5f62a0 1882 {
a3c15d89 1883 gtk_im_context_set_client_window( win->m_imData->context,
f089940f 1884 win->m_wxwindow ? win->GTKGetDrawingWindow() : widget->window);
2b5f62a0 1885 }
03647350 1886
8622e8cd
RR
1887 // We cannot set colours and fonts before the widget
1888 // been realized, so we do this directly after realization
1889 // or otherwise in idle time
1890
1891 if (win->m_needsStyleChange)
1892 {
1893 win->SetBackgroundStyle(win->GetBackgroundStyle());
1894 win->m_needsStyleChange = false;
1895 }
1896
3c679789
RR
1897 wxWindowCreateEvent event( win );
1898 event.SetEventObject( win );
97687291 1899 win->GTKProcessEvent( event );
9c76b9af
RR
1900
1901 win->GTKUpdateCursor(true, false);
a2053b27
RR
1902}
1903
b79395c5 1904//-----------------------------------------------------------------------------
cca410b3 1905// "size_allocate" from m_wxwindow or m_widget
b79395c5
RR
1906//-----------------------------------------------------------------------------
1907
cca410b3
PC
1908static void
1909size_allocate(GtkWidget*, GtkAllocation* alloc, wxWindow* win)
8f75cb6c 1910{
cca410b3
PC
1911 int w = alloc->width;
1912 int h = alloc->height;
1913 if (win->m_wxwindow)
5b8a521e 1914 {
08f53168
PC
1915 int border_x, border_y;
1916 WX_PIZZA(win->m_wxwindow)->get_border_widths(border_x, border_y);
1917 w -= 2 * border_x;
1918 h -= 2 * border_y;
cca410b3
PC
1919 if (w < 0) w = 0;
1920 if (h < 0) h = 0;
1921 }
1922 if (win->m_oldClientWidth != w || win->m_oldClientHeight != h)
1923 {
1924 win->m_oldClientWidth = w;
1925 win->m_oldClientHeight = h;
1926 // this callback can be connected to m_wxwindow,
1927 // so always get size from m_widget->allocation
1928 win->m_width = win->m_widget->allocation.width;
1929 win->m_height = win->m_widget->allocation.height;
1930 if (!win->m_nativeSizeEvent)
1931 {
1932 wxSizeEvent event(win->GetSize(), win->GetId());
1933 event.SetEventObject(win);
1934 win->GTKProcessEvent(event);
1935 }
5b8a521e 1936 }
8f75cb6c
RR
1937}
1938
7738af59 1939//-----------------------------------------------------------------------------
78cd9c69 1940// "grab_broken"
7738af59
VZ
1941//-----------------------------------------------------------------------------
1942
db885f2a
PC
1943#if GTK_CHECK_VERSION(2, 8, 0)
1944static gboolean
1945gtk_window_grab_broken( GtkWidget*,
7738af59
VZ
1946 GdkEventGrabBroken *event,
1947 wxWindow *win )
1948{
1949 // Mouse capture has been lost involuntarily, notify the application
db885f2a 1950 if(!event->keyboard && wxWindow::GetCapture() == win)
7738af59
VZ
1951 {
1952 wxMouseCaptureLostEvent evt( win->GetId() );
1953 evt.SetEventObject( win );
937013e0 1954 win->HandleWindowEvent( evt );
7738af59 1955 }
db885f2a 1956 return false;
7738af59 1957}
4b859ff4 1958#endif
7738af59 1959
013151c7
JS
1960//-----------------------------------------------------------------------------
1961// "style_set"
1962//-----------------------------------------------------------------------------
1963
1964static
1965void gtk_window_style_set_callback( GtkWidget *WXUNUSED(widget),
1966 GtkStyle *previous_style,
1967 wxWindow* win )
1968{
013151c7
JS
1969 if (win && previous_style)
1970 {
013151c7
JS
1971 wxSysColourChangedEvent event;
1972 event.SetEventObject(win);
1973
1974 win->GTKProcessEvent( event );
1975 }
1976}
1977
ef5c70f9
VZ
1978} // extern "C"
1979
1980// ----------------------------------------------------------------------------
1981// this wxWindowBase function is implemented here (in platform-specific file)
1982// because it is static and so couldn't be made virtual
1983// ----------------------------------------------------------------------------
1984
1985wxWindow *wxWindowBase::DoFindFocus()
1986{
22f43cb5 1987 wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
ef5c70f9 1988 // the cast is necessary when we compile in wxUniversal mode
5c33522f 1989 return static_cast<wxWindow*>(focus);
865bb325 1990}
63081513 1991
48200154 1992void wxWindowGTK::AddChildGTK(wxWindowGTK* child)
6ca41e57 1993{
9a33c3ef 1994 wxASSERT_MSG(m_wxwindow, "Cannot add a child to a window without a client area");
03647350 1995
9a33c3ef
FM
1996 // the window might have been scrolled already, we
1997 // have to adapt the position
48200154 1998 wxPizza* pizza = WX_PIZZA(m_wxwindow);
08f53168
PC
1999 child->m_x += pizza->m_scroll_x;
2000 child->m_y += pizza->m_scroll_y;
148cd9b6 2001
08f53168
PC
2002 gtk_widget_set_size_request(
2003 child->m_widget, child->m_width, child->m_height);
f089940f 2004 pizza->put(child->m_widget, child->m_x, child->m_y);
6ca41e57
RR
2005}
2006
bbe0af5b
RR
2007//-----------------------------------------------------------------------------
2008// global functions
2009//-----------------------------------------------------------------------------
2010
1e6feb95 2011wxWindow *wxGetActiveWindow()
bbe0af5b 2012{
6cad4f1b 2013 return wxWindow::FindFocus();
bbe0af5b
RR
2014}
2015
7dd40b6f
RD
2016
2017wxMouseState wxGetMouseState()
2018{
2019 wxMouseState ms;
2020
2021 gint x;
2022 gint y;
2023 GdkModifierType mask;
2024
2025 gdk_window_get_pointer(NULL, &x, &y, &mask);
2026
2027 ms.SetX(x);
2028 ms.SetY(y);
c4021a79
PC
2029 ms.SetLeftDown((mask & GDK_BUTTON1_MASK) != 0);
2030 ms.SetMiddleDown((mask & GDK_BUTTON2_MASK) != 0);
2031 ms.SetRightDown((mask & GDK_BUTTON3_MASK) != 0);
2032 ms.SetAux1Down((mask & GDK_BUTTON4_MASK) != 0);
2033 ms.SetAux2Down((mask & GDK_BUTTON5_MASK) != 0);
2034
2035 ms.SetControlDown((mask & GDK_CONTROL_MASK) != 0);
2036 ms.SetShiftDown((mask & GDK_SHIFT_MASK) != 0);
2037 ms.SetAltDown((mask & GDK_MOD1_MASK) != 0);
2038 ms.SetMetaDown((mask & GDK_META_MASK) != 0);
3d257b8d 2039
7dd40b6f
RD
2040 return ms;
2041}
3d257b8d 2042
c801d85f 2043//-----------------------------------------------------------------------------
1e6feb95 2044// wxWindowGTK
c801d85f
KB
2045//-----------------------------------------------------------------------------
2046
6522713c
VZ
2047// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2048// method
1e6feb95 2049#ifdef __WXUNIVERSAL__
6522713c 2050 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
28953245 2051#endif // __WXUNIVERSAL__
c801d85f 2052
1e6feb95 2053void wxWindowGTK::Init()
c801d85f 2054{
f03fc89f 2055 // GTK specific
d3b9f782
VZ
2056 m_widget = NULL;
2057 m_wxwindow = NULL;
2058 m_focusWidget = NULL;
8bbe427f 2059
f03fc89f 2060 // position/size
a2053b27
RR
2061 m_x = 0;
2062 m_y = 0;
2063 m_width = 0;
e380f72b 2064 m_height = 0;
8bbe427f 2065
0a164d4c 2066 m_hasVMT = false;
02761f6c 2067
c6212a0c 2068 m_showOnIdle = false;
148cd9b6 2069
0a164d4c
WS
2070 m_noExpose = false;
2071 m_nativeSizeEvent = false;
94633ad9 2072
0a164d4c 2073 m_isScrolling = false;
add7cadd 2074 m_mouseButtonDown = false;
add7cadd 2075
22c9b211
VZ
2076 // initialize scrolling stuff
2077 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2078 {
2079 m_scrollBar[dir] = NULL;
2080 m_scrollPos[dir] = 0;
22c9b211 2081 }
f03fc89f 2082
815ac4a7
VZ
2083 m_oldClientWidth =
2084 m_oldClientHeight = 0;
8bbe427f 2085
0a164d4c 2086 m_clipPaintRegion = false;
b6fa52db 2087
c7382f91
JS
2088 m_needsStyleChange = false;
2089
5e014a0c 2090 m_cursor = *wxSTANDARD_CURSOR;
2daa0ce9 2091
a3c15d89 2092 m_imData = NULL;
a589495e 2093 m_dirtyTabOrder = false;
362c6693 2094}
c801d85f 2095
1e6feb95 2096wxWindowGTK::wxWindowGTK()
68995f26
VZ
2097{
2098 Init();
2099}
2100
1e6feb95
VZ
2101wxWindowGTK::wxWindowGTK( wxWindow *parent,
2102 wxWindowID id,
2103 const wxPoint &pos,
2104 const wxSize &size,
2105 long style,
2106 const wxString &name )
6ca41e57 2107{
68995f26
VZ
2108 Init();
2109
e380f72b 2110 Create( parent, id, pos, size, style, name );
6ca41e57 2111}
8bbe427f 2112
1e6feb95
VZ
2113bool wxWindowGTK::Create( wxWindow *parent,
2114 wxWindowID id,
2115 const wxPoint &pos,
2116 const wxSize &size,
2117 long style,
2118 const wxString &name )
c801d85f 2119{
e5048854
JS
2120 // Get default border
2121 wxBorder border = GetBorder(style);
9800347d 2122
e5048854
JS
2123 style &= ~wxBORDER_MASK;
2124 style |= border;
ac9d38d8 2125
4dcaf11a
RR
2126 if (!PreCreation( parent, pos, size ) ||
2127 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2128 {
1e6feb95 2129 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
0a164d4c 2130 return false;
4dcaf11a 2131 }
47d67540 2132
7da4a9cf
RR
2133 // We should accept the native look
2134#if 0
2135 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2136 scroll_class->scrollbar_spacing = 0;
2137#endif
2138
e5048854 2139
0f52f610 2140 m_wxwindow = wxPizza::New(m_windowStyle);
75f661bb
PC
2141#ifndef __WXUNIVERSAL__
2142 if (HasFlag(wxPizza::BORDER_STYLES))
2143 {
2144 g_signal_connect(m_wxwindow, "parent_set",
2145 G_CALLBACK(parent_set), this);
2146 }
2147#endif
3e09bcfd 2148 if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
c9192212 2149 m_widget = m_wxwindow;
6552c7af
RR
2150 else
2151 {
d3b9f782 2152 m_widget = gtk_scrolled_window_new( NULL, NULL );
ff8bfdbb 2153
6552c7af 2154 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
47d67540 2155
6552c7af
RR
2156 // There is a conflict with default bindings at GTK+
2157 // level between scrolled windows and notebooks both of which want to use
2158 // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
2159 // direction and notebooks for changing pages -- we decide that if we don't
2160 // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
2161 // means we can get working keyboard navigation in notebooks
2162 if ( !HasFlag(wxHSCROLL) )
fd4081aa 2163 {
6552c7af
RR
2164 GtkBindingSet *
2165 bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
2166 if ( bindings )
2167 {
2168 gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
2169 gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
2170 }
fd4081aa 2171 }
fd4081aa 2172
6552c7af
RR
2173 if (HasFlag(wxALWAYS_SHOW_SB))
2174 {
2175 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
d2288928 2176
6552c7af
RR
2177 scrolledWindow->hscrollbar_visible = TRUE;
2178 scrolledWindow->vscrollbar_visible = TRUE;
2179 }
2180 else
2181 {
2182 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2183 }
47d67540 2184
6552c7af
RR
2185 m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
2186 m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
2187 if (GetLayoutDirection() == wxLayout_RightToLeft)
2188 gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
47d67540 2189
6552c7af 2190 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
4e5a4c69 2191
6552c7af
RR
2192 // connect various scroll-related events
2193 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
2194 {
2195 // these handlers block mouse events to any window during scrolling
2196 // such as motion events and prevent GTK and wxWidgets from fighting
2197 // over where the slider should be
2198 g_signal_connect(m_scrollBar[dir], "button_press_event",
22c9b211 2199 G_CALLBACK(gtk_scrollbar_button_press_event), this);
6552c7af 2200 g_signal_connect(m_scrollBar[dir], "button_release_event",
22c9b211
VZ
2201 G_CALLBACK(gtk_scrollbar_button_release_event), this);
2202
6552c7af 2203 gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
22c9b211 2204 G_CALLBACK(gtk_scrollbar_event_after), this);
6552c7af 2205 g_signal_handler_block(m_scrollBar[dir], handler_id);
22c9b211 2206
6552c7af 2207 // these handlers get notified when scrollbar slider moves
40e5ebbf 2208 g_signal_connect_after(m_scrollBar[dir], "value_changed",
22c9b211 2209 G_CALLBACK(gtk_scrollbar_value_changed), this);
6552c7af 2210 }
76ed8f8d 2211
6552c7af
RR
2212 gtk_widget_show( m_wxwindow );
2213 }
9ff9d30c 2214 g_object_ref(m_widget);
47d67540 2215
f03fc89f
VZ
2216 if (m_parent)
2217 m_parent->DoAddChild( this );
94633ad9 2218
76fcf0f2 2219 m_focusWidget = m_wxwindow;
8bbe427f 2220
29901843
VS
2221 SetCanFocus(AcceptsFocus());
2222
e380f72b 2223 PostCreation();
8bbe427f 2224
0a164d4c 2225 return true;
362c6693 2226}
c801d85f 2227
1e6feb95 2228wxWindowGTK::~wxWindowGTK()
c801d85f 2229{
7de59551
RD
2230 SendDestroyEvent();
2231
22f43cb5
VS
2232 if (gs_currentFocus == this)
2233 gs_currentFocus = NULL;
2234 if (gs_pendingFocus == this)
2235 gs_pendingFocus = NULL;
44cd54c2 2236
bd2e08d0
VS
2237 if ( gs_deferredFocusOut == this )
2238 gs_deferredFocusOut = NULL;
3e679f01 2239
0a164d4c 2240 m_hasVMT = false;
47d67540 2241
02c3e53b
JS
2242 // destroy children before destroying this window itself
2243 DestroyChildren();
2244
2245 // unhook focus handlers to prevent stray events being
2246 // propagated to this (soon to be) dead object
2247 if (m_focusWidget != NULL)
2248 {
9fa72bd2
MR
2249 g_signal_handlers_disconnect_by_func (m_focusWidget,
2250 (gpointer) gtk_window_focus_in_callback,
2251 this);
2252 g_signal_handlers_disconnect_by_func (m_focusWidget,
2253 (gpointer) gtk_window_focus_out_callback,
2254 this);
02c3e53b
JS
2255 }
2256
f03fc89f 2257 if (m_widget)
0a164d4c 2258 Show( false );
8bbe427f 2259
f6551618
MW
2260 // delete before the widgets to avoid a crash on solaris
2261 delete m_imData;
f6551618 2262
2f55b88c
PC
2263 // avoid problem with GTK+ 2.18 where a frozen window causes the whole
2264 // TLW to be frozen, and if the window is then destroyed, nothing ever
2265 // gets painted again
2266 if (IsFrozen())
2267 DoThaw();
2268
f03fc89f 2269 if (m_widget)
a2053b27 2270 {
9ff9d30c
PC
2271 // Note that gtk_widget_destroy() does not destroy the widget, it just
2272 // emits the "destroy" signal. The widget is not actually destroyed
2273 // until its reference count drops to zero.
2274 gtk_widget_destroy(m_widget);
2275 // Release our reference, should be the last one
2276 g_object_unref(m_widget);
2277 m_widget = NULL;
a2053b27 2278 }
9ff9d30c 2279 m_wxwindow = NULL;
362c6693 2280}
c801d85f 2281
1e6feb95 2282bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
c801d85f 2283{
e8375af8
VZ
2284 if ( GTKNeedsParent() )
2285 {
2286 wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
2287 }
8bbe427f 2288
a7c26d10
RD
2289 // Use either the given size, or the default if -1 is given.
2290 // See wxWindowBase for these functions.
3013a903 2291 m_width = WidthDefault(size.x) ;
f03fc89f 2292 m_height = HeightDefault(size.y);
8bbe427f 2293
43a18898
RR
2294 m_x = (int)pos.x;
2295 m_y = (int)pos.y;
8bbe427f 2296
0a164d4c 2297 return true;
c801d85f
KB
2298}
2299
1e6feb95 2300void wxWindowGTK::PostCreation()
c801d85f 2301{
82b978d7
RD
2302 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2303
43a18898
RR
2304 if (m_wxwindow)
2305 {
147bc491 2306 if (!m_noExpose)
b02da6b1 2307 {
77ffb593 2308 // these get reported to wxWidgets -> wxPaintEvent
1e6feb95 2309
9fa72bd2
MR
2310 g_signal_connect (m_wxwindow, "expose_event",
2311 G_CALLBACK (gtk_window_expose_callback), this);
147bc491 2312
847dfdb4 2313 if (GetLayoutDirection() == wxLayout_LeftToRight)
08f53168 2314 gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
93d23d8f 2315 }
2b5f62a0 2316
ed56a258
JS
2317 // Create input method handler
2318 m_imData = new wxGtkIMData;
2319
2b5f62a0 2320 // Cannot handle drawing preedited text yet
a3c15d89 2321 gtk_im_context_set_use_preedit( m_imData->context, FALSE );
2b5f62a0 2322
9fa72bd2 2323 g_signal_connect (m_imData->context, "commit",
da210120 2324 G_CALLBACK (gtk_wxwindow_commit_cb), this);
43a18898 2325 }
47d67540 2326
76fcf0f2 2327 // focus handling
63081513 2328
06fda9e8
RR
2329 if (!GTK_IS_WINDOW(m_widget))
2330 {
2331 if (m_focusWidget == NULL)
2332 m_focusWidget = m_widget;
0a164d4c 2333
4c20ee63
RR
2334 if (m_wxwindow)
2335 {
2336 g_signal_connect (m_focusWidget, "focus_in_event",
9fa72bd2 2337 G_CALLBACK (gtk_window_focus_in_callback), this);
4c20ee63 2338 g_signal_connect (m_focusWidget, "focus_out_event",
f1e57cb9 2339 G_CALLBACK (gtk_window_focus_out_callback), this);
4c20ee63
RR
2340 }
2341 else
2342 {
2343 g_signal_connect_after (m_focusWidget, "focus_in_event",
2344 G_CALLBACK (gtk_window_focus_in_callback), this);
2345 g_signal_connect_after (m_focusWidget, "focus_out_event",
2346 G_CALLBACK (gtk_window_focus_out_callback), this);
2347 }
06fda9e8 2348 }
76fcf0f2 2349
28e88942
VZ
2350 if ( !AcceptsFocusFromKeyboard() )
2351 {
80332672 2352 SetCanFocus(false);
28e88942
VZ
2353
2354 g_signal_connect(m_widget, "focus",
2355 G_CALLBACK(wx_window_focus_callback), this);
2356 }
2357
76fcf0f2 2358 // connect to the various key and mouse handlers
63081513 2359
a2053b27 2360 GtkWidget *connect_widget = GetConnectWidget();
f03fc89f 2361
a2053b27 2362 ConnectWidget( connect_widget );
47d67540 2363
63081513 2364 /* We cannot set colours, fonts and cursors before the widget has
a2053b27 2365 been realized, so we do this directly after realization */
9fa72bd2
MR
2366 g_signal_connect (connect_widget, "realize",
2367 G_CALLBACK (gtk_window_realized_callback), this);
2daa0ce9 2368
cca410b3
PC
2369 if (!IsTopLevel())
2370 {
2371 g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
2372 G_CALLBACK(size_allocate), this);
2373 }
2374
db885f2a 2375#if GTK_CHECK_VERSION(2, 8, 0)
bb8afd65
VZ
2376 if ( gtk_check_version(2,8,0) == NULL )
2377 {
2378 // Make sure we can notify the app when mouse capture is lost
2379 if ( m_wxwindow )
4b859ff4 2380 {
4b859ff4 2381 g_signal_connect (m_wxwindow, "grab_broken_event",
7738af59 2382 G_CALLBACK (gtk_window_grab_broken), this);
4b859ff4 2383 }
7738af59 2384
bb8afd65 2385 if ( connect_widget != m_wxwindow )
4b859ff4 2386 {
4b859ff4 2387 g_signal_connect (connect_widget, "grab_broken_event",
7738af59 2388 G_CALLBACK (gtk_window_grab_broken), this);
4b859ff4 2389 }
63081513 2390 }
bb8afd65 2391#endif // GTK+ >= 2.8
2daa0ce9 2392
92153555 2393 if ( GTKShouldConnectSizeRequest() )
47c93b63
RR
2394 {
2395 // This is needed if we want to add our windows into native
024e9a4c 2396 // GTK controls, such as the toolbar. With this callback, the
47c93b63 2397 // toolbar gets to know the correct size (the one set by the
024e9a4c 2398 // programmer). Sadly, it misbehaves for wxComboBox.
9fa72bd2
MR
2399 g_signal_connect (m_widget, "size_request",
2400 G_CALLBACK (wxgtk_window_size_request_callback),
2401 this);
47c93b63 2402 }
1e6feb95 2403
40bab631
VS
2404 InheritAttributes();
2405
0a164d4c 2406 m_hasVMT = true;
e892f2fd 2407
978af864 2408 SetLayoutDirection(wxLayout_Default);
a433fbd5
VZ
2409
2410 // unless the window was created initially hidden (i.e. Hide() had been
2411 // called before Create()), we should show it at GTK+ level as well
2412 if ( IsShown() )
2413 gtk_widget_show( m_widget );
b4071e91
RR
2414}
2415
a0c8bb73
VZ
2416gulong wxWindowGTK::GTKConnectWidget(const char *signal, void (*callback)())
2417{
2418 return g_signal_connect(m_widget, signal, callback, this);
2419}
2420
1e6feb95 2421void wxWindowGTK::ConnectWidget( GtkWidget *widget )
b4071e91 2422{
9fa72bd2
MR
2423 g_signal_connect (widget, "key_press_event",
2424 G_CALLBACK (gtk_window_key_press_callback), this);
2425 g_signal_connect (widget, "key_release_event",
2426 G_CALLBACK (gtk_window_key_release_callback), this);
2427 g_signal_connect (widget, "button_press_event",
2428 G_CALLBACK (gtk_window_button_press_callback), this);
2429 g_signal_connect (widget, "button_release_event",
2430 G_CALLBACK (gtk_window_button_release_callback), this);
2431 g_signal_connect (widget, "motion_notify_event",
2432 G_CALLBACK (gtk_window_motion_notify_callback), this);
35510e48 2433
9fa72bd2 2434 g_signal_connect (widget, "scroll_event",
76e4be8e 2435 G_CALLBACK (window_scroll_event), this);
7f251559
RR
2436 if (m_scrollBar[ScrollDir_Horz])
2437 g_signal_connect (m_scrollBar[ScrollDir_Horz], "scroll_event",
2438 G_CALLBACK (window_scroll_event_hscrollbar), this);
2439 if (m_scrollBar[ScrollDir_Vert])
2440 g_signal_connect (m_scrollBar[ScrollDir_Vert], "scroll_event",
2441 G_CALLBACK (window_scroll_event), this);
35510e48 2442
9fa72bd2
MR
2443 g_signal_connect (widget, "popup_menu",
2444 G_CALLBACK (wxgtk_window_popup_menu_callback), this);
2445 g_signal_connect (widget, "enter_notify_event",
2446 G_CALLBACK (gtk_window_enter_callback), this);
2447 g_signal_connect (widget, "leave_notify_event",
2448 G_CALLBACK (gtk_window_leave_callback), this);
013151c7
JS
2449
2450 if (IsTopLevel() && m_wxwindow)
2451 g_signal_connect (m_wxwindow, "style_set",
2452 G_CALLBACK (gtk_window_style_set_callback), this);
362c6693 2453}
c801d85f 2454
1e6feb95 2455bool wxWindowGTK::Destroy()
c801d85f 2456{
82b978d7 2457 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
47d67540 2458
0a164d4c 2459 m_hasVMT = false;
c801d85f 2460
f03fc89f 2461 return wxWindowBase::Destroy();
362c6693 2462}
c801d85f 2463
1e6feb95 2464void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
23efdd02 2465{
08f53168 2466 gtk_widget_set_size_request(m_widget, width, height);
03647350 2467
69597639 2468 // inform the parent to perform the move
03647350 2469 wxASSERT_MSG(m_parent && m_parent->m_wxwindow,
9a33c3ef 2470 "the parent window has no client area?");
08f53168 2471 WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
23efdd02 2472}
2daa0ce9 2473
82008f15
PC
2474void wxWindowGTK::ConstrainSize()
2475{
2476#ifdef __WXGPE__
2477 // GPE's window manager doesn't like size hints at all, esp. when the user
2478 // has to use the virtual keyboard, so don't constrain size there
2479 if (!IsTopLevel())
2480#endif
2481 {
2482 const wxSize minSize = GetMinSize();
2483 const wxSize maxSize = GetMaxSize();
2484 if (minSize.x > 0 && m_width < minSize.x) m_width = minSize.x;
2485 if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
2486 if (maxSize.x > 0 && m_width > maxSize.x) m_width = maxSize.x;
2487 if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
2488 }
2489}
2490
1e6feb95 2491void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
c801d85f 2492{
82b978d7 2493 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
1e6feb95 2494 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
8bbe427f 2495
b9f29261
VS
2496 int currentX, currentY;
2497 GetPosition(&currentX, &currentY);
443c834d 2498 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
b9f29261 2499 x = currentX;
443c834d 2500 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
b9f29261 2501 y = currentY;
a200c35e
VS
2502 AdjustForParentClientOrigin(x, y, sizeFlags);
2503
fe39b16a
RR
2504 // calculate the best size if we should auto size the window
2505 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2506 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2507 {
2508 const wxSize sizeBest = GetBestSize();
2509 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2510 width = sizeBest.x;
2511 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2512 height = sizeBest.y;
2513 }
2514
cca410b3 2515 const wxSize oldSize(m_width, m_height);
fe39b16a
RR
2516 if (width != -1)
2517 m_width = width;
2518 if (height != -1)
2519 m_height = height;
2520
cca410b3 2521 if (m_parent->m_wxwindow)
fb1585ae 2522 {
08f53168
PC
2523 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2524 m_x = x + pizza->m_scroll_x;
2525 m_y = y + pizza->m_scroll_y;
47d67540 2526
863e0817
RR
2527 int left_border = 0;
2528 int right_border = 0;
2529 int top_border = 0;
c50f1fb9 2530 int bottom_border = 0;
f03fc89f 2531
863e0817 2532 /* the default button has a border around it */
29f538ce 2533 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
c50f1fb9 2534 {
f893066b
RR
2535 GtkBorder *default_border = NULL;
2536 gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2537 if (default_border)
863e0817 2538 {
f893066b
RR
2539 left_border += default_border->left;
2540 right_border += default_border->right;
2541 top_border += default_border->top;
2542 bottom_border += default_border->bottom;
6cfdfed8 2543 gtk_border_free( default_border );
863e0817 2544 }
863e0817 2545 }
c50f1fb9 2546
18ac7bef
PC
2547 DoMoveWindow( m_x - left_border,
2548 m_y - top_border,
863e0817
RR
2549 m_width+left_border+right_border,
2550 m_height+top_border+bottom_border );
54517652 2551 }
148cd9b6 2552
cca410b3 2553 if (m_width != oldSize.x || m_height != oldSize.y)
5b8a521e 2554 {
cca410b3
PC
2555 // update these variables to keep size_allocate handler
2556 // from sending another size event for this change
5b8a521e 2557 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
6d693bb4 2558
cca410b3
PC
2559 gtk_widget_queue_resize(m_widget);
2560 if (!m_nativeSizeEvent)
2561 {
2562 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2563 event.SetEventObject( this );
937013e0 2564 HandleWindowEvent( event );
cca410b3 2565 }
03647350 2566 } else
e47e063a
RR
2567 if (sizeFlags & wxSIZE_FORCE_EVENT)
2568 {
2569 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2570 event.SetEventObject( this );
2571 HandleWindowEvent( event );
30760ce7 2572 }
362c6693 2573}
c801d85f 2574
71ead4bf 2575bool wxWindowGTK::GTKShowFromOnIdle()
9390a202 2576{
f46ad98f
RR
2577 if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget))
2578 {
2579 GtkAllocation alloc;
2580 alloc.x = m_x;
2581 alloc.y = m_y;
2582 alloc.width = m_width;
2583 alloc.height = m_height;
2584 gtk_widget_size_allocate( m_widget, &alloc );
2585 gtk_widget_show( m_widget );
2586 wxShowEvent eventShow(GetId(), true);
2587 eventShow.SetEventObject(this);
937013e0 2588 HandleWindowEvent(eventShow);
f46ad98f 2589 m_showOnIdle = false;
7317857d 2590 return true;
f46ad98f 2591 }
02761f6c 2592
7317857d
RR
2593 return false;
2594}
2595
2596void wxWindowGTK::OnInternalIdle()
2597{
bd2e08d0
VS
2598 if ( gs_deferredFocusOut )
2599 GTKHandleDeferredFocusOut();
2600
7317857d 2601 // Check if we have to show window now
71ead4bf 2602 if (GTKShowFromOnIdle()) return;
7317857d
RR
2603
2604 if ( m_dirtyTabOrder )
2605 {
2606 m_dirtyTabOrder = false;
2607 RealizeTabOrder();
2608 }
2609
9c61c5b0
VZ
2610 // Update style if the window was not yet realized when
2611 // SetBackgroundStyle() was called
7317857d
RR
2612 if (m_needsStyleChange)
2613 {
2614 SetBackgroundStyle(GetBackgroundStyle());
2615 m_needsStyleChange = false;
2616 }
02761f6c 2617
df707c27 2618 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
e39af974 2619 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
9390a202
RR
2620}
2621
1e6feb95 2622void wxWindowGTK::DoGetSize( int *width, int *height ) const
c801d85f 2623{
82b978d7 2624 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2625
fb1585ae
RR
2626 if (width) (*width) = m_width;
2627 if (height) (*height) = m_height;
362c6693 2628}
c801d85f 2629
1e6feb95 2630void wxWindowGTK::DoSetClientSize( int width, int height )
c801d85f 2631{
82b978d7
RD
2632 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2633
949ff63e
PC
2634 const wxSize size = GetSize();
2635 const wxSize clientSize = GetClientSize();
2636 SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
362c6693 2637}
c801d85f 2638
1e6feb95 2639void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
c801d85f 2640{
82b978d7 2641 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2642
09bf8378
PC
2643 int w = m_width;
2644 int h = m_height;
2645
fcdd5335 2646 if ( m_wxwindow )
c801d85f 2647 {
8466fc74 2648 // if window is scrollable, account for scrollbars
fcdd5335 2649 if ( GTK_IS_SCROLLED_WINDOW(m_widget) )
8466fc74 2650 {
fcdd5335
VZ
2651 GtkPolicyType policy[ScrollDir_Max];
2652 gtk_scrolled_window_get_policy(GTK_SCROLLED_WINDOW(m_widget),
2653 &policy[ScrollDir_Horz],
2654 &policy[ScrollDir_Vert]);
2655
2656 for ( int i = 0; i < ScrollDir_Max; i++ )
8466fc74 2657 {
fcdd5335
VZ
2658 // don't account for the scrollbars we don't have
2659 GtkRange * const range = m_scrollBar[i];
2660 if ( !range )
2661 continue;
2662
2663 // nor for the ones we have but don't current show
2664 switch ( policy[i] )
2665 {
2666 case GTK_POLICY_NEVER:
2667 // never shown so doesn't take any place
2668 continue;
2669
2670 case GTK_POLICY_ALWAYS:
2671 // no checks necessary
2672 break;
2673
2674 case GTK_POLICY_AUTOMATIC:
2675 // may be shown or not, check
2676 GtkAdjustment *adj = gtk_range_get_adjustment(range);
2677 if ( adj->upper <= adj->page_size )
2678 continue;
2679 }
2680
9800347d 2681 GtkScrolledWindowClass *scroll_class =
7da4a9cf
RR
2682 GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2683
fcdd5335
VZ
2684 GtkRequisition req;
2685 gtk_widget_size_request(GTK_WIDGET(range), &req);
8466fc74 2686 if (i == ScrollDir_Horz)
7da4a9cf 2687 h -= req.height + scroll_class->scrollbar_spacing;
8466fc74 2688 else
7da4a9cf 2689 w -= req.width + scroll_class->scrollbar_spacing;
8466fc74
PC
2690 }
2691 }
09bf8378 2692
b3554952
VZ
2693 const wxSize sizeBorders = DoGetBorderSize();
2694 w -= sizeBorders.x;
2695 h -= sizeBorders.y;
9000c624 2696
69346023
PC
2697 if (w < 0)
2698 w = 0;
2699 if (h < 0)
2700 h = 0;
1ecc4d80 2701 }
1e6feb95 2702
09bf8378
PC
2703 if (width) *width = w;
2704 if (height) *height = h;
362c6693 2705}
c801d85f 2706
b3554952
VZ
2707wxSize wxWindowGTK::DoGetBorderSize() const
2708{
2709 if ( !m_wxwindow )
2710 return wxWindowBase::DoGetBorderSize();
2711
2712 int x, y;
2713 WX_PIZZA(m_wxwindow)->get_border_widths(x, y);
2714
2715 return 2*wxSize(x, y);
2716}
2717
1e6feb95 2718void wxWindowGTK::DoGetPosition( int *x, int *y ) const
c801d85f 2719{
82b978d7 2720 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2721
bf0c00c6
RR
2722 int dx = 0;
2723 int dy = 0;
fd8a7b0b 2724 if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
bf0c00c6 2725 {
08f53168
PC
2726 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2727 dx = pizza->m_scroll_x;
2728 dy = pizza->m_scroll_y;
bf0c00c6 2729 }
94633ad9 2730
96c8547e
JS
2731 if (m_x == -1 && m_y == -1)
2732 {
d3b9f782 2733 GdkWindow *source = NULL;
96c8547e 2734 if (m_wxwindow)
08f53168 2735 source = m_wxwindow->window;
96c8547e
JS
2736 else
2737 source = m_widget->window;
2738
2739 if (source)
2740 {
2741 int org_x = 0;
2742 int org_y = 0;
2743 gdk_window_get_origin( source, &org_x, &org_y );
2744
bb5521a9
VZ
2745 if (m_parent)
2746 m_parent->ScreenToClient(&org_x, &org_y);
96c8547e 2747
5c33522f
VZ
2748 const_cast<wxWindowGTK*>(this)->m_x = org_x;
2749 const_cast<wxWindowGTK*>(this)->m_y = org_y;
bfeeb7f3 2750 }
96c8547e
JS
2751 }
2752
496beb3f
VS
2753 if (x) (*x) = m_x - dx;
2754 if (y) (*y) = m_y - dy;
362c6693 2755}
c801d85f 2756
1e6feb95 2757void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
c801d85f 2758{
82b978d7 2759 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2760
a2053b27
RR
2761 if (!m_widget->window) return;
2762
d3b9f782 2763 GdkWindow *source = NULL;
43a18898 2764 if (m_wxwindow)
08f53168 2765 source = m_wxwindow->window;
43a18898
RR
2766 else
2767 source = m_widget->window;
47d67540 2768
43a18898
RR
2769 int org_x = 0;
2770 int org_y = 0;
2771 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 2772
43a18898 2773 if (!m_wxwindow)
c801d85f 2774 {
43a18898
RR
2775 if (GTK_WIDGET_NO_WINDOW (m_widget))
2776 {
2777 org_x += m_widget->allocation.x;
2778 org_y += m_widget->allocation.y;
2779 }
362c6693 2780 }
47d67540 2781
49e74855
RR
2782
2783 if (x)
2784 {
2785 if (GetLayoutDirection() == wxLayout_RightToLeft)
2786 *x = (GetClientSize().x - *x) + org_x;
fcb29b23 2787 else
49e74855
RR
2788 *x += org_x;
2789 }
fcb29b23 2790
43a18898 2791 if (y) *y += org_y;
362c6693 2792}
c801d85f 2793
1e6feb95 2794void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
c801d85f 2795{
82b978d7 2796 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2797
a2053b27
RR
2798 if (!m_widget->window) return;
2799
d3b9f782 2800 GdkWindow *source = NULL;
1ecc4d80 2801 if (m_wxwindow)
08f53168 2802 source = m_wxwindow->window;
1ecc4d80
RR
2803 else
2804 source = m_widget->window;
47d67540 2805
1ecc4d80
RR
2806 int org_x = 0;
2807 int org_y = 0;
2808 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 2809
1ecc4d80 2810 if (!m_wxwindow)
c801d85f 2811 {
1ecc4d80
RR
2812 if (GTK_WIDGET_NO_WINDOW (m_widget))
2813 {
2814 org_x += m_widget->allocation.x;
2815 org_y += m_widget->allocation.y;
2816 }
362c6693 2817 }
47d67540 2818
49e74855
RR
2819 if (x)
2820 {
2821 if (GetLayoutDirection() == wxLayout_RightToLeft)
2822 *x = (GetClientSize().x - *x) - org_x;
fcb29b23 2823 else
49e74855
RR
2824 *x -= org_x;
2825 }
1ecc4d80 2826 if (y) *y -= org_y;
362c6693 2827}
c801d85f 2828
1e6feb95 2829bool wxWindowGTK::Show( bool show )
c801d85f 2830{
3cc57044 2831 if ( !wxWindowBase::Show(show) )
739730ca
RR
2832 {
2833 // nothing to do
0a164d4c 2834 return false;
739730ca 2835 }
8bbe427f 2836
3cc57044
VZ
2837 // notice that we may call Hide() before the window is created and this is
2838 // actually useful to create it hidden initially -- but we can't call
2839 // Show() before it is created
2840 if ( !m_widget )
f46ad98f 2841 {
3cc57044
VZ
2842 wxASSERT_MSG( !show, "can't show invalid window" );
2843 return true;
f46ad98f 2844 }
3cc57044
VZ
2845
2846 if ( show )
f46ad98f 2847 {
3cc57044
VZ
2848 if ( m_showOnIdle )
2849 {
2850 // defer until later
2851 return true;
2852 }
2853
2854 gtk_widget_show(m_widget);
f46ad98f 2855 }
3cc57044
VZ
2856 else // hide
2857 {
2858 gtk_widget_hide(m_widget);
2859 }
2860
2861 wxShowEvent eventShow(GetId(), show);
2862 eventShow.SetEventObject(this);
2863 HandleWindowEvent(eventShow);
2b5f62a0 2864
0a164d4c 2865 return true;
362c6693 2866}
c801d85f 2867
47a8a4d5 2868void wxWindowGTK::DoEnable( bool enable )
fdca68a6 2869{
47a8a4d5 2870 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
1ecc4d80 2871
f03fc89f 2872 gtk_widget_set_sensitive( m_widget, enable );
6552c7af 2873 if (m_wxwindow && (m_wxwindow != m_widget))
f03fc89f 2874 gtk_widget_set_sensitive( m_wxwindow, enable );
362c6693 2875}
c801d85f 2876
1e6feb95 2877int wxWindowGTK::GetCharHeight() const
2f2aa628 2878{
82b978d7 2879 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
47d67540 2880
cc402e64
VZ
2881 wxFont font = GetFont();
2882 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
2f2aa628 2883
db885f2a 2884 PangoContext* context = gtk_widget_get_pango_context(m_widget);
bbd006c0
RR
2885
2886 if (!context)
2887 return 0;
2888
cc402e64 2889 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
bbd006c0
RR
2890 PangoLayout *layout = pango_layout_new(context);
2891 pango_layout_set_font_description(layout, desc);
2892 pango_layout_set_text(layout, "H", 1);
2893 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2894
2895 PangoRectangle rect;
2896 pango_layout_line_get_extents(line, NULL, &rect);
2897
3fe39b0c 2898 g_object_unref (layout);
7de59551 2899
f69e2009 2900 return (int) PANGO_PIXELS(rect.height);
362c6693 2901}
c801d85f 2902
1e6feb95 2903int wxWindowGTK::GetCharWidth() const
c33c4050 2904{
82b978d7 2905 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
47d67540 2906
cc402e64
VZ
2907 wxFont font = GetFont();
2908 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
47d67540 2909
db885f2a 2910 PangoContext* context = gtk_widget_get_pango_context(m_widget);
bbd006c0
RR
2911
2912 if (!context)
2913 return 0;
2914
cc402e64 2915 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
bbd006c0
RR
2916 PangoLayout *layout = pango_layout_new(context);
2917 pango_layout_set_font_description(layout, desc);
95c430aa 2918 pango_layout_set_text(layout, "g", 1);
bbd006c0
RR
2919 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2920
2921 PangoRectangle rect;
2922 pango_layout_line_get_extents(line, NULL, &rect);
2923
3fe39b0c 2924 g_object_unref (layout);
7de59551 2925
f69e2009 2926 return (int) PANGO_PIXELS(rect.width);
c33c4050
RR
2927}
2928
6de70470
VZ
2929void wxWindowGTK::DoGetTextExtent( const wxString& string,
2930 int *x,
2931 int *y,
2932 int *descent,
2933 int *externalLeading,
2934 const wxFont *theFont ) const
c33c4050 2935{
cc402e64 2936 wxFont fontToUse = theFont ? *theFont : GetFont();
47d67540 2937
223d09f6 2938 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
2b5f62a0 2939
0a164d4c 2940 if (string.empty())
48d011c8 2941 {
b15ed747
RR
2942 if (x) (*x) = 0;
2943 if (y) (*y) = 0;
48d011c8
RR
2944 return;
2945 }
47d67540 2946
48d011c8
RR
2947 PangoContext *context = NULL;
2948 if (m_widget)
2b5f62a0
VZ
2949 context = gtk_widget_get_pango_context( m_widget );
2950
48d011c8
RR
2951 if (!context)
2952 {
b15ed747
RR
2953 if (x) (*x) = 0;
2954 if (y) (*y) = 0;
48d011c8
RR
2955 return;
2956 }
2b5f62a0 2957
48d011c8
RR
2958 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
2959 PangoLayout *layout = pango_layout_new(context);
2960 pango_layout_set_font_description(layout, desc);
2961 {
a3669332
VZ
2962 const wxCharBuffer data = wxGTK_CONV( string );
2963 if ( data )
2964 pango_layout_set_text(layout, data, strlen(data));
48d011c8 2965 }
2b5f62a0 2966
48d011c8 2967 PangoRectangle rect;
fd43b1b3 2968 pango_layout_get_extents(layout, NULL, &rect);
2b5f62a0 2969
f69e2009
VS
2970 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
2971 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
48d011c8
RR
2972 if (descent)
2973 {
f69e2009
VS
2974 PangoLayoutIter *iter = pango_layout_get_iter(layout);
2975 int baseline = pango_layout_iter_get_baseline(iter);
2976 pango_layout_iter_free(iter);
2977 *descent = *y - PANGO_PIXELS(baseline);
48d011c8
RR
2978 }
2979 if (externalLeading) (*externalLeading) = 0; // ??
2b5f62a0 2980
3fe39b0c 2981 g_object_unref (layout);
c33c4050
RR
2982}
2983
36a845fe
RR
2984void wxWindowGTK::GTKDisableFocusOutEvent()
2985{
2986 g_signal_handlers_block_by_func( m_focusWidget,
2987 (gpointer) gtk_window_focus_out_callback, this);
2988}
2989
2990void wxWindowGTK::GTKEnableFocusOutEvent()
2991{
2992 g_signal_handlers_unblock_by_func( m_focusWidget,
2993 (gpointer) gtk_window_focus_out_callback, this);
2994}
bd2e08d0
VS
2995
2996bool wxWindowGTK::GTKHandleFocusIn()
ef5c70f9 2997{
bd2e08d0
VS
2998 // Disable default focus handling for custom windows since the default GTK+
2999 // handler issues a repaint
3000 const bool retval = m_wxwindow ? true : false;
3001
3002
3003 // NB: if there's still unprocessed deferred focus-out event (see
3004 // GTKHandleFocusOut() for explanation), we need to process it first so
3005 // that the order of focus events -- focus-out first, then focus-in
3006 // elsewhere -- is preserved
3007 if ( gs_deferredFocusOut )
ef5c70f9 3008 {
bd2e08d0
VS
3009 if ( GTKNeedsToFilterSameWindowFocus() &&
3010 gs_deferredFocusOut == this )
ef5c70f9 3011 {
bd2e08d0
VS
3012 // GTK+ focus changed from this wxWindow back to itself, so don't
3013 // emit any events at all
3014 wxLogTrace(TRACE_FOCUS,
3015 "filtered out spurious focus change within %s(%p, %s)",
3016 GetClassInfo()->GetClassName(), this, GetLabel());
3017 gs_deferredFocusOut = NULL;
3018 return retval;
ef5c70f9 3019 }
bd2e08d0
VS
3020
3021 // otherwise we need to send focus-out first
3022 wxASSERT_MSG ( gs_deferredFocusOut != this,
3023 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
3024 GTKHandleDeferredFocusOut();
ef5c70f9
VZ
3025 }
3026
bd2e08d0
VS
3027
3028 wxLogTrace(TRACE_FOCUS,
3029 "handling focus_in event for %s(%p, %s)",
3030 GetClassInfo()->GetClassName(), this, GetLabel());
3031
3032 if (m_imData)
3033 gtk_im_context_focus_in(m_imData->context);
3034
22f43cb5
VS
3035 gs_currentFocus = this;
3036 gs_pendingFocus = NULL;
bd2e08d0
VS
3037
3038#if wxUSE_CARET
3039 // caret needs to be informed about focus change
3040 wxCaret *caret = GetCaret();
3041 if ( caret )
3042 {
3043 caret->OnSetFocus();
3044 }
3045#endif // wxUSE_CARET
3046
3047 // Notify the parent keeping track of focus for the kbd navigation
3048 // purposes that we got it.
b22bb1a0 3049 wxChildFocusEvent eventChildFocus(static_cast<wxWindow*>(this));
bd2e08d0
VS
3050 GTKProcessEvent(eventChildFocus);
3051
3052 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
3053 eventFocus.SetEventObject(this);
3054 GTKProcessEvent(eventFocus);
3055
3056 return retval;
ef5c70f9
VZ
3057}
3058
bd2e08d0 3059bool wxWindowGTK::GTKHandleFocusOut()
7cec1c9e 3060{
bd2e08d0
VS
3061 // Disable default focus handling for custom windows since the default GTK+
3062 // handler issues a repaint
3063 const bool retval = m_wxwindow ? true : false;
3064
3065
3066 // NB: If a control is composed of several GtkWidgets and when focus
3067 // changes from one of them to another within the same wxWindow, we get
3068 // a focus-out event followed by focus-in for another GtkWidget owned
3069 // by the same wx control. We don't want to generate two spurious
3070 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
3071 // from GTKHandleFocusOut() until we know for sure it's not coming back
3072 // (i.e. in GTKHandleFocusIn() or at idle time).
3073 if ( GTKNeedsToFilterSameWindowFocus() )
7cec1c9e 3074 {
bd2e08d0
VS
3075 wxASSERT_MSG( gs_deferredFocusOut == NULL,
3076 "deferred focus out event already pending" );
3077 wxLogTrace(TRACE_FOCUS,
3078 "deferring focus_out event for %s(%p, %s)",
3079 GetClassInfo()->GetClassName(), this, GetLabel());
3080 gs_deferredFocusOut = this;
3081 return retval;
7cec1c9e
RR
3082 }
3083
bd2e08d0
VS
3084 GTKHandleFocusOutNoDeferring();
3085
3086 return retval;
3087}
3088
3089void wxWindowGTK::GTKHandleFocusOutNoDeferring()
3090{
3091 wxLogTrace(TRACE_FOCUS,
3092 "handling focus_out event for %s(%p, %s)",
3093 GetClassInfo()->GetClassName(), this, GetLabel());
3094
3095 if (m_imData)
3096 gtk_im_context_focus_out(m_imData->context);
3097
22f43cb5 3098 if ( gs_currentFocus != this )
7cec1c9e 3099 {
22f43cb5 3100 // Something is terribly wrong, gs_currentFocus is out of sync with the
bd2e08d0
VS
3101 // real focus. We will reset it to NULL anyway, because after this
3102 // focus-out event is handled, one of the following with happen:
3103 //
3104 // * either focus will go out of the app altogether, in which case
22f43cb5 3105 // gs_currentFocus _should_ be NULL
bd2e08d0
VS
3106 //
3107 // * or it goes to another control, in which case focus-in event will
22f43cb5 3108 // follow immediately and it will set gs_currentFocus to the right
bd2e08d0
VS
3109 // value
3110 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3111 GetClassInfo()->GetClassName(), this, GetLabel());
3112 }
22f43cb5 3113 gs_currentFocus = NULL;
db885f2a 3114
bd2e08d0
VS
3115#if wxUSE_CARET
3116 // caret needs to be informed about focus change
3117 wxCaret *caret = GetCaret();
3118 if ( caret )
3119 {
3120 caret->OnKillFocus();
354aa1e3 3121 }
bd2e08d0
VS
3122#endif // wxUSE_CARET
3123
3124 wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3125 event.SetEventObject( this );
3126 GTKProcessEvent( event );
3127}
3128
3129/*static*/
3130void wxWindowGTK::GTKHandleDeferredFocusOut()
3131{
3132 // NB: See GTKHandleFocusOut() for explanation. This function is called
3133 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3134 // deferred event.
3135 if ( gs_deferredFocusOut )
c801d85f 3136 {
bd2e08d0
VS
3137 wxWindowGTK *win = gs_deferredFocusOut;
3138 gs_deferredFocusOut = NULL;
db885f2a 3139
bd2e08d0
VS
3140 wxLogTrace(TRACE_FOCUS,
3141 "processing deferred focus_out event for %s(%p, %s)",
3142 win->GetClassInfo()->GetClassName(), win, win->GetLabel());
fcb29b23 3143
bd2e08d0
VS
3144 win->GTKHandleFocusOutNoDeferring();
3145 }
3146}
0a164d4c 3147
bd2e08d0
VS
3148void wxWindowGTK::SetFocus()
3149{
3150 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
6aeb6f2a 3151
bd2e08d0
VS
3152 // Setting "physical" focus is not immediate in GTK+ and while
3153 // gtk_widget_is_focus ("determines if the widget is the focus widget
3154 // within its toplevel", i.e. returns true for one widget per TLW, not
3155 // globally) returns true immediately after grabbing focus,
3156 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3157 // has focus at the moment) takes affect only after the window is shown
3158 // (if it was hidden at the moment of the call) or at the next event loop
3159 // iteration.
3160 //
3161 // Because we want to FindFocus() call immediately following
3162 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3163 // ourselves.
22f43cb5 3164 gs_pendingFocus = this;
bd2e08d0
VS
3165
3166 GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3167
3168 if ( GTK_IS_CONTAINER(widget) &&
3169 !GTK_WIDGET_CAN_FOCUS(widget) )
3170 {
3171 wxLogTrace(TRACE_FOCUS,
9a83f860 3172 wxT("Setting focus to a child of %s(%p, %s)"),
bd2e08d0
VS
3173 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3174 gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3175 }
3176 else
3177 {
3178 wxLogTrace(TRACE_FOCUS,
9a83f860 3179 wxT("Setting focus to %s(%p, %s)"),
bd2e08d0
VS
3180 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3181 gtk_widget_grab_focus(widget);
362c6693 3182 }
362c6693 3183}
c801d85f 3184
80332672
VZ
3185void wxWindowGTK::SetCanFocus(bool canFocus)
3186{
3187 if ( canFocus )
3188 GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
3189 else
3190 GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
3191
3192 if ( m_wxwindow && (m_widget != m_wxwindow) )
3193 {
3194 if ( canFocus )
3195 GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3196 else
3197 GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3198 }
3199}
3200
1e6feb95 3201bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
463c1fa1 3202{
0a164d4c 3203 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
c50f1fb9 3204
1e6feb95
VZ
3205 wxWindowGTK *oldParent = m_parent,
3206 *newParent = (wxWindowGTK *)newParentBase;
a2053b27 3207
5fd11f09
RR
3208 wxASSERT( GTK_IS_WIDGET(m_widget) );
3209
f03fc89f 3210 if ( !wxWindowBase::Reparent(newParent) )
0a164d4c 3211 return false;
8bbe427f 3212
5fd11f09
RR
3213 wxASSERT( GTK_IS_WIDGET(m_widget) );
3214
8ce63e9d 3215 if (oldParent)
3017f78d 3216 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
c50f1fb9 3217
5fd11f09
RR
3218 wxASSERT( GTK_IS_WIDGET(m_widget) );
3219
8ce63e9d
RR
3220 if (newParent)
3221 {
f46ad98f
RR
3222 if (GTK_WIDGET_VISIBLE (newParent->m_widget))
3223 {
3224 m_showOnIdle = true;
3225 gtk_widget_hide( m_widget );
3226 }
8ce63e9d 3227 /* insert GTK representation */
48200154 3228 newParent->AddChildGTK(this);
8ce63e9d 3229 }
c50f1fb9 3230
978af864 3231 SetLayoutDirection(wxLayout_Default);
148cd9b6 3232
0a164d4c 3233 return true;
362c6693 3234}
c801d85f 3235
1e6feb95 3236void wxWindowGTK::DoAddChild(wxWindowGTK *child)
ddb6bc71 3237{
223d09f6 3238 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
223d09f6 3239 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
ddb6bc71 3240
ddb6bc71
RR
3241 /* add to list */
3242 AddChild( child );
c50f1fb9 3243
ddb6bc71 3244 /* insert GTK representation */
48200154 3245 AddChildGTK(child);
ddb6bc71
RR
3246}
3247
a589495e
VS
3248void wxWindowGTK::AddChild(wxWindowBase *child)
3249{
3250 wxWindowBase::AddChild(child);
3251 m_dirtyTabOrder = true;
a1abca32 3252 wxTheApp->WakeUpIdle();
a589495e
VS
3253}
3254
3255void wxWindowGTK::RemoveChild(wxWindowBase *child)
3256{
3257 wxWindowBase::RemoveChild(child);
3258 m_dirtyTabOrder = true;
a1abca32 3259 wxTheApp->WakeUpIdle();
a589495e 3260}
0a164d4c 3261
978af864
VZ
3262/* static */
3263wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3264{
10bd1f7d 3265 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
978af864
VZ
3266 ? wxLayout_RightToLeft
3267 : wxLayout_LeftToRight;
3268}
3269
3270/* static */
3271void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3272{
9a83f860 3273 wxASSERT_MSG( dir != wxLayout_Default, wxT("invalid layout direction") );
978af864 3274
10bd1f7d 3275 gtk_widget_set_direction(widget,
978af864
VZ
3276 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3277 : GTK_TEXT_DIR_LTR);
3278}
3279
3280wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3281{
3282 return GTKGetLayout(m_widget);
3283}
3284
3285void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3286{
3287 if ( dir == wxLayout_Default )
3288 {
3289 const wxWindow *const parent = GetParent();
3290 if ( parent )
3291 {
3292 // inherit layout from parent.
3293 dir = parent->GetLayoutDirection();
3294 }
3295 else // no parent, use global default layout
3296 {
3297 dir = wxTheApp->GetLayoutDirection();
3298 }
3299 }
3300
3301 if ( dir == wxLayout_Default )
3302 return;
3303
3304 GTKSetLayout(m_widget, dir);
fcb29b23 3305
6552c7af 3306 if (m_wxwindow && (m_wxwindow != m_widget))
69597639
RR
3307 GTKSetLayout(m_wxwindow, dir);
3308}
3309
3310wxCoord
3311wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3312 wxCoord WXUNUSED(width),
3313 wxCoord WXUNUSED(widthTotal)) const
3314{
08f53168 3315 // We now mirror the coordinates of RTL windows in wxPizza
69597639 3316 return x;
978af864
VZ
3317}
3318
915bd4e4 3319void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
a589495e
VS
3320{
3321 wxWindowBase::DoMoveInTabOrder(win, move);
3322 m_dirtyTabOrder = true;
a1abca32 3323 wxTheApp->WakeUpIdle();
a589495e
VS
3324}
3325
5644933f
VZ
3326bool wxWindowGTK::DoNavigateIn(int flags)
3327{
3328 if ( flags & wxNavigationKeyEvent::WinChange )
3329 {
9a83f860 3330 wxFAIL_MSG( wxT("not implemented") );
5644933f
VZ
3331
3332 return false;
3333 }
3334 else // navigate inside the container
3335 {
7a3ba5af 3336 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
9a83f860 3337 wxCHECK_MSG( parent, false, wxT("every window must have a TLW parent") );
5644933f
VZ
3338
3339 GtkDirectionType dir;
3340 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3341 : GTK_DIR_TAB_BACKWARD;
3342
3343 gboolean rc;
3344 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3345
3346 return rc == TRUE;
3347 }
3348}
3349
2e1f5012
VZ
3350bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3351{
3352 // none needed by default
3353 return false;
3354}
3355
3356void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3357{
3358 // nothing to do by default since none is needed
3359}
3360
a589495e
VS
3361void wxWindowGTK::RealizeTabOrder()
3362{
3363 if (m_wxwindow)
3364 {
12848fda 3365 if ( !m_children.empty() )
a589495e 3366 {
259858fc 3367 // we don't only construct the correct focus chain but also use
2e1f5012
VZ
3368 // this opportunity to update the mnemonic widgets for the widgets
3369 // that need them
259858fc 3370
a589495e 3371 GList *chain = NULL;
2e1f5012 3372 wxWindowGTK* mnemonicWindow = NULL;
0a164d4c 3373
12848fda
VZ
3374 for ( wxWindowList::const_iterator i = m_children.begin();
3375 i != m_children.end();
3376 ++i )
a589495e 3377 {
259858fc 3378 wxWindowGTK *win = *i;
2e1f5012
VZ
3379
3380 if ( mnemonicWindow )
259858fc
VZ
3381 {
3382 if ( win->AcceptsFocusFromKeyboard() )
3383 {
2e1f5012
VZ
3384 // wxComboBox et al. needs to focus on on a different
3385 // widget than m_widget, so if the main widget isn't
3386 // focusable try the connect widget
3387 GtkWidget* w = win->m_widget;
3388 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3389 {
3390 w = win->GetConnectWidget();
3391 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3392 w = NULL;
3393 }
3394
3395 if ( w )
3396 {
3397 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3398 mnemonicWindow = NULL;
3399 }
259858fc
VZ
3400 }
3401 }
2e1f5012 3402 else if ( win->GTKWidgetNeedsMnemonic() )
259858fc 3403 {
2e1f5012 3404 mnemonicWindow = win;
259858fc 3405 }
259858fc
VZ
3406
3407 chain = g_list_prepend(chain, win->m_widget);
a589495e 3408 }
0a164d4c 3409
a589495e 3410 chain = g_list_reverse(chain);
0a164d4c 3411
a589495e
VS
3412 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3413 g_list_free(chain);
3414 }
12848fda 3415 else // no children
a589495e
VS
3416 {
3417 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3418 }
3419 }
a589495e
VS
3420}
3421
1e6feb95 3422void wxWindowGTK::Raise()
362c6693 3423{
82b978d7
RD
3424 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3425
fdfb8475
RR
3426 if (m_wxwindow && m_wxwindow->window)
3427 {
3428 gdk_window_raise( m_wxwindow->window );
3429 }
0a164d4c 3430 else if (m_widget->window)
fdfb8475
RR
3431 {
3432 gdk_window_raise( m_widget->window );
3433 }
362c6693
RR
3434}
3435
1e6feb95 3436void wxWindowGTK::Lower()
362c6693 3437{
82b978d7
RD
3438 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3439
fdfb8475
RR
3440 if (m_wxwindow && m_wxwindow->window)
3441 {
3442 gdk_window_lower( m_wxwindow->window );
3443 }
0a164d4c 3444 else if (m_widget->window)
fdfb8475
RR
3445 {
3446 gdk_window_lower( m_widget->window );
3447 }
362c6693 3448}
c801d85f 3449
1e6feb95 3450bool wxWindowGTK::SetCursor( const wxCursor &cursor )
86b29a61 3451{
fe282c08 3452 if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
2f262021 3453 return false;
f6bcfd97 3454
2f262021 3455 GTKUpdateCursor();
1e6feb95 3456
2f262021 3457 return true;
ef5c70f9
VZ
3458}
3459
c2246a38 3460void wxWindowGTK::GTKUpdateCursor(bool update_self /*=true*/, bool recurse /*=true*/)
ef5c70f9 3461{
c2246a38 3462 if (update_self)
ef5c70f9 3463 {
c2246a38
RR
3464 wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
3465 if ( cursor.Ok() )
ef5c70f9 3466 {
9c76b9af
RR
3467 wxArrayGdkWindows windowsThis;
3468 GdkWindow* window = GTKGetWindow(windowsThis);
3469 if (window)
3470 gdk_window_set_cursor( window, cursor.GetCursor() );
3471 else
ef5c70f9 3472 {
9c76b9af
RR
3473 const size_t count = windowsThis.size();
3474 for ( size_t n = 0; n < count; n++ )
5dd7eef7 3475 {
9c76b9af
RR
3476 GdkWindow *win = windowsThis[n];
3477 // It can be zero if the window has not been realized yet.
3478 if ( win )
c2246a38 3479 {
c2246a38
RR
3480 gdk_window_set_cursor(win, cursor.GetCursor());
3481 }
5dd7eef7 3482 }
c2246a38
RR
3483 }
3484 }
3485 }
3486
3487 if (recurse)
3488 {
3489 for (wxWindowList::iterator it = GetChildren().begin(); it != GetChildren().end(); ++it)
3490 {
3491 (*it)->GTKUpdateCursor( true );
ef5c70f9
VZ
3492 }
3493 }
362c6693 3494}
c801d85f 3495
1e6feb95 3496void wxWindowGTK::WarpPointer( int x, int y )
4f22cf8d 3497{
82b978d7
RD
3498 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3499
3bcc8d15
RR
3500 // We provide this function ourselves as it is
3501 // missing in GDK (top of this file).
148cd9b6 3502
d3b9f782 3503 GdkWindow *window = NULL;
ed673c6a 3504 if (m_wxwindow)
08f53168 3505 window = m_wxwindow->window;
ed673c6a
RR
3506 else
3507 window = GetConnectWidget()->window;
148cd9b6 3508
ed673c6a
RR
3509 if (window)
3510 gdk_window_warp_pointer( window, x, y );
4f22cf8d
RR
3511}
3512
22c9b211 3513wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
0c131a5a 3514{
22c9b211
VZ
3515 // find the scrollbar which generated the event
3516 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
0c131a5a 3517 {
22c9b211
VZ
3518 if ( range == m_scrollBar[dir] )
3519 return (ScrollDir)dir;
0c131a5a 3520 }
22c9b211 3521
9a83f860 3522 wxFAIL_MSG( wxT("event from unknown scrollbar received") );
22c9b211
VZ
3523
3524 return ScrollDir_Max;
0c131a5a
VZ
3525}
3526
22c9b211 3527bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
0c131a5a 3528{
add7cadd 3529 bool changed = false;
22c9b211
VZ
3530 GtkRange* range = m_scrollBar[dir];
3531 if ( range && units )
add7cadd
PC
3532 {
3533 GtkAdjustment* adj = range->adjustment;
22c9b211
VZ
3534 gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
3535 : adj->page_increment;
3536
3537 const int posOld = int(adj->value + 0.5);
3538 gtk_range_set_value(range, posOld + units*inc);
3539
3540 changed = int(adj->value + 0.5) != posOld;
add7cadd 3541 }
22c9b211 3542
add7cadd 3543 return changed;
0c131a5a 3544}
3013a903 3545
22c9b211
VZ
3546bool wxWindowGTK::ScrollLines(int lines)
3547{
3548 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3549}
3550
3551bool wxWindowGTK::ScrollPages(int pages)
3552{
3553 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3554}
3555
e4161a2a
VZ
3556void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3557 const wxRect *rect)
c801d85f 3558{
b4857be3
VZ
3559 if ( !m_widget )
3560 {
3561 // it is valid to call Refresh() for a window which hasn't been created
3562 // yet, it simply doesn't do anything in this case
3563 return;
3564 }
08bbdb08 3565
d0285203 3566 if (!m_wxwindow)
ba86da30 3567 {
d0285203
RR
3568 if (rect)
3569 gtk_widget_queue_draw_area( m_widget, rect->x, rect->y, rect->width, rect->height );
3570 else
3571 gtk_widget_queue_draw( m_widget );
ba86da30 3572 }
6cab4fca 3573 else
4e5a4c69 3574 {
d0285203
RR
3575 // Just return if the widget or one of its ancestors isn't mapped
3576 GtkWidget *w;
3577 for (w = m_wxwindow; w != NULL; w = w->parent)
3578 if (!GTK_WIDGET_MAPPED (w))
3579 return;
3580
f089940f 3581 GdkWindow* window = GTKGetDrawingWindow();
d0285203
RR
3582 if (rect)
3583 {
3584 int x = rect->x;
3585 if (GetLayoutDirection() == wxLayout_RightToLeft)
3586 x = GetClientSize().x - x - rect->width;
3587 GdkRectangle r;
3588 r.x = rect->x;
3589 r.y = rect->y;
3590 r.width = rect->width;
3591 r.height = rect->height;
f089940f 3592 gdk_window_invalidate_rect(window, &r, true);
d0285203
RR
3593 }
3594 else
f089940f 3595 gdk_window_invalidate_rect(window, NULL, true);
4e5a4c69 3596 }
362c6693 3597}
c801d85f 3598
beab25bd 3599void wxWindowGTK::Update()
010afced 3600{
f089940f 3601 if (m_widget && GTK_WIDGET_MAPPED(m_widget))
ab0c1a3c
PC
3602 {
3603 GdkDisplay* display = gtk_widget_get_display(m_widget);
3604 // Flush everything out to the server, and wait for it to finish.
3605 // This ensures nothing will overwrite the drawing we are about to do.
3606 gdk_display_sync(display);
010afced 3607
f089940f
PC
3608 GdkWindow* window = GTKGetDrawingWindow();
3609 if (window == NULL)
3610 window = m_widget->window;
3611 gdk_window_process_updates(window, true);
03647350 3612
6cab4fca
PC
3613 // Flush again, but no need to wait for it to finish
3614 gdk_display_flush(display);
a67f1484 3615 }
beab25bd
RR
3616}
3617
657b4fd4 3618bool wxWindowGTK::DoIsExposed( int x, int y ) const
847dfdb4
RR
3619{
3620 return m_updateRegion.Contains(x, y) != wxOutRegion;
3621}
3622
657b4fd4 3623bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
847dfdb4
RR
3624{
3625 if (GetLayoutDirection() == wxLayout_RightToLeft)
3626 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3627 else
3628 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3629}
3630
beab25bd
RR
3631void wxWindowGTK::GtkSendPaintEvents()
3632{
3bcc8d15
RR
3633 if (!m_wxwindow)
3634 {
3bcc8d15
RR
3635 m_updateRegion.Clear();
3636 return;
3637 }
beab25bd 3638
f90566f5 3639 // Clip to paint region in wxClientDC
0a164d4c 3640 m_clipPaintRegion = true;
fab591c5 3641
bcb614b3
RR
3642 m_nativeUpdateRegion = m_updateRegion;
3643
847dfdb4
RR
3644 if (GetLayoutDirection() == wxLayout_RightToLeft)
3645 {
bcb614b3
RR
3646 // Transform m_updateRegion under RTL
3647 m_updateRegion.Clear();
fcb29b23 3648
847dfdb4 3649 gint width;
08f53168 3650 gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
fcb29b23 3651
bcb614b3 3652 wxRegionIterator upd( m_nativeUpdateRegion );
847dfdb4
RR
3653 while (upd)
3654 {
3655 wxRect rect;
3656 rect.x = upd.GetX();
3657 rect.y = upd.GetY();
3658 rect.width = upd.GetWidth();
3659 rect.height = upd.GetHeight();
fcb29b23 3660
847dfdb4 3661 rect.x = width - rect.x - rect.width;
bcb614b3 3662 m_updateRegion.Union( rect );
fcb29b23 3663
847dfdb4
RR
3664 ++upd;
3665 }
3666 }
fcb29b23 3667
9c61c5b0 3668 switch ( GetBackgroundStyle() )
f90566f5 3669 {
9c61c5b0 3670 case wxBG_STYLE_ERASE:
822cf31c 3671 {
9c61c5b0
VZ
3672 wxWindowDC dc( (wxWindow*)this );
3673 dc.SetDeviceClippingRegion( m_updateRegion );
3674
3675 // Work around gtk-qt <= 0.60 bug whereby the window colour
3676 // remains grey
3677 if ( UseBgCol() &&
3678 wxSystemOptions::
3679 GetOptionInt("gtk.window.force-background-colour") )
3680 {
3681 dc.SetBackground(GetBackgroundColour());
3682 dc.Clear();
3683 }
3684
3685 wxEraseEvent erase_event( GetId(), &dc );
3686 erase_event.SetEventObject( this );
3687
3688 if ( HandleWindowEvent(erase_event) )
3689 {
3690 // background erased, don't do it again
3691 break;
3692 }
822cf31c 3693 }
9c61c5b0 3694 // fall through
b15ed747 3695
9c61c5b0
VZ
3696 case wxBG_STYLE_SYSTEM:
3697 if ( GetThemeEnabled() )
3698 {
3699 // find ancestor from which to steal background
3700 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3701 if (!parent)
3702 parent = (wxWindow*)this;
3703
3704 if (GTK_WIDGET_MAPPED(parent->m_widget))
3705 {
3706 wxRegionIterator upd( m_nativeUpdateRegion );
3707 while (upd)
3708 {
3709 GdkRectangle rect;
3710 rect.x = upd.GetX();
3711 rect.y = upd.GetY();
3712 rect.width = upd.GetWidth();
3713 rect.height = upd.GetHeight();
3714
3715 gtk_paint_flat_box( parent->m_widget->style,
f089940f 3716 GTKGetDrawingWindow(),
9c61c5b0
VZ
3717 (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3718 GTK_SHADOW_NONE,
3719 &rect,
3720 parent->m_widget,
3721 (char *)"base",
3722 0, 0, -1, -1 );
3723
3724 ++upd;
3725 }
3726 }
3727 }
3728 break;
8ab7b4c5 3729
9c61c5b0
VZ
3730 case wxBG_STYLE_PAINT:
3731 // nothing to do: window will be painted over in EVT_PAINT
3732 break;
b15ed747 3733
9c61c5b0
VZ
3734 default:
3735 wxFAIL_MSG( "unsupported background style" );
b15ed747 3736 }
03eaa52a 3737
beab25bd
RR
3738 wxNcPaintEvent nc_paint_event( GetId() );
3739 nc_paint_event.SetEventObject( this );
937013e0 3740 HandleWindowEvent( nc_paint_event );
03eaa52a 3741
beab25bd
RR
3742 wxPaintEvent paint_event( GetId() );
3743 paint_event.SetEventObject( this );
937013e0 3744 HandleWindowEvent( paint_event );
beab25bd 3745
0a164d4c 3746 m_clipPaintRegion = false;
c89f5c02 3747
c89f5c02 3748 m_updateRegion.Clear();
bcb614b3 3749 m_nativeUpdateRegion.Clear();
beab25bd
RR
3750}
3751
8e1a5bf9
VZ
3752void wxWindowGTK::SetDoubleBuffered( bool on )
3753{
3754 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3755
3756 if ( m_wxwindow )
3757 gtk_widget_set_double_buffered( m_wxwindow, on );
3758}
3759
2e992e06
VZ
3760bool wxWindowGTK::IsDoubleBuffered() const
3761{
3762 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
3763}
3764
596f1d11 3765void wxWindowGTK::ClearBackground()
c801d85f 3766{
82b978d7 3767 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
362c6693 3768}
c801d85f 3769
ff8bfdbb 3770#if wxUSE_TOOLTIPS
1e6feb95 3771void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
b1170810 3772{
f03fc89f 3773 wxWindowBase::DoSetToolTip(tip);
ff8bfdbb 3774
f03fc89f 3775 if (m_tooltip)
fb4b0165 3776 {
7fc8b9a4 3777 m_tooltip->GTKApply( (wxWindow *)this );
fb4b0165
MW
3778 }
3779 else
3780 {
3781 GtkWidget *w = GetConnectWidget();
3782 wxToolTip::GTKApply(w, NULL);
fb4b0165 3783 }
b1170810
RR
3784}
3785
7fc8b9a4 3786void wxWindowGTK::GTKApplyToolTip( GtkTooltips *tips, const gchar *tip )
b1170810 3787{
614a87df 3788 GtkWidget *w = GetConnectWidget();
614a87df
JS
3789
3790#if GTK_CHECK_VERSION(2, 12, 0)
85314957 3791 if (!gtk_check_version(2, 12, 0))
614a87df 3792 {
85314957 3793 gtk_widget_set_tooltip_text (w, tip);
614a87df 3794 }
85314957 3795 else
614a87df 3796#endif
85314957
VZ
3797 {
3798 gtk_tooltips_set_tip(tips, w, tip, NULL);
3799 }
301cd871 3800}
ff8bfdbb 3801#endif // wxUSE_TOOLTIPS
b1170810 3802
1e6feb95 3803bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
c801d85f 3804{
0a164d4c 3805 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
8bbe427f 3806
739730ca 3807 if (!wxWindowBase::SetBackgroundColour(colour))
44dfb5ce 3808 return false;
c50f1fb9 3809
5edef14e 3810 if (colour.Ok())
994bc575 3811 {
5edef14e
VS
3812 // We need the pixel value e.g. for background clearing.
3813 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
994bc575 3814 }
ca298c88 3815
5edef14e 3816 // apply style change (forceStyle=true so that new style is applied
c7382f91 3817 // even if the bg colour changed from valid to wxNullColour)
9c61c5b0 3818 GTKApplyWidgetStyle(true);
ea323db3 3819
5edef14e 3820 return true;
6de97a3b
RR
3821}
3822
1e6feb95 3823bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
6de97a3b 3824{
0a164d4c 3825 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
8bbe427f 3826
739730ca
RR
3827 if (!wxWindowBase::SetForegroundColour(colour))
3828 {
5edef14e 3829 return false;
739730ca 3830 }
0a164d4c 3831
5edef14e 3832 if (colour.Ok())
ea323db3 3833 {
5edef14e
VS
3834 // We need the pixel value e.g. for background clearing.
3835 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
ea323db3 3836 }
f03fc89f 3837
5edef14e
VS
3838 // apply style change (forceStyle=true so that new style is applied
3839 // even if the bg colour changed from valid to wxNullColour):
496e7ec6 3840 GTKApplyWidgetStyle(true);
5edef14e 3841
44dfb5ce 3842 return true;
58614078
RR
3843}
3844
496e7ec6 3845PangoContext *wxWindowGTK::GTKGetPangoDefaultContext()
2b5f62a0
VZ
3846{
3847 return gtk_widget_get_pango_context( m_widget );
3848}
0a164d4c 3849
496e7ec6 3850GtkRcStyle *wxWindowGTK::GTKCreateWidgetStyle(bool forceStyle)
58614078 3851{
f40fdaa3 3852 // do we need to apply any changes at all?
5edef14e 3853 if ( !forceStyle &&
984e8d0b
VS
3854 !m_font.Ok() &&
3855 !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
fb65642c 3856 {
f40fdaa3 3857 return NULL;
fb65642c
RR
3858 }
3859
f40fdaa3 3860 GtkRcStyle *style = gtk_rc_style_new();
1ecc4d80 3861
984e8d0b 3862 if ( m_font.Ok() )
db434467 3863 {
0a164d4c 3864 style->font_desc =
f40fdaa3 3865 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
288059b2 3866 }
1ecc4d80 3867
532ae0f6
VZ
3868 int flagsNormal = 0,
3869 flagsPrelight = 0,
3870 flagsActive = 0,
3871 flagsInsensitive = 0;
3872
fe161a26 3873 if ( m_foregroundColour.Ok() )
1ecc4d80 3874 {
c6685317 3875 const GdkColor *fg = m_foregroundColour.GetColor();
0a164d4c 3876
532ae0f6
VZ
3877 style->fg[GTK_STATE_NORMAL] =
3878 style->text[GTK_STATE_NORMAL] = *fg;
3879 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
0a164d4c 3880
532ae0f6
VZ
3881 style->fg[GTK_STATE_PRELIGHT] =
3882 style->text[GTK_STATE_PRELIGHT] = *fg;
3883 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
0a164d4c 3884
532ae0f6
VZ
3885 style->fg[GTK_STATE_ACTIVE] =
3886 style->text[GTK_STATE_ACTIVE] = *fg;
3887 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
1ecc4d80
RR
3888 }
3889
fe161a26 3890 if ( m_backgroundColour.Ok() )
1ecc4d80 3891 {
c6685317 3892 const GdkColor *bg = m_backgroundColour.GetColor();
5edef14e 3893
532ae0f6 3894 style->bg[GTK_STATE_NORMAL] =
5edef14e 3895 style->base[GTK_STATE_NORMAL] = *bg;
532ae0f6 3896 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
0a164d4c 3897
532ae0f6 3898 style->bg[GTK_STATE_PRELIGHT] =
5edef14e 3899 style->base[GTK_STATE_PRELIGHT] = *bg;
532ae0f6 3900 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
0a164d4c 3901
532ae0f6 3902 style->bg[GTK_STATE_ACTIVE] =
5edef14e 3903 style->base[GTK_STATE_ACTIVE] = *bg;
532ae0f6 3904 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
0a164d4c 3905
532ae0f6 3906 style->bg[GTK_STATE_INSENSITIVE] =
5edef14e 3907 style->base[GTK_STATE_INSENSITIVE] = *bg;
532ae0f6 3908 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
1ecc4d80 3909 }
0a164d4c 3910
532ae0f6
VZ
3911 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3912 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3913 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3914 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3915
f40fdaa3 3916 return style;
a81258be
RR
3917}
3918
496e7ec6 3919void wxWindowGTK::GTKApplyWidgetStyle(bool forceStyle)
a81258be 3920{
496e7ec6 3921 GtkRcStyle *style = GTKCreateWidgetStyle(forceStyle);
f8e045e2
RD
3922 if ( style )
3923 {
7074ce35 3924 DoApplyWidgetStyle(style);
f8e045e2
RD
3925 gtk_rc_style_unref(style);
3926 }
6dd18972
VS
3927
3928 // Style change may affect GTK+'s size calculation:
3929 InvalidateBestSize();
6de97a3b
RR
3930}
3931
7074ce35
VS
3932void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3933{
0d013e46
VZ
3934 if ( m_wxwindow )
3935 {
3936 // block the signal temporarily to avoid sending
3937 // wxSysColourChangedEvents when we change the colours ourselves
3938 bool unblock = false;
3939 if ( IsTopLevel() )
3940 {
3941 unblock = true;
3942 g_signal_handlers_block_by_func(
3943 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3944 }
013151c7 3945
7074ce35 3946 gtk_widget_modify_style(m_wxwindow, style);
0d013e46
VZ
3947
3948 if ( unblock )
3949 {
3950 g_signal_handlers_unblock_by_func(
3951 m_wxwindow, (void *)gtk_window_style_set_callback, this);
3952 }
3953 }
7cb93e45 3954 else
0d013e46 3955 {
7cb93e45 3956 gtk_widget_modify_style(m_widget, style);
0d013e46 3957 }
7074ce35
VS
3958}
3959
c7382f91
JS
3960bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3961{
3962 wxWindowBase::SetBackgroundStyle(style);
0a164d4c 3963
9c61c5b0 3964 if ( style == wxBG_STYLE_PAINT )
c7382f91 3965 {
788f9633
VZ
3966 GdkWindow *window;
3967 if ( m_wxwindow )
3968 {
f089940f 3969 window = GTKGetDrawingWindow();
788f9633 3970 }
c7382f91 3971 else
788f9633
VZ
3972 {
3973 GtkWidget * const w = GetConnectWidget();
3974 window = w ? w->window : NULL;
3975 }
c7382f91
JS
3976
3977 if (window)
3978 {
3979 // Make sure GDK/X11 doesn't refresh the window
3980 // automatically.
3981 gdk_window_set_back_pixmap( window, None, False );
3982#ifdef __X__
3983 Display* display = GDK_WINDOW_DISPLAY(window);
3984 XFlush(display);
3985#endif
3986 m_needsStyleChange = false;
3987 }
788f9633
VZ
3988 else // window not realized yet
3989 {
c7382f91
JS
3990 // Do in OnIdle, because the window is not yet available
3991 m_needsStyleChange = true;
788f9633 3992 }
0a164d4c 3993
c7382f91
JS
3994 // Don't apply widget style, or we get a grey background
3995 }
3996 else
3997 {
3998 // apply style change (forceStyle=true so that new style is applied
3999 // even if the bg colour changed from valid to wxNullColour):
496e7ec6 4000 GTKApplyWidgetStyle(true);
c7382f91 4001 }
9c61c5b0 4002
c7382f91
JS
4003 return true;
4004}
7074ce35 4005
bcf7614c
PC
4006// ----------------------------------------------------------------------------
4007// Pop-up menu stuff
4008// ----------------------------------------------------------------------------
4009
4010#if wxUSE_MENUS_NATIVE
4011
edd6813c
PC
4012extern "C" {
4013static
bcf7614c
PC
4014void wxPopupMenuPositionCallback( GtkMenu *menu,
4015 gint *x, gint *y,
4016 gboolean * WXUNUSED(whatever),
4017 gpointer user_data )
4018{
4019 // ensure that the menu appears entirely on screen
4020 GtkRequisition req;
4021 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4022
4023 wxSize sizeScreen = wxGetDisplaySize();
4024 wxPoint *pos = (wxPoint*)user_data;
4025
4026 gint xmax = sizeScreen.x - req.width,
4027 ymax = sizeScreen.y - req.height;
4028
4029 *x = pos->x < xmax ? pos->x : xmax;
4030 *y = pos->y < ymax ? pos->y : ymax;
4031}
edd6813c
PC
4032}
4033
bcf7614c
PC
4034bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4035{
4036 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4037
a1c6f069 4038 menu->UpdateUI();
bcf7614c
PC
4039
4040 wxPoint pos;
4041 gpointer userdata;
4042 GtkMenuPositionFunc posfunc;
4043 if ( x == -1 && y == -1 )
4044 {
4045 // use GTK's default positioning algorithm
4046 userdata = NULL;
4047 posfunc = NULL;
4048 }
4049 else
4050 {
4051 pos = ClientToScreen(wxPoint(x, y));
4052 userdata = &pos;
4053 posfunc = wxPopupMenuPositionCallback;
4054 }
4055
4056 menu->m_popupShown = true;
4057 gtk_menu_popup(
4058 GTK_MENU(menu->m_menu),
d3b9f782
VZ
4059 NULL, // parent menu shell
4060 NULL, // parent menu item
bcf7614c
PC
4061 posfunc, // function to position it
4062 userdata, // client data
4063 0, // button used to activate it
4064 gtk_get_current_event_time()
4065 );
4066
4067 while (menu->m_popupShown)
4068 {
4069 gtk_main_iteration();
4070 }
4071
4072 return true;
4073}
4074
4075#endif // wxUSE_MENUS_NATIVE
4076
06cfab17 4077#if wxUSE_DRAG_AND_DROP
ac57418f 4078
1e6feb95 4079void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
c801d85f 4080{
82b978d7
RD
4081 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4082
1ecc4d80 4083 GtkWidget *dnd_widget = GetConnectWidget();
47d67540 4084
1fe91d70 4085 if (m_dropTarget) m_dropTarget->GtkUnregisterWidget( dnd_widget );
47d67540 4086
1ecc4d80
RR
4087 if (m_dropTarget) delete m_dropTarget;
4088 m_dropTarget = dropTarget;
47d67540 4089
1fe91d70 4090 if (m_dropTarget) m_dropTarget->GtkRegisterWidget( dnd_widget );
362c6693 4091}
c801d85f 4092
f03fc89f 4093#endif // wxUSE_DRAG_AND_DROP
ac57418f 4094
1e6feb95 4095GtkWidget* wxWindowGTK::GetConnectWidget()
e3e65dac 4096{
1ecc4d80
RR
4097 GtkWidget *connect_widget = m_widget;
4098 if (m_wxwindow) connect_widget = m_wxwindow;
47d67540 4099
1ecc4d80 4100 return connect_widget;
e3e65dac 4101}
47d67540 4102
ef5c70f9 4103bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
903f689b 4104{
ef5c70f9
VZ
4105 wxArrayGdkWindows windowsThis;
4106 GdkWindow * const winThis = GTKGetWindow(windowsThis);
148cd9b6 4107
ef5c70f9
VZ
4108 return winThis ? window == winThis
4109 : windowsThis.Index(window) != wxNOT_FOUND;
4110}
4111
4112GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
4113{
f089940f 4114 return m_wxwindow ? GTKGetDrawingWindow() : m_widget->window;
903f689b
RR
4115}
4116
1e6feb95 4117bool wxWindowGTK::SetFont( const wxFont &font )
c801d85f 4118{
0a164d4c 4119 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
9c288e4d 4120
5edef14e
VS
4121 if (!wxWindowBase::SetFont(font))
4122 return false;
c801d85f 4123
5edef14e
VS
4124 // apply style change (forceStyle=true so that new style is applied
4125 // even if the font changed from valid to wxNullFont):
496e7ec6 4126 GTKApplyWidgetStyle(true);
5edef14e
VS
4127
4128 return true;
362c6693 4129}
c801d85f 4130
94633ad9 4131void wxWindowGTK::DoCaptureMouse()
c801d85f 4132{
82b978d7
RD
4133 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4134
d3b9f782 4135 GdkWindow *window = NULL;
b231914f 4136 if (m_wxwindow)
f089940f 4137 window = GTKGetDrawingWindow();
ed673c6a 4138 else
b231914f 4139 window = GetConnectWidget()->window;
148cd9b6 4140
9a83f860 4141 wxCHECK_RET( window, wxT("CaptureMouse() failed") );
c50f1fb9 4142
f516d986 4143 const wxCursor* cursor = &m_cursor;
cca602ac
JS
4144 if (!cursor->Ok())
4145 cursor = wxSTANDARD_CURSOR;
4146
ed673c6a 4147 gdk_pointer_grab( window, FALSE,
1ecc4d80
RR
4148 (GdkEventMask)
4149 (GDK_BUTTON_PRESS_MASK |
4150 GDK_BUTTON_RELEASE_MASK |
148cd9b6 4151 GDK_POINTER_MOTION_HINT_MASK |
1ecc4d80 4152 GDK_POINTER_MOTION_MASK),
d3b9f782 4153 NULL,
cca602ac 4154 cursor->GetCursor(),
b02da6b1 4155 (guint32)GDK_CURRENT_TIME );
b231914f 4156 g_captureWindow = this;
0a164d4c 4157 g_captureWindowHasMouse = true;
362c6693 4158}
c801d85f 4159
94633ad9 4160void wxWindowGTK::DoReleaseMouse()
c801d85f 4161{
82b978d7
RD
4162 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4163
e4606ed9 4164 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
47d67540 4165
d3b9f782 4166 g_captureWindow = NULL;
c43430bb 4167
d3b9f782 4168 GdkWindow *window = NULL;
b231914f 4169 if (m_wxwindow)
f089940f 4170 window = GTKGetDrawingWindow();
ed673c6a 4171 else
b231914f 4172 window = GetConnectWidget()->window;
148cd9b6 4173
b02da6b1
VZ
4174 if (!window)
4175 return;
c50f1fb9 4176
b02da6b1 4177 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
362c6693 4178}
c801d85f 4179
7738af59
VZ
4180void wxWindowGTK::GTKReleaseMouseAndNotify()
4181{
4182 DoReleaseMouse();
4183 wxMouseCaptureLostEvent evt(GetId());
4184 evt.SetEventObject( this );
937013e0 4185 HandleWindowEvent( evt );
7738af59
VZ
4186}
4187
1e6feb95
VZ
4188/* static */
4189wxWindow *wxWindowBase::GetCapture()
4190{
4191 return (wxWindow *)g_captureWindow;
4192}
4193
4194bool wxWindowGTK::IsRetained() const
c801d85f 4195{
0a164d4c 4196 return false;
362c6693 4197}
c801d85f 4198
22c9b211
VZ
4199void wxWindowGTK::SetScrollbar(int orient,
4200 int pos,
4201 int thumbVisible,
4202 int range,
4203 bool WXUNUSED(update))
c801d85f 4204{
63c95f27
PC
4205 const int dir = ScrollDirFromOrient(orient);
4206 GtkRange* const sb = m_scrollBar[dir];
9a83f860 4207 wxCHECK_RET( sb, wxT("this window is not scrollable") );
c801d85f 4208
8466fc74 4209 if (range <= 0)
de7bb802
PC
4210 {
4211 // GtkRange requires upper > lower
4212 range =
4213 thumbVisible = 1;
4214 }
47d67540 4215
b9e7f011 4216 GtkAdjustment * const adj = sb->adjustment;
add7cadd 4217 adj->step_increment = 1;
35510e48 4218 adj->page_increment =
add7cadd 4219 adj->page_size = thumbVisible;
63c95f27
PC
4220 adj->value = pos;
4221
4222 g_signal_handlers_block_by_func(
4223 sb, (void*)gtk_scrollbar_value_changed, this);
4224
4225 gtk_range_set_range(sb, 0, range);
4226 m_scrollPos[dir] = sb->adjustment->value;
4227
4228 g_signal_handlers_unblock_by_func(
4229 sb, (void*)gtk_scrollbar_value_changed, this);
87a3ebe9
VZ
4230}
4231
22c9b211 4232void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
c801d85f 4233{
b9e7f011
VZ
4234 const int dir = ScrollDirFromOrient(orient);
4235 GtkRange * const sb = m_scrollBar[dir];
9a83f860 4236 wxCHECK_RET( sb, wxT("this window is not scrollable") );
1ecc4d80 4237
add7cadd
PC
4238 // This check is more than an optimization. Without it, the slider
4239 // will not move smoothly while tracking when using wxScrollHelper.
4240 if (GetScrollPos(orient) != pos)
47d67540 4241 {
63c95f27
PC
4242 g_signal_handlers_block_by_func(
4243 sb, (void*)gtk_scrollbar_value_changed, this);
40e5ebbf 4244
63c95f27
PC
4245 gtk_range_set_value(sb, pos);
4246 m_scrollPos[dir] = sb->adjustment->value;
98264520 4247
63c95f27
PC
4248 g_signal_handlers_unblock_by_func(
4249 sb, (void*)gtk_scrollbar_value_changed, this);
cb43b372 4250 }
362c6693 4251}
c801d85f 4252
22c9b211 4253int wxWindowGTK::GetScrollThumb(int orient) const
c801d85f 4254{
b9e7f011 4255 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
9a83f860 4256 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
47d67540 4257
40b849aa 4258 return wxRound(sb->adjustment->page_size);
362c6693 4259}
c801d85f 4260
1e6feb95 4261int wxWindowGTK::GetScrollPos( int orient ) const
c801d85f 4262{
b9e7f011 4263 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
9a83f860 4264 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
c801d85f 4265
40b849aa 4266 return wxRound(sb->adjustment->value);
362c6693 4267}
c801d85f 4268
1e6feb95 4269int wxWindowGTK::GetScrollRange( int orient ) const
c801d85f 4270{
b9e7f011 4271 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
9a83f860 4272 wxCHECK_MSG( sb, 0, wxT("this window is not scrollable") );
c801d85f 4273
40b849aa 4274 return wxRound(sb->adjustment->upper);
add7cadd
PC
4275}
4276
4277// Determine if increment is the same as +/-x, allowing for some small
4278// difference due to possible inexactness in floating point arithmetic
4279static inline bool IsScrollIncrement(double increment, double x)
4280{
4281 wxASSERT(increment > 0);
4282 const double tolerance = 1.0 / 1024;
4283 return fabs(increment - fabs(x)) < tolerance;
4284}
4285
71ead4bf 4286wxEventType wxWindowGTK::GTKGetScrollEventType(GtkRange* range)
add7cadd 4287{
add7cadd
PC
4288 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4289
4290 const int barIndex = range == m_scrollBar[1];
4291 GtkAdjustment* adj = range->adjustment;
fcb29b23 4292
40b849aa 4293 const int value = wxRound(adj->value);
fcb29b23 4294
add7cadd
PC
4295 // save previous position
4296 const double oldPos = m_scrollPos[barIndex];
4297 // update current position
4298 m_scrollPos[barIndex] = adj->value;
4299 // If event should be ignored, or integral position has not changed
40b849aa 4300 if (!m_hasVMT || g_blockEventsOnDrag || value == wxRound(oldPos))
add7cadd
PC
4301 {
4302 return wxEVT_NULL;
4303 }
4304
4305 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4306 if (!m_isScrolling)
4307 {
4308 // Difference from last change event
4309 const double diff = adj->value - oldPos;
4310 const bool isDown = diff > 0;
4311
4312 if (IsScrollIncrement(adj->step_increment, diff))
4313 {
4314 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4315 }
4316 else if (IsScrollIncrement(adj->page_increment, diff))
4317 {
4318 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4319 }
4320 else if (m_mouseButtonDown)
4321 {
4322 // Assume track event
4323 m_isScrolling = true;
4324 }
4325 }
4326 return eventType;
362c6693 4327}
c801d85f 4328
1e6feb95 4329void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
c801d85f 4330{
82b978d7
RD
4331 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4332
223d09f6 4333 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
2b5f62a0 4334
f47ae6e7 4335 // No scrolling requested.
8e217128 4336 if ((dx == 0) && (dy == 0)) return;
35510e48 4337
0a164d4c 4338 m_clipPaintRegion = true;
0fc5dbf5 4339
08f53168 4340 WX_PIZZA(m_wxwindow)->scroll(dx, dy);
0fc5dbf5 4341
0a164d4c 4342 m_clipPaintRegion = false;
113faca1 4343
231018bd 4344#if wxUSE_CARET
113faca1
JS
4345 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4346 if (restoreCaret)
4347 {
4348 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4349 if (dx > 0)
4350 caretRect.width += dx;
4351 else
fcb29b23 4352 {
113faca1 4353 caretRect.x += dx; caretRect.width -= dx;
fcb29b23 4354 }
113faca1
JS
4355 if (dy > 0)
4356 caretRect.height += dy;
4357 else
fcb29b23 4358 {
113faca1 4359 caretRect.y += dy; caretRect.height -= dy;
fcb29b23
VZ
4360 }
4361
113faca1
JS
4362 RefreshRect(caretRect);
4363 }
fcb29b23 4364#endif // wxUSE_CARET
c801d85f 4365}
3723b7b1 4366
496e7ec6 4367void wxWindowGTK::GTKScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
6493aaca
VZ
4368{
4369 //RN: Note that static controls usually have no border on gtk, so maybe
88a7a4e1 4370 //it makes sense to treat that as simply no border at the wx level
6493aaca
VZ
4371 //as well...
4372 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4373 {
4374 GtkShadowType gtkstyle;
88a7a4e1 4375
6493aaca
VZ
4376 if(wxstyle & wxBORDER_RAISED)
4377 gtkstyle = GTK_SHADOW_OUT;
ec2d6790 4378 else if ((wxstyle & wxBORDER_SUNKEN) || (wxstyle & wxBORDER_THEME))
6493aaca 4379 gtkstyle = GTK_SHADOW_IN;
78cd9c69
JS
4380#if 0
4381 // Now obsolete
6493aaca
VZ
4382 else if (wxstyle & wxBORDER_DOUBLE)
4383 gtkstyle = GTK_SHADOW_ETCHED_IN;
78cd9c69 4384#endif
6493aaca
VZ
4385 else //default
4386 gtkstyle = GTK_SHADOW_IN;
4387
88a7a4e1 4388 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
6493aaca
VZ
4389 gtkstyle );
4390 }
4391}
4392
015dca24
MR
4393void wxWindowGTK::SetWindowStyleFlag( long style )
4394{
4395 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4396 wxWindowBase::SetWindowStyleFlag(style);
4397}
4e5a4c69 4398
3723b7b1
JS
4399// Find the wxWindow at the current mouse position, also returning the mouse
4400// position.
4401wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4402{
59a12e90
JS
4403 pt = wxGetMousePosition();
4404 wxWindow* found = wxFindWindowAtPoint(pt);
4405 return found;
3723b7b1
JS
4406}
4407
4408// Get the current mouse position.
4409wxPoint wxGetMousePosition()
4410{
59a12e90
JS
4411 /* This crashes when used within wxHelpContext,
4412 so we have to use the X-specific implementation below.
4413 gint x, y;
4414 GdkModifierType *mask;
4415 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4416
4417 return wxPoint(x, y);
4418 */
4419
3723b7b1
JS
4420 int x, y;
4421 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
59a12e90 4422
37d81cc2 4423 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
59a12e90
JS
4424 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4425 Window rootReturn, childReturn;
4426 int rootX, rootY, winX, winY;
4427 unsigned int maskReturn;
4428
4429 XQueryPointer (display,
5cd09f0b
RR
4430 rootWindow,
4431 &rootReturn,
59a12e90
JS
4432 &childReturn,
4433 &rootX, &rootY, &winX, &winY, &maskReturn);
4434 return wxPoint(rootX, rootY);
4435
3723b7b1
JS
4436}
4437
08f53168
PC
4438GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4439{
4440 GdkWindow* window = NULL;
4441 if (m_wxwindow)
375efc1f 4442 window = m_wxwindow->window;
08f53168
PC
4443 return window;
4444}
5f346ddc
VS
4445
4446// ----------------------------------------------------------------------------
4447// freeze/thaw
4448// ----------------------------------------------------------------------------
4449
89267fe5
VS
4450extern "C"
4451{
4452
4453// this is called if we attempted to freeze unrealized widget when it finally
4454// is realized (and so can be frozen):
f089940f 4455static void wx_frozen_widget_realize(GtkWidget* w, wxWindowGTK* win)
89267fe5
VS
4456{
4457 wxASSERT( w && !GTK_WIDGET_NO_WINDOW(w) );
4458 wxASSERT( GTK_WIDGET_REALIZED(w) );
4459
4460 g_signal_handlers_disconnect_by_func
4461 (
4462 w,
4463 (void*)wx_frozen_widget_realize,
f089940f 4464 win
89267fe5
VS
4465 );
4466
9914bfbb
PC
4467 GdkWindow* window = w->window;
4468 if (w == win->m_wxwindow)
4469 window = win->GTKGetDrawingWindow();
f089940f 4470 gdk_window_freeze_updates(window);
89267fe5
VS
4471}
4472
4473} // extern "C"
4474
5f346ddc
VS
4475void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4476{
89267fe5
VS
4477 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4478 return; // window-less widget, cannot be frozen
4479
4480 if ( !GTK_WIDGET_REALIZED(w) )
4481 {
4482 // we can't thaw unrealized widgets because they don't have GdkWindow,
4483 // so set it up to be done immediately after realization:
4484 g_signal_connect_after
4485 (
4486 w,
4487 "realize",
4488 G_CALLBACK(wx_frozen_widget_realize),
f089940f 4489 this
89267fe5
VS
4490 );
4491 return;
4492 }
4493
9914bfbb
PC
4494 GdkWindow* window = w->window;
4495 if (w == m_wxwindow)
4496 window = GTKGetDrawingWindow();
f089940f 4497 gdk_window_freeze_updates(window);
5f346ddc
VS
4498}
4499
4500void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4501{
89267fe5
VS
4502 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4503 return; // window-less widget, cannot be frozen
4504
4505 if ( !GTK_WIDGET_REALIZED(w) )
4506 {
4507 // the widget wasn't realized yet, no need to thaw
4508 g_signal_handlers_disconnect_by_func
4509 (
4510 w,
4511 (void*)wx_frozen_widget_realize,
f089940f 4512 this
89267fe5
VS
4513 );
4514 return;
4515 }
4516
9914bfbb
PC
4517 GdkWindow* window = w->window;
4518 if (w == m_wxwindow)
4519 window = GTKGetDrawingWindow();
f089940f 4520 gdk_window_thaw_updates(window);
5f346ddc
VS
4521}
4522
4523void wxWindowGTK::DoFreeze()
4524{
4525 GTKFreezeWidget(m_widget);
4526 if ( m_wxwindow && m_widget != m_wxwindow )
4527 GTKFreezeWidget(m_wxwindow);
4528}
4529
4530void wxWindowGTK::DoThaw()
4531{
4532 GTKThawWidget(m_widget);
4533 if ( m_wxwindow && m_widget != m_wxwindow )
4534 GTKThawWidget(m_wxwindow);
4535}