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