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