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