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