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