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