projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
set initial GTK_CAN_FOCUS value to match AcceptsFocus (fixes wxTreeCtrl text control...
[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 SetCanFocus(AcceptsFocus());
2144
2145 PostCreation();
2146
2147 return true;
2148 }
2149
2150 wxWindowGTK::~wxWindowGTK()
2151 {
2152 SendDestroyEvent();
2153
2154 if (gs_currentFocus == this)
2155 gs_currentFocus = NULL;
2156 if (gs_pendingFocus == this)
2157 gs_pendingFocus = NULL;
2158
2159 if ( gs_deferredFocusOut == this )
2160 gs_deferredFocusOut = NULL;
2161
2162 m_isBeingDeleted = true;
2163 m_hasVMT = false;
2164
2165 // destroy children before destroying this window itself
2166 DestroyChildren();
2167
2168 // unhook focus handlers to prevent stray events being
2169 // propagated to this (soon to be) dead object
2170 if (m_focusWidget != NULL)
2171 {
2172 g_signal_handlers_disconnect_by_func (m_focusWidget,
2173 (gpointer) gtk_window_focus_in_callback,
2174 this);
2175 g_signal_handlers_disconnect_by_func (m_focusWidget,
2176 (gpointer) gtk_window_focus_out_callback,
2177 this);
2178 }
2179
2180 if (m_widget)
2181 Show( false );
2182
2183 // delete before the widgets to avoid a crash on solaris
2184 delete m_imData;
2185
2186 if (m_wxwindow && (m_wxwindow != m_widget))
2187 {
2188 gtk_widget_destroy( m_wxwindow );
2189 m_wxwindow = (GtkWidget*) NULL;
2190 }
2191
2192 if (m_widget)
2193 {
2194 gtk_widget_destroy( m_widget );
2195 m_widget = (GtkWidget*) NULL;
2196 }
2197 }
2198
2199 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2200 {
2201 if ( GTKNeedsParent() )
2202 {
2203 wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
2204 }
2205
2206 // Use either the given size, or the default if -1 is given.
2207 // See wxWindowBase for these functions.
2208 m_width = WidthDefault(size.x) ;
2209 m_height = HeightDefault(size.y);
2210
2211 m_x = (int)pos.x;
2212 m_y = (int)pos.y;
2213
2214 return true;
2215 }
2216
2217 void wxWindowGTK::PostCreation()
2218 {
2219 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2220
2221 if (m_wxwindow)
2222 {
2223 if (!m_noExpose)
2224 {
2225 // these get reported to wxWidgets -> wxPaintEvent
2226
2227 g_signal_connect (m_wxwindow, "expose_event",
2228 G_CALLBACK (gtk_window_expose_callback), this);
2229
2230 if (GetLayoutDirection() == wxLayout_LeftToRight)
2231 gtk_widget_set_redraw_on_allocate(m_wxwindow, HasFlag(wxFULL_REPAINT_ON_RESIZE));
2232 }
2233
2234 // Create input method handler
2235 m_imData = new wxGtkIMData;
2236
2237 // Cannot handle drawing preedited text yet
2238 gtk_im_context_set_use_preedit( m_imData->context, FALSE );
2239
2240 g_signal_connect (m_imData->context, "commit",
2241 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2242
2243 // border drawing
2244 #ifndef __WXUNIVERSAL__
2245 if (HasFlag(wxPizza::BORDER_STYLES))
2246 {
2247 g_signal_connect(m_widget, "expose_event",
2248 G_CALLBACK(expose_event_border), this);
2249 }
2250 #endif
2251 }
2252
2253 // focus handling
2254
2255 if (!GTK_IS_WINDOW(m_widget))
2256 {
2257 if (m_focusWidget == NULL)
2258 m_focusWidget = m_widget;
2259
2260 if (m_wxwindow)
2261 {
2262 g_signal_connect (m_focusWidget, "focus_in_event",
2263 G_CALLBACK (gtk_window_focus_in_callback), this);
2264 g_signal_connect (m_focusWidget, "focus_out_event",
2265 G_CALLBACK (gtk_window_focus_out_callback), this);
2266 }
2267 else
2268 {
2269 g_signal_connect_after (m_focusWidget, "focus_in_event",
2270 G_CALLBACK (gtk_window_focus_in_callback), this);
2271 g_signal_connect_after (m_focusWidget, "focus_out_event",
2272 G_CALLBACK (gtk_window_focus_out_callback), this);
2273 }
2274 }
2275
2276 if ( !AcceptsFocusFromKeyboard() )
2277 {
2278 SetCanFocus(false);
2279
2280 g_signal_connect(m_widget, "focus",
2281 G_CALLBACK(wx_window_focus_callback), this);
2282 }
2283
2284 // connect to the various key and mouse handlers
2285
2286 GtkWidget *connect_widget = GetConnectWidget();
2287
2288 ConnectWidget( connect_widget );
2289
2290 /* We cannot set colours, fonts and cursors before the widget has
2291 been realized, so we do this directly after realization */
2292 g_signal_connect (connect_widget, "realize",
2293 G_CALLBACK (gtk_window_realized_callback), this);
2294
2295 if (!IsTopLevel())
2296 {
2297 g_signal_connect(m_wxwindow ? m_wxwindow : m_widget, "size_allocate",
2298 G_CALLBACK(size_allocate), this);
2299 }
2300
2301 if (m_wxwindow)
2302 {
2303 #if GTK_CHECK_VERSION(2, 8, 0)
2304 if (!gtk_check_version(2,8,0))
2305 {
2306 // Make sure we can notify the app when mouse capture is lost
2307 g_signal_connect (m_wxwindow, "grab_broken_event",
2308 G_CALLBACK (gtk_window_grab_broken), this);
2309 }
2310 #endif
2311 }
2312
2313 if ( connect_widget != m_wxwindow )
2314 {
2315 #if GTK_CHECK_VERSION(2, 8, 0)
2316 if (!gtk_check_version(2,8,0))
2317 {
2318 // Make sure we can notify app code when mouse capture is lost
2319 g_signal_connect (connect_widget, "grab_broken_event",
2320 G_CALLBACK (gtk_window_grab_broken), this);
2321 }
2322 #endif
2323 }
2324
2325 #ifdef GTK_IS_FILE_CHOOSER_BUTTON
2326 if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget))
2327 {
2328 // If we connect to the "size_request" signal of a GtkFileChooserButton
2329 // then that control won't be sized properly when placed inside sizers
2330 // (this can be tested removing this elseif and running XRC or WIDGETS samples)
2331 // FIXME: what should be done here ?
2332 } else
2333 #endif
2334 if ( !IsTopLevel() ) // top level windows use their own callback
2335 {
2336 // This is needed if we want to add our windows into native
2337 // GTK controls, such as the toolbar. With this callback, the
2338 // toolbar gets to know the correct size (the one set by the
2339 // programmer). Sadly, it misbehaves for wxComboBox.
2340 g_signal_connect (m_widget, "size_request",
2341 G_CALLBACK (wxgtk_window_size_request_callback),
2342 this);
2343 }
2344
2345 InheritAttributes();
2346
2347 m_hasVMT = true;
2348
2349 SetLayoutDirection(wxLayout_Default);
2350
2351 // unless the window was created initially hidden (i.e. Hide() had been
2352 // called before Create()), we should show it at GTK+ level as well
2353 if ( IsShown() )
2354 gtk_widget_show( m_widget );
2355 }
2356
2357 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2358 {
2359 g_signal_connect (widget, "key_press_event",
2360 G_CALLBACK (gtk_window_key_press_callback), this);
2361 g_signal_connect (widget, "key_release_event",
2362 G_CALLBACK (gtk_window_key_release_callback), this);
2363 g_signal_connect (widget, "button_press_event",
2364 G_CALLBACK (gtk_window_button_press_callback), this);
2365 g_signal_connect (widget, "button_release_event",
2366 G_CALLBACK (gtk_window_button_release_callback), this);
2367 g_signal_connect (widget, "motion_notify_event",
2368 G_CALLBACK (gtk_window_motion_notify_callback), this);
2369 g_signal_connect (widget, "scroll_event",
2370 G_CALLBACK (window_scroll_event), this);
2371 g_signal_connect (widget, "popup_menu",
2372 G_CALLBACK (wxgtk_window_popup_menu_callback), this);
2373 g_signal_connect (widget, "enter_notify_event",
2374 G_CALLBACK (gtk_window_enter_callback), this);
2375 g_signal_connect (widget, "leave_notify_event",
2376 G_CALLBACK (gtk_window_leave_callback), this);
2377
2378 if (IsTopLevel() && m_wxwindow)
2379 g_signal_connect (m_wxwindow, "style_set",
2380 G_CALLBACK (gtk_window_style_set_callback), this);
2381 }
2382
2383 bool wxWindowGTK::Destroy()
2384 {
2385 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2386
2387 m_hasVMT = false;
2388
2389 return wxWindowBase::Destroy();
2390 }
2391
2392 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2393 {
2394 gtk_widget_set_size_request(m_widget, width, height);
2395 // inform the parent to perform the move
2396 WX_PIZZA(m_parent->m_wxwindow)->move(m_widget, x, y);
2397 }
2398
2399 void wxWindowGTK::ConstrainSize()
2400 {
2401 #ifdef __WXGPE__
2402 // GPE's window manager doesn't like size hints at all, esp. when the user
2403 // has to use the virtual keyboard, so don't constrain size there
2404 if (!IsTopLevel())
2405 #endif
2406 {
2407 const wxSize minSize = GetMinSize();
2408 const wxSize maxSize = GetMaxSize();
2409 if (minSize.x > 0 && m_width < minSize.x) m_width = minSize.x;
2410 if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
2411 if (maxSize.x > 0 && m_width > maxSize.x) m_width = maxSize.x;
2412 if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
2413 }
2414 }
2415
2416 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2417 {
2418 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2419 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2420
2421 int currentX, currentY;
2422 GetPosition(&currentX, &currentY);
2423 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2424 x = currentX;
2425 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2426 y = currentY;
2427 AdjustForParentClientOrigin(x, y, sizeFlags);
2428
2429 // calculate the best size if we should auto size the window
2430 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2431 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2432 {
2433 const wxSize sizeBest = GetBestSize();
2434 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
2435 width = sizeBest.x;
2436 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
2437 height = sizeBest.y;
2438 }
2439
2440 const wxSize oldSize(m_width, m_height);
2441 if (width != -1)
2442 m_width = width;
2443 if (height != -1)
2444 m_height = height;
2445
2446 ConstrainSize();
2447
2448 if (m_parent->m_wxwindow)
2449 {
2450 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2451 m_x = x + pizza->m_scroll_x;
2452 m_y = y + pizza->m_scroll_y;
2453
2454 int left_border = 0;
2455 int right_border = 0;
2456 int top_border = 0;
2457 int bottom_border = 0;
2458
2459 /* the default button has a border around it */
2460 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2461 {
2462 GtkBorder *default_border = NULL;
2463 gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
2464 if (default_border)
2465 {
2466 left_border += default_border->left;
2467 right_border += default_border->right;
2468 top_border += default_border->top;
2469 bottom_border += default_border->bottom;
2470 gtk_border_free( default_border );
2471 }
2472 }
2473
2474 DoMoveWindow( m_x - left_border,
2475 m_y - top_border,
2476 m_width+left_border+right_border,
2477 m_height+top_border+bottom_border );
2478 }
2479
2480 if (m_width != oldSize.x || m_height != oldSize.y)
2481 {
2482 // update these variables to keep size_allocate handler
2483 // from sending another size event for this change
2484 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2485
2486 gtk_widget_queue_resize(m_widget);
2487 if (!m_nativeSizeEvent)
2488 {
2489 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2490 event.SetEventObject( this );
2491 HandleWindowEvent( event );
2492 }
2493 }
2494 }
2495
2496 bool wxWindowGTK::GtkShowFromOnIdle()
2497 {
2498 if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget))
2499 {
2500 GtkAllocation alloc;
2501 alloc.x = m_x;
2502 alloc.y = m_y;
2503 alloc.width = m_width;
2504 alloc.height = m_height;
2505 gtk_widget_size_allocate( m_widget, &alloc );
2506 gtk_widget_show( m_widget );
2507 wxShowEvent eventShow(GetId(), true);
2508 eventShow.SetEventObject(this);
2509 HandleWindowEvent(eventShow);
2510 m_showOnIdle = false;
2511 return true;
2512 }
2513
2514 return false;
2515 }
2516
2517 void wxWindowGTK::OnInternalIdle()
2518 {
2519 if ( gs_deferredFocusOut )
2520 GTKHandleDeferredFocusOut();
2521
2522 // Check if we have to show window now
2523 if (GtkShowFromOnIdle()) return;
2524
2525 if ( m_dirtyTabOrder )
2526 {
2527 m_dirtyTabOrder = false;
2528 RealizeTabOrder();
2529 }
2530
2531 // Update style if the window was not yet realized
2532 // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
2533 if (m_needsStyleChange)
2534 {
2535 SetBackgroundStyle(GetBackgroundStyle());
2536 m_needsStyleChange = false;
2537 }
2538
2539 wxCursor cursor = m_cursor;
2540 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2541
2542 if (cursor.Ok())
2543 {
2544 /* I now set the cursor anew in every OnInternalIdle call
2545 as setting the cursor in a parent window also effects the
2546 windows above so that checking for the current cursor is
2547 not possible. */
2548
2549 if (m_wxwindow && (m_wxwindow != m_widget))
2550 {
2551 GdkWindow *window = m_wxwindow->window;
2552 if (window)
2553 gdk_window_set_cursor( window, cursor.GetCursor() );
2554
2555 if (!g_globalCursor.Ok())
2556 cursor = *wxSTANDARD_CURSOR;
2557
2558 window = m_widget->window;
2559 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2560 gdk_window_set_cursor( window, cursor.GetCursor() );
2561
2562 }
2563 else if ( m_widget )
2564 {
2565 GdkWindow *window = m_widget->window;
2566 if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )
2567 gdk_window_set_cursor( window, cursor.GetCursor() );
2568 }
2569 }
2570
2571 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
2572 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
2573 }
2574
2575 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2576 {
2577 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2578
2579 if (width) (*width) = m_width;
2580 if (height) (*height) = m_height;
2581 }
2582
2583 void wxWindowGTK::DoSetClientSize( int width, int height )
2584 {
2585 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2586
2587 const wxSize size = GetSize();
2588 const wxSize clientSize = GetClientSize();
2589 SetSize(width + (size.x - clientSize.x), height + (size.y - clientSize.y));
2590 }
2591
2592 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2593 {
2594 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2595
2596 int w = m_width;
2597 int h = m_height;
2598
2599 if (m_wxwindow)
2600 {
2601 // if window is scrollable, account for scrollbars
2602 for (int i = 0; i < 2 && m_scrollBar[i]; i++)
2603 {
2604 GtkRequisition req;
2605 GtkAdjustment* adj = gtk_range_get_adjustment(m_scrollBar[i]);
2606 // if scrollbar enabled
2607 if (adj->upper > adj->page_size)
2608 {
2609 gtk_widget_size_request(GTK_WIDGET(m_scrollBar[i]), &req);
2610 if (i == ScrollDir_Horz)
2611 h -= req.height;
2612 else
2613 w -= req.width;
2614 }
2615 }
2616
2617 int border_x, border_y;
2618 WX_PIZZA(m_wxwindow)->get_border_widths(border_x, border_y);
2619 w -= 2 * border_x;
2620 h -= 2 * border_y;
2621
2622 if (w < 0)
2623 w = 0;
2624 if (h < 0)
2625 h = 0;
2626 }
2627
2628 if (width) *width = w;
2629 if (height) *height = h;
2630 }
2631
2632 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2633 {
2634 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2635
2636 int dx = 0;
2637 int dy = 0;
2638 if (!IsTopLevel() && m_parent && m_parent->m_wxwindow)
2639 {
2640 wxPizza* pizza = WX_PIZZA(m_parent->m_wxwindow);
2641 dx = pizza->m_scroll_x;
2642 dy = pizza->m_scroll_y;
2643 }
2644
2645 if (m_x == -1 && m_y == -1)
2646 {
2647 GdkWindow *source = (GdkWindow *) NULL;
2648 if (m_wxwindow)
2649 source = m_wxwindow->window;
2650 else
2651 source = m_widget->window;
2652
2653 if (source)
2654 {
2655 int org_x = 0;
2656 int org_y = 0;
2657 gdk_window_get_origin( source, &org_x, &org_y );
2658
2659 if (m_parent)
2660 m_parent->ScreenToClient(&org_x, &org_y);
2661
2662 wx_const_cast(wxWindowGTK*, this)->m_x = org_x;
2663 wx_const_cast(wxWindowGTK*, this)->m_y = org_y;
2664 }
2665 }
2666
2667 if (x) (*x) = m_x - dx;
2668 if (y) (*y) = m_y - dy;
2669 }
2670
2671 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2672 {
2673 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2674
2675 if (!m_widget->window) return;
2676
2677 GdkWindow *source = (GdkWindow *) NULL;
2678 if (m_wxwindow)
2679 source = m_wxwindow->window;
2680 else
2681 source = m_widget->window;
2682
2683 int org_x = 0;
2684 int org_y = 0;
2685 gdk_window_get_origin( source, &org_x, &org_y );
2686
2687 if (!m_wxwindow)
2688 {
2689 if (GTK_WIDGET_NO_WINDOW (m_widget))
2690 {
2691 org_x += m_widget->allocation.x;
2692 org_y += m_widget->allocation.y;
2693 }
2694 }
2695
2696
2697 if (x)
2698 {
2699 if (GetLayoutDirection() == wxLayout_RightToLeft)
2700 *x = (GetClientSize().x - *x) + org_x;
2701 else
2702 *x += org_x;
2703 }
2704
2705 if (y) *y += org_y;
2706 }
2707
2708 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
2709 {
2710 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2711
2712 if (!m_widget->window) return;
2713
2714 GdkWindow *source = (GdkWindow *) NULL;
2715 if (m_wxwindow)
2716 source = m_wxwindow->window;
2717 else
2718 source = m_widget->window;
2719
2720 int org_x = 0;
2721 int org_y = 0;
2722 gdk_window_get_origin( source, &org_x, &org_y );
2723
2724 if (!m_wxwindow)
2725 {
2726 if (GTK_WIDGET_NO_WINDOW (m_widget))
2727 {
2728 org_x += m_widget->allocation.x;
2729 org_y += m_widget->allocation.y;
2730 }
2731 }
2732
2733 if (x)
2734 {
2735 if (GetLayoutDirection() == wxLayout_RightToLeft)
2736 *x = (GetClientSize().x - *x) - org_x;
2737 else
2738 *x -= org_x;
2739 }
2740 if (y) *y -= org_y;
2741 }
2742
2743 bool wxWindowGTK::Show( bool show )
2744 {
2745 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
2746
2747 if (!wxWindowBase::Show(show))
2748 {
2749 // nothing to do
2750 return false;
2751 }
2752
2753 if (show && m_showOnIdle)
2754 {
2755 // deferred
2756 }
2757 else
2758 {
2759 if (show)
2760 gtk_widget_show(m_widget);
2761 else
2762 gtk_widget_hide(m_widget);
2763 wxShowEvent eventShow(GetId(), show);
2764 eventShow.SetEventObject(this);
2765 HandleWindowEvent(eventShow);
2766 }
2767
2768 return true;
2769 }
2770
2771 void wxWindowGTK::DoEnable( bool enable )
2772 {
2773 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2774
2775 gtk_widget_set_sensitive( m_widget, enable );
2776 if (m_wxwindow && (m_wxwindow != m_widget))
2777 gtk_widget_set_sensitive( m_wxwindow, enable );
2778 }
2779
2780 int wxWindowGTK::GetCharHeight() const
2781 {
2782 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
2783
2784 wxFont font = GetFont();
2785 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
2786
2787 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2788
2789 if (!context)
2790 return 0;
2791
2792 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2793 PangoLayout *layout = pango_layout_new(context);
2794 pango_layout_set_font_description(layout, desc);
2795 pango_layout_set_text(layout, "H", 1);
2796 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2797
2798 PangoRectangle rect;
2799 pango_layout_line_get_extents(line, NULL, &rect);
2800
2801 g_object_unref (layout);
2802
2803 return (int) PANGO_PIXELS(rect.height);
2804 }
2805
2806 int wxWindowGTK::GetCharWidth() const
2807 {
2808 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
2809
2810 wxFont font = GetFont();
2811 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
2812
2813 PangoContext* context = gtk_widget_get_pango_context(m_widget);
2814
2815 if (!context)
2816 return 0;
2817
2818 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
2819 PangoLayout *layout = pango_layout_new(context);
2820 pango_layout_set_font_description(layout, desc);
2821 pango_layout_set_text(layout, "g", 1);
2822 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2823
2824 PangoRectangle rect;
2825 pango_layout_line_get_extents(line, NULL, &rect);
2826
2827 g_object_unref (layout);
2828
2829 return (int) PANGO_PIXELS(rect.width);
2830 }
2831
2832 void wxWindowGTK::GetTextExtent( const wxString& string,
2833 int *x,
2834 int *y,
2835 int *descent,
2836 int *externalLeading,
2837 const wxFont *theFont ) const
2838 {
2839 wxFont fontToUse = theFont ? *theFont : GetFont();
2840
2841 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
2842
2843 if (string.empty())
2844 {
2845 if (x) (*x) = 0;
2846 if (y) (*y) = 0;
2847 return;
2848 }
2849
2850 PangoContext *context = NULL;
2851 if (m_widget)
2852 context = gtk_widget_get_pango_context( m_widget );
2853
2854 if (!context)
2855 {
2856 if (x) (*x) = 0;
2857 if (y) (*y) = 0;
2858 return;
2859 }
2860
2861 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
2862 PangoLayout *layout = pango_layout_new(context);
2863 pango_layout_set_font_description(layout, desc);
2864 {
2865 const wxCharBuffer data = wxGTK_CONV( string );
2866 if ( data )
2867 pango_layout_set_text(layout, data, strlen(data));
2868 }
2869
2870 PangoRectangle rect;
2871 pango_layout_get_extents(layout, NULL, &rect);
2872
2873 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
2874 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
2875 if (descent)
2876 {
2877 PangoLayoutIter *iter = pango_layout_get_iter(layout);
2878 int baseline = pango_layout_iter_get_baseline(iter);
2879 pango_layout_iter_free(iter);
2880 *descent = *y - PANGO_PIXELS(baseline);
2881 }
2882 if (externalLeading) (*externalLeading) = 0; // ??
2883
2884 g_object_unref (layout);
2885 }
2886
2887
2888 bool wxWindowGTK::GTKHandleFocusIn()
2889 {
2890 // Disable default focus handling for custom windows since the default GTK+
2891 // handler issues a repaint
2892 const bool retval = m_wxwindow ? true : false;
2893
2894
2895 // NB: if there's still unprocessed deferred focus-out event (see
2896 // GTKHandleFocusOut() for explanation), we need to process it first so
2897 // that the order of focus events -- focus-out first, then focus-in
2898 // elsewhere -- is preserved
2899 if ( gs_deferredFocusOut )
2900 {
2901 if ( GTKNeedsToFilterSameWindowFocus() &&
2902 gs_deferredFocusOut == this )
2903 {
2904 // GTK+ focus changed from this wxWindow back to itself, so don't
2905 // emit any events at all
2906 wxLogTrace(TRACE_FOCUS,
2907 "filtered out spurious focus change within %s(%p, %s)",
2908 GetClassInfo()->GetClassName(), this, GetLabel());
2909 gs_deferredFocusOut = NULL;
2910 return retval;
2911 }
2912
2913 // otherwise we need to send focus-out first
2914 wxASSERT_MSG ( gs_deferredFocusOut != this,
2915 "GTKHandleFocusIn(GTKFocus_Normal) called even though focus changed back to itself - derived class should handle this" );
2916 GTKHandleDeferredFocusOut();
2917 }
2918
2919
2920 wxLogTrace(TRACE_FOCUS,
2921 "handling focus_in event for %s(%p, %s)",
2922 GetClassInfo()->GetClassName(), this, GetLabel());
2923
2924 if (m_imData)
2925 gtk_im_context_focus_in(m_imData->context);
2926
2927 gs_currentFocus = this;
2928 gs_pendingFocus = NULL;
2929
2930 #if wxUSE_CARET
2931 // caret needs to be informed about focus change
2932 wxCaret *caret = GetCaret();
2933 if ( caret )
2934 {
2935 caret->OnSetFocus();
2936 }
2937 #endif // wxUSE_CARET
2938
2939 // Notify the parent keeping track of focus for the kbd navigation
2940 // purposes that we got it.
2941 wxChildFocusEvent eventChildFocus(this);
2942 GTKProcessEvent(eventChildFocus);
2943
2944 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, GetId());
2945 eventFocus.SetEventObject(this);
2946 GTKProcessEvent(eventFocus);
2947
2948 return retval;
2949 }
2950
2951 bool wxWindowGTK::GTKHandleFocusOut()
2952 {
2953 // Disable default focus handling for custom windows since the default GTK+
2954 // handler issues a repaint
2955 const bool retval = m_wxwindow ? true : false;
2956
2957
2958 // NB: If a control is composed of several GtkWidgets and when focus
2959 // changes from one of them to another within the same wxWindow, we get
2960 // a focus-out event followed by focus-in for another GtkWidget owned
2961 // by the same wx control. We don't want to generate two spurious
2962 // wxEVT_SET_FOCUS events in this case, so we defer sending wx events
2963 // from GTKHandleFocusOut() until we know for sure it's not coming back
2964 // (i.e. in GTKHandleFocusIn() or at idle time).
2965 if ( GTKNeedsToFilterSameWindowFocus() )
2966 {
2967 wxASSERT_MSG( gs_deferredFocusOut == NULL,
2968 "deferred focus out event already pending" );
2969 wxLogTrace(TRACE_FOCUS,
2970 "deferring focus_out event for %s(%p, %s)",
2971 GetClassInfo()->GetClassName(), this, GetLabel());
2972 gs_deferredFocusOut = this;
2973 return retval;
2974 }
2975
2976 GTKHandleFocusOutNoDeferring();
2977
2978 return retval;
2979 }
2980
2981 void wxWindowGTK::GTKHandleFocusOutNoDeferring()
2982 {
2983 wxLogTrace(TRACE_FOCUS,
2984 "handling focus_out event for %s(%p, %s)",
2985 GetClassInfo()->GetClassName(), this, GetLabel());
2986
2987 if (m_imData)
2988 gtk_im_context_focus_out(m_imData->context);
2989
2990 if ( gs_currentFocus != this )
2991 {
2992 // Something is terribly wrong, gs_currentFocus is out of sync with the
2993 // real focus. We will reset it to NULL anyway, because after this
2994 // focus-out event is handled, one of the following with happen:
2995 //
2996 // * either focus will go out of the app altogether, in which case
2997 // gs_currentFocus _should_ be NULL
2998 //
2999 // * or it goes to another control, in which case focus-in event will
3000 // follow immediately and it will set gs_currentFocus to the right
3001 // value
3002 wxLogDebug("window %s(%p, %s) lost focus even though it didn't have it",
3003 GetClassInfo()->GetClassName(), this, GetLabel());
3004 }
3005 gs_currentFocus = NULL;
3006
3007 #if wxUSE_CARET
3008 // caret needs to be informed about focus change
3009 wxCaret *caret = GetCaret();
3010 if ( caret )
3011 {
3012 caret->OnKillFocus();
3013 }
3014 #endif // wxUSE_CARET
3015
3016 wxFocusEvent event( wxEVT_KILL_FOCUS, GetId() );
3017 event.SetEventObject( this );
3018 GTKProcessEvent( event );
3019 }
3020
3021 /*static*/
3022 void wxWindowGTK::GTKHandleDeferredFocusOut()
3023 {
3024 // NB: See GTKHandleFocusOut() for explanation. This function is called
3025 // from either GTKHandleFocusIn() or OnInternalIdle() to process
3026 // deferred event.
3027 if ( gs_deferredFocusOut )
3028 {
3029 wxWindowGTK *win = gs_deferredFocusOut;
3030 gs_deferredFocusOut = NULL;
3031
3032 wxLogTrace(TRACE_FOCUS,
3033 "processing deferred focus_out event for %s(%p, %s)",
3034 win->GetClassInfo()->GetClassName(), win, win->GetLabel());
3035
3036 win->GTKHandleFocusOutNoDeferring();
3037 }
3038 }
3039
3040 void wxWindowGTK::SetFocus()
3041 {
3042 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3043
3044 // Setting "physical" focus is not immediate in GTK+ and while
3045 // gtk_widget_is_focus ("determines if the widget is the focus widget
3046 // within its toplevel", i.e. returns true for one widget per TLW, not
3047 // globally) returns true immediately after grabbing focus,
3048 // GTK_WIDGET_HAS_FOCUS (which returns true only for the one widget that
3049 // has focus at the moment) takes affect only after the window is shown
3050 // (if it was hidden at the moment of the call) or at the next event loop
3051 // iteration.
3052 //
3053 // Because we want to FindFocus() call immediately following
3054 // foo->SetFocus() to return foo, we have to keep track of "pending" focus
3055 // ourselves.
3056 gs_pendingFocus = this;
3057
3058 GtkWidget *widget = m_wxwindow ? m_wxwindow : m_focusWidget;
3059
3060 if ( GTK_IS_CONTAINER(widget) &&
3061 !GTK_WIDGET_CAN_FOCUS(widget) )
3062 {
3063 wxLogTrace(TRACE_FOCUS,
3064 _T("Setting focus to a child of %s(%p, %s)"),
3065 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3066 gtk_widget_child_focus(widget, GTK_DIR_TAB_FORWARD);
3067 }
3068 else
3069 {
3070 wxLogTrace(TRACE_FOCUS,
3071 _T("Setting focus to %s(%p, %s)"),
3072 GetClassInfo()->GetClassName(), this, GetLabel().c_str());
3073 gtk_widget_grab_focus(widget);
3074 }
3075 }
3076
3077 void wxWindowGTK::SetCanFocus(bool canFocus)
3078 {
3079 if ( canFocus )
3080 GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
3081 else
3082 GTK_WIDGET_UNSET_FLAGS(m_widget, GTK_CAN_FOCUS);
3083
3084 if ( m_wxwindow && (m_widget != m_wxwindow) )
3085 {
3086 if ( canFocus )
3087 GTK_WIDGET_SET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3088 else
3089 GTK_WIDGET_UNSET_FLAGS(m_wxwindow, GTK_CAN_FOCUS);
3090 }
3091 }
3092
3093 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3094 {
3095 wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
3096
3097 wxWindowGTK *oldParent = m_parent,
3098 *newParent = (wxWindowGTK *)newParentBase;
3099
3100 wxASSERT( GTK_IS_WIDGET(m_widget) );
3101
3102 if ( !wxWindowBase::Reparent(newParent) )
3103 return false;
3104
3105 wxASSERT( GTK_IS_WIDGET(m_widget) );
3106
3107 /* prevent GTK from deleting the widget arbitrarily */
3108 gtk_widget_ref( m_widget );
3109
3110 if (oldParent)
3111 {
3112 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3113 }
3114
3115 wxASSERT( GTK_IS_WIDGET(m_widget) );
3116
3117 if (newParent)
3118 {
3119 if (GTK_WIDGET_VISIBLE (newParent->m_widget))
3120 {
3121 m_showOnIdle = true;
3122 gtk_widget_hide( m_widget );
3123 }
3124
3125 /* insert GTK representation */
3126 (*(newParent->m_insertCallback))(newParent, this);
3127 }
3128
3129 /* reverse: prevent GTK from deleting the widget arbitrarily */
3130 gtk_widget_unref( m_widget );
3131
3132 SetLayoutDirection(wxLayout_Default);
3133
3134 return true;
3135 }
3136
3137 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3138 {
3139 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3140 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3141
3142 /* add to list */
3143 AddChild( child );
3144
3145 /* insert GTK representation */
3146 (*m_insertCallback)(this, child);
3147 }
3148
3149 void wxWindowGTK::AddChild(wxWindowBase *child)
3150 {
3151 wxWindowBase::AddChild(child);
3152 m_dirtyTabOrder = true;
3153 wxTheApp->WakeUpIdle();
3154 }
3155
3156 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3157 {
3158 wxWindowBase::RemoveChild(child);
3159 m_dirtyTabOrder = true;
3160 wxTheApp->WakeUpIdle();
3161 }
3162
3163 /* static */
3164 wxLayoutDirection wxWindowGTK::GTKGetLayout(GtkWidget *widget)
3165 {
3166 return gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL
3167 ? wxLayout_RightToLeft
3168 : wxLayout_LeftToRight;
3169 }
3170
3171 /* static */
3172 void wxWindowGTK::GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir)
3173 {
3174 wxASSERT_MSG( dir != wxLayout_Default, _T("invalid layout direction") );
3175
3176 gtk_widget_set_direction(widget,
3177 dir == wxLayout_RightToLeft ? GTK_TEXT_DIR_RTL
3178 : GTK_TEXT_DIR_LTR);
3179 }
3180
3181 wxLayoutDirection wxWindowGTK::GetLayoutDirection() const
3182 {
3183 return GTKGetLayout(m_widget);
3184 }
3185
3186 void wxWindowGTK::SetLayoutDirection(wxLayoutDirection dir)
3187 {
3188 if ( dir == wxLayout_Default )
3189 {
3190 const wxWindow *const parent = GetParent();
3191 if ( parent )
3192 {
3193 // inherit layout from parent.
3194 dir = parent->GetLayoutDirection();
3195 }
3196 else // no parent, use global default layout
3197 {
3198 dir = wxTheApp->GetLayoutDirection();
3199 }
3200 }
3201
3202 if ( dir == wxLayout_Default )
3203 return;
3204
3205 GTKSetLayout(m_widget, dir);
3206
3207 if (m_wxwindow && (m_wxwindow != m_widget))
3208 GTKSetLayout(m_wxwindow, dir);
3209 }
3210
3211 wxCoord
3212 wxWindowGTK::AdjustForLayoutDirection(wxCoord x,
3213 wxCoord WXUNUSED(width),
3214 wxCoord WXUNUSED(widthTotal)) const
3215 {
3216 // We now mirror the coordinates of RTL windows in wxPizza
3217 return x;
3218 }
3219
3220 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, WindowOrder move)
3221 {
3222 wxWindowBase::DoMoveInTabOrder(win, move);
3223 m_dirtyTabOrder = true;
3224 wxTheApp->WakeUpIdle();
3225 }
3226
3227 bool wxWindowGTK::DoNavigateIn(int flags)
3228 {
3229 if ( flags & wxNavigationKeyEvent::WinChange )
3230 {
3231 wxFAIL_MSG( _T("not implemented") );
3232
3233 return false;
3234 }
3235 else // navigate inside the container
3236 {
3237 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3238 wxCHECK_MSG( parent, false, _T("every window must have a TLW parent") );
3239
3240 GtkDirectionType dir;
3241 dir = flags & wxNavigationKeyEvent::IsForward ? GTK_DIR_TAB_FORWARD
3242 : GTK_DIR_TAB_BACKWARD;
3243
3244 gboolean rc;
3245 g_signal_emit_by_name(parent->m_widget, "focus", dir, &rc);
3246
3247 return rc == TRUE;
3248 }
3249 }
3250
3251 bool wxWindowGTK::GTKWidgetNeedsMnemonic() const
3252 {
3253 // none needed by default
3254 return false;
3255 }
3256
3257 void wxWindowGTK::GTKWidgetDoSetMnemonic(GtkWidget* WXUNUSED(w))
3258 {
3259 // nothing to do by default since none is needed
3260 }
3261
3262 void wxWindowGTK::RealizeTabOrder()
3263 {
3264 if (m_wxwindow)
3265 {
3266 if ( !m_children.empty() )
3267 {
3268 // we don't only construct the correct focus chain but also use
3269 // this opportunity to update the mnemonic widgets for the widgets
3270 // that need them
3271
3272 GList *chain = NULL;
3273 wxWindowGTK* mnemonicWindow = NULL;
3274
3275 for ( wxWindowList::const_iterator i = m_children.begin();
3276 i != m_children.end();
3277 ++i )
3278 {
3279 wxWindowGTK *win = *i;
3280
3281 if ( mnemonicWindow )
3282 {
3283 if ( win->AcceptsFocusFromKeyboard() )
3284 {
3285 // wxComboBox et al. needs to focus on on a different
3286 // widget than m_widget, so if the main widget isn't
3287 // focusable try the connect widget
3288 GtkWidget* w = win->m_widget;
3289 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3290 {
3291 w = win->GetConnectWidget();
3292 if ( !GTK_WIDGET_CAN_FOCUS(w) )
3293 w = NULL;
3294 }
3295
3296 if ( w )
3297 {
3298 mnemonicWindow->GTKWidgetDoSetMnemonic(w);
3299 mnemonicWindow = NULL;
3300 }
3301 }
3302 }
3303 else if ( win->GTKWidgetNeedsMnemonic() )
3304 {
3305 mnemonicWindow = win;
3306 }
3307
3308 chain = g_list_prepend(chain, win->m_widget);
3309 }
3310
3311 chain = g_list_reverse(chain);
3312
3313 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3314 g_list_free(chain);
3315 }
3316 else // no children
3317 {
3318 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3319 }
3320 }
3321 }
3322
3323 void wxWindowGTK::Raise()
3324 {
3325 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3326
3327 if (m_wxwindow && m_wxwindow->window)
3328 {
3329 gdk_window_raise( m_wxwindow->window );
3330 }
3331 else if (m_widget->window)
3332 {
3333 gdk_window_raise( m_widget->window );
3334 }
3335 }
3336
3337 void wxWindowGTK::Lower()
3338 {
3339 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3340
3341 if (m_wxwindow && m_wxwindow->window)
3342 {
3343 gdk_window_lower( m_wxwindow->window );
3344 }
3345 else if (m_widget->window)
3346 {
3347 gdk_window_lower( m_widget->window );
3348 }
3349 }
3350
3351 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3352 {
3353 if ( !wxWindowBase::SetCursor(cursor.Ok() ? cursor : *wxSTANDARD_CURSOR) )
3354 return false;
3355
3356 GTKUpdateCursor();
3357
3358 return true;
3359 }
3360
3361 void wxWindowGTK::GTKUpdateCursor()
3362 {
3363 wxCursor cursor(g_globalCursor.Ok() ? g_globalCursor : GetCursor());
3364 if ( cursor.Ok() )
3365 {
3366 wxArrayGdkWindows windowsThis;
3367 GdkWindow * const winThis = GTKGetWindow(windowsThis);
3368 if ( winThis )
3369 {
3370 gdk_window_set_cursor(winThis, cursor.GetCursor());
3371 }
3372 else
3373 {
3374 const size_t count = windowsThis.size();
3375 for ( size_t n = 0; n < count; n++ )
3376 {
3377 GdkWindow *win = windowsThis[n];
3378 if ( !win )
3379 {
3380 wxFAIL_MSG(_T("NULL window returned by GTKGetWindow()?"));
3381 continue;
3382 }
3383
3384 gdk_window_set_cursor(win, cursor.GetCursor());
3385 }
3386 }
3387 }
3388 }
3389
3390 void wxWindowGTK::WarpPointer( int x, int y )
3391 {
3392 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3393
3394 // We provide this function ourselves as it is
3395 // missing in GDK (top of this file).
3396
3397 GdkWindow *window = (GdkWindow*) NULL;
3398 if (m_wxwindow)
3399 window = m_wxwindow->window;
3400 else
3401 window = GetConnectWidget()->window;
3402
3403 if (window)
3404 gdk_window_warp_pointer( window, x, y );
3405 }
3406
3407 wxWindowGTK::ScrollDir wxWindowGTK::ScrollDirFromRange(GtkRange *range) const
3408 {
3409 // find the scrollbar which generated the event
3410 for ( int dir = 0; dir < ScrollDir_Max; dir++ )
3411 {
3412 if ( range == m_scrollBar[dir] )
3413 return (ScrollDir)dir;
3414 }
3415
3416 wxFAIL_MSG( _T("event from unknown scrollbar received") );
3417
3418 return ScrollDir_Max;
3419 }
3420
3421 bool wxWindowGTK::DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units)
3422 {
3423 bool changed = false;
3424 GtkRange* range = m_scrollBar[dir];
3425 if ( range && units )
3426 {
3427 GtkAdjustment* adj = range->adjustment;
3428 gdouble inc = unit == ScrollUnit_Line ? adj->step_increment
3429 : adj->page_increment;
3430
3431 const int posOld = int(adj->value + 0.5);
3432 gtk_range_set_value(range, posOld + units*inc);
3433
3434 changed = int(adj->value + 0.5) != posOld;
3435 }
3436
3437 return changed;
3438 }
3439
3440 bool wxWindowGTK::ScrollLines(int lines)
3441 {
3442 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Line, lines);
3443 }
3444
3445 bool wxWindowGTK::ScrollPages(int pages)
3446 {
3447 return DoScrollByUnits(ScrollDir_Vert, ScrollUnit_Page, pages);
3448 }
3449
3450 void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
3451 const wxRect *rect)
3452 {
3453 if (!m_widget)
3454 return;
3455 if (!m_widget->window)
3456 return;
3457
3458 if (m_wxwindow)
3459 {
3460 if (m_wxwindow->window == NULL) return;
3461
3462 GdkRectangle gdk_rect,
3463 *p;
3464 if (rect)
3465 {
3466 gdk_rect.x = rect->x;
3467 gdk_rect.y = rect->y;
3468 gdk_rect.width = rect->width;
3469 gdk_rect.height = rect->height;
3470 if (GetLayoutDirection() == wxLayout_RightToLeft)
3471 gdk_rect.x = GetClientSize().x - gdk_rect.x - gdk_rect.width;
3472
3473 p = &gdk_rect;
3474 }
3475 else // invalidate everything
3476 {
3477 p = NULL;
3478 }
3479
3480 gdk_window_invalidate_rect(m_wxwindow->window, p, true);
3481 }
3482 }
3483
3484 void wxWindowGTK::Update()
3485 {
3486 GtkUpdate();
3487
3488 // when we call Update() we really want to update the window immediately on
3489 // screen, even if it means flushing the entire queue and hence slowing down
3490 // everything -- but it should still be done, it's just that Update() should
3491 // be called very rarely
3492 gdk_flush();
3493 }
3494
3495 void wxWindowGTK::GtkUpdate()
3496 {
3497 if (m_wxwindow && m_wxwindow->window)
3498 gdk_window_process_updates(m_wxwindow->window, false);
3499 if (m_widget && m_widget->window && (m_wxwindow != m_widget))
3500 gdk_window_process_updates( m_widget->window, FALSE );
3501
3502 // for consistency with other platforms (and also because it's convenient
3503 // to be able to update an entire TLW by calling Update() only once), we
3504 // should also update all our children here
3505 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3506 node;
3507 node = node->GetNext() )
3508 {
3509 node->GetData()->GtkUpdate();
3510 }
3511 }
3512
3513 bool wxWindowGTK::DoIsExposed( int x, int y ) const
3514 {
3515 return m_updateRegion.Contains(x, y) != wxOutRegion;
3516 }
3517
3518
3519 bool wxWindowGTK::DoIsExposed( int x, int y, int w, int h ) const
3520 {
3521 if (GetLayoutDirection() == wxLayout_RightToLeft)
3522 return m_updateRegion.Contains(x-w, y, w, h) != wxOutRegion;
3523 else
3524 return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
3525 }
3526
3527 void wxWindowGTK::GtkSendPaintEvents()
3528 {
3529 if (!m_wxwindow)
3530 {
3531 m_updateRegion.Clear();
3532 return;
3533 }
3534
3535 // Clip to paint region in wxClientDC
3536 m_clipPaintRegion = true;
3537
3538 m_nativeUpdateRegion = m_updateRegion;
3539
3540 if (GetLayoutDirection() == wxLayout_RightToLeft)
3541 {
3542 // Transform m_updateRegion under RTL
3543 m_updateRegion.Clear();
3544
3545 gint width;
3546 gdk_drawable_get_size(m_wxwindow->window, &width, NULL);
3547
3548 wxRegionIterator upd( m_nativeUpdateRegion );
3549 while (upd)
3550 {
3551 wxRect rect;
3552 rect.x = upd.GetX();
3553 rect.y = upd.GetY();
3554 rect.width = upd.GetWidth();
3555 rect.height = upd.GetHeight();
3556
3557 rect.x = width - rect.x - rect.width;
3558 m_updateRegion.Union( rect );
3559
3560 ++upd;
3561 }
3562 }
3563
3564 if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM))
3565 {
3566 // find ancestor from which to steal background
3567 wxWindow *parent = wxGetTopLevelParent((wxWindow *)this);
3568 if (!parent)
3569 parent = (wxWindow*)this;
3570
3571 if (GTK_WIDGET_MAPPED(parent->m_widget))
3572 {
3573 wxRegionIterator upd( m_nativeUpdateRegion );
3574 while (upd)
3575 {
3576 GdkRectangle rect;
3577 rect.x = upd.GetX();
3578 rect.y = upd.GetY();
3579 rect.width = upd.GetWidth();
3580 rect.height = upd.GetHeight();
3581
3582 gtk_paint_flat_box( parent->m_widget->style,
3583 m_wxwindow->window,
3584 (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3585 GTK_SHADOW_NONE,
3586 &rect,
3587 parent->m_widget,
3588 (char *)"base",
3589 0, 0, -1, -1 );
3590
3591 ++upd;
3592 }
3593 }
3594 }
3595 else
3596 {
3597 wxWindowDC dc( (wxWindow*)this );
3598 dc.SetClippingRegion( m_updateRegion );
3599
3600 // Work around gtk-qt <= 0.60 bug whereby the window colour
3601 // remains grey
3602 if (GetBackgroundStyle() == wxBG_STYLE_COLOUR && GetBackgroundColour().Ok() && wxSystemOptions::GetOptionInt(wxT("gtk.window.force-background-colour")) == 1)
3603 {
3604 dc.SetBackground(wxBrush(GetBackgroundColour()));
3605 dc.Clear();
3606 }
3607
3608 wxEraseEvent erase_event( GetId(), &dc );
3609 erase_event.SetEventObject( this );
3610
3611 HandleWindowEvent(erase_event);
3612 }
3613
3614 wxNcPaintEvent nc_paint_event( GetId() );
3615 nc_paint_event.SetEventObject( this );
3616 HandleWindowEvent( nc_paint_event );
3617
3618 wxPaintEvent paint_event( GetId() );
3619 paint_event.SetEventObject( this );
3620 HandleWindowEvent( paint_event );
3621
3622 m_clipPaintRegion = false;
3623
3624 m_updateRegion.Clear();
3625 m_nativeUpdateRegion.Clear();
3626 }
3627
3628 void wxWindowGTK::SetDoubleBuffered( bool on )
3629 {
3630 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3631
3632 if ( m_wxwindow )
3633 gtk_widget_set_double_buffered( m_wxwindow, on );
3634 }
3635
3636 bool wxWindowGTK::IsDoubleBuffered() const
3637 {
3638 return GTK_WIDGET_DOUBLE_BUFFERED( m_wxwindow );
3639 }
3640
3641 void wxWindowGTK::ClearBackground()
3642 {
3643 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3644 }
3645
3646 #if wxUSE_TOOLTIPS
3647 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3648 {
3649 wxWindowBase::DoSetToolTip(tip);
3650
3651 if (m_tooltip)
3652 m_tooltip->Apply( (wxWindow *)this );
3653 }
3654
3655 void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const gchar *tip )
3656 {
3657 gtk_tooltips_set_tip(tips, GetConnectWidget(), tip, NULL);
3658 }
3659 #endif // wxUSE_TOOLTIPS
3660
3661 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3662 {
3663 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3664
3665 if (!wxWindowBase::SetBackgroundColour(colour))
3666 return false;
3667
3668 if (colour.Ok())
3669 {
3670 // We need the pixel value e.g. for background clearing.
3671 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3672 }
3673
3674 // apply style change (forceStyle=true so that new style is applied
3675 // even if the bg colour changed from valid to wxNullColour)
3676 if (GetBackgroundStyle() != wxBG_STYLE_CUSTOM)
3677 ApplyWidgetStyle(true);
3678
3679 return true;
3680 }
3681
3682 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3683 {
3684 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3685
3686 if (!wxWindowBase::SetForegroundColour(colour))
3687 {
3688 return false;
3689 }
3690
3691 if (colour.Ok())
3692 {
3693 // We need the pixel value e.g. for background clearing.
3694 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
3695 }
3696
3697 // apply style change (forceStyle=true so that new style is applied
3698 // even if the bg colour changed from valid to wxNullColour):
3699 ApplyWidgetStyle(true);
3700
3701 return true;
3702 }
3703
3704 PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
3705 {
3706 return gtk_widget_get_pango_context( m_widget );
3707 }
3708
3709 GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
3710 {
3711 // do we need to apply any changes at all?
3712 if ( !forceStyle &&
3713 !m_font.Ok() &&
3714 !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
3715 {
3716 return NULL;
3717 }
3718
3719 GtkRcStyle *style = gtk_rc_style_new();
3720
3721 if ( m_font.Ok() )
3722 {
3723 style->font_desc =
3724 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
3725 }
3726
3727 int flagsNormal = 0,
3728 flagsPrelight = 0,
3729 flagsActive = 0,
3730 flagsInsensitive = 0;
3731
3732 if ( m_foregroundColour.Ok() )
3733 {
3734 const GdkColor *fg = m_foregroundColour.GetColor();
3735
3736 style->fg[GTK_STATE_NORMAL] =
3737 style->text[GTK_STATE_NORMAL] = *fg;
3738 flagsNormal |= GTK_RC_FG | GTK_RC_TEXT;
3739
3740 style->fg[GTK_STATE_PRELIGHT] =
3741 style->text[GTK_STATE_PRELIGHT] = *fg;
3742 flagsPrelight |= GTK_RC_FG | GTK_RC_TEXT;
3743
3744 style->fg[GTK_STATE_ACTIVE] =
3745 style->text[GTK_STATE_ACTIVE] = *fg;
3746 flagsActive |= GTK_RC_FG | GTK_RC_TEXT;
3747 }
3748
3749 if ( m_backgroundColour.Ok() )
3750 {
3751 const GdkColor *bg = m_backgroundColour.GetColor();
3752
3753 style->bg[GTK_STATE_NORMAL] =
3754 style->base[GTK_STATE_NORMAL] = *bg;
3755 flagsNormal |= GTK_RC_BG | GTK_RC_BASE;
3756
3757 style->bg[GTK_STATE_PRELIGHT] =
3758 style->base[GTK_STATE_PRELIGHT] = *bg;
3759 flagsPrelight |= GTK_RC_BG | GTK_RC_BASE;
3760
3761 style->bg[GTK_STATE_ACTIVE] =
3762 style->base[GTK_STATE_ACTIVE] = *bg;
3763 flagsActive |= GTK_RC_BG | GTK_RC_BASE;
3764
3765 style->bg[GTK_STATE_INSENSITIVE] =
3766 style->base[GTK_STATE_INSENSITIVE] = *bg;
3767 flagsInsensitive |= GTK_RC_BG | GTK_RC_BASE;
3768 }
3769
3770 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)flagsNormal;
3771 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)flagsPrelight;
3772 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)flagsActive;
3773 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)flagsInsensitive;
3774
3775 return style;
3776 }
3777
3778 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)
3779 {
3780 GtkRcStyle *style = CreateWidgetStyle(forceStyle);
3781 if ( style )
3782 {
3783 DoApplyWidgetStyle(style);
3784 gtk_rc_style_unref(style);
3785 }
3786
3787 // Style change may affect GTK+'s size calculation:
3788 InvalidateBestSize();
3789 }
3790
3791 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
3792 {
3793 wxSuspendStyleEvents s(static_cast<wxWindow*>(this));
3794
3795 if (m_wxwindow)
3796 gtk_widget_modify_style(m_wxwindow, style);
3797 else
3798 gtk_widget_modify_style(m_widget, style);
3799 }
3800
3801 bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style)
3802 {
3803 wxWindowBase::SetBackgroundStyle(style);
3804
3805 if (style == wxBG_STYLE_CUSTOM)
3806 {
3807 GdkWindow *window;
3808 if ( m_wxwindow )
3809 {
3810 window = m_wxwindow->window;
3811 }
3812 else
3813 {
3814 GtkWidget * const w = GetConnectWidget();
3815 window = w ? w->window : NULL;
3816 }
3817
3818 if (window)
3819 {
3820 // Make sure GDK/X11 doesn't refresh the window
3821 // automatically.
3822 gdk_window_set_back_pixmap( window, None, False );
3823 #ifdef __X__
3824 Display* display = GDK_WINDOW_DISPLAY(window);
3825 XFlush(display);
3826 #endif
3827 m_needsStyleChange = false;
3828 }
3829 else // window not realized yet
3830 {
3831 // Do in OnIdle, because the window is not yet available
3832 m_needsStyleChange = true;
3833 }
3834
3835 // Don't apply widget style, or we get a grey background
3836 }
3837 else
3838 {
3839 // apply style change (forceStyle=true so that new style is applied
3840 // even if the bg colour changed from valid to wxNullColour):
3841 ApplyWidgetStyle(true);
3842 }
3843 return true;
3844 }
3845
3846 // ----------------------------------------------------------------------------
3847 // Pop-up menu stuff
3848 // ----------------------------------------------------------------------------
3849
3850 #if wxUSE_MENUS_NATIVE
3851
3852 static void SetInvokingWindow( wxMenu *menu, wxWindow* win )
3853 {
3854 menu->SetInvokingWindow( win );
3855
3856 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
3857 while (node)
3858 {
3859 wxMenuItem *menuitem = node->GetData();
3860 if (menuitem->IsSubMenu())
3861 {
3862 SetInvokingWindow( menuitem->GetSubMenu(), win );
3863 }
3864
3865 node = node->GetNext();
3866 }
3867 }
3868
3869 extern "C" {
3870 static
3871 void wxPopupMenuPositionCallback( GtkMenu *menu,
3872 gint *x, gint *y,
3873 gboolean * WXUNUSED(whatever),
3874 gpointer user_data )
3875 {
3876 // ensure that the menu appears entirely on screen
3877 GtkRequisition req;
3878 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
3879
3880 wxSize sizeScreen = wxGetDisplaySize();
3881 wxPoint *pos = (wxPoint*)user_data;
3882
3883 gint xmax = sizeScreen.x - req.width,
3884 ymax = sizeScreen.y - req.height;
3885
3886 *x = pos->x < xmax ? pos->x : xmax;
3887 *y = pos->y < ymax ? pos->y : ymax;
3888 }
3889 }
3890
3891 void wxWindowGTK::DoPopupMenuUpdateUI(wxMenu* menu)
3892 {
3893 menu->UpdateUI();
3894 }
3895
3896 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
3897 {
3898 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3899
3900 wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") );
3901
3902 SetInvokingWindow( menu, this );
3903
3904 DoPopupMenuUpdateUI(menu);
3905
3906 wxPoint pos;
3907 gpointer userdata;
3908 GtkMenuPositionFunc posfunc;
3909 if ( x == -1 && y == -1 )
3910 {
3911 // use GTK's default positioning algorithm
3912 userdata = NULL;
3913 posfunc = NULL;
3914 }
3915 else
3916 {
3917 pos = ClientToScreen(wxPoint(x, y));
3918 userdata = &pos;
3919 posfunc = wxPopupMenuPositionCallback;
3920 }
3921
3922 menu->m_popupShown = true;
3923 gtk_menu_popup(
3924 GTK_MENU(menu->m_menu),
3925 (GtkWidget *) NULL, // parent menu shell
3926 (GtkWidget *) NULL, // parent menu item
3927 posfunc, // function to position it
3928 userdata, // client data
3929 0, // button used to activate it
3930 gtk_get_current_event_time()
3931 );
3932
3933 while (menu->m_popupShown)
3934 {
3935 gtk_main_iteration();
3936 }
3937
3938 return true;
3939 }
3940
3941 #endif // wxUSE_MENUS_NATIVE
3942
3943 #if wxUSE_DRAG_AND_DROP
3944
3945 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
3946 {
3947 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3948
3949 GtkWidget *dnd_widget = GetConnectWidget();
3950
3951 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
3952
3953 if (m_dropTarget) delete m_dropTarget;
3954 m_dropTarget = dropTarget;
3955
3956 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
3957 }
3958
3959 #endif // wxUSE_DRAG_AND_DROP
3960
3961 GtkWidget* wxWindowGTK::GetConnectWidget()
3962 {
3963 GtkWidget *connect_widget = m_widget;
3964 if (m_wxwindow) connect_widget = m_wxwindow;
3965
3966 return connect_widget;
3967 }
3968
3969 bool wxWindowGTK::GTKIsOwnWindow(GdkWindow *window) const
3970 {
3971 wxArrayGdkWindows windowsThis;
3972 GdkWindow * const winThis = GTKGetWindow(windowsThis);
3973
3974 return winThis ? window == winThis
3975 : windowsThis.Index(window) != wxNOT_FOUND;
3976 }
3977
3978 GdkWindow *wxWindowGTK::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
3979 {
3980 return m_wxwindow ? m_wxwindow->window : m_widget->window;
3981 }
3982
3983 bool wxWindowGTK::SetFont( const wxFont &font )
3984 {
3985 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
3986
3987 if (!wxWindowBase::SetFont(font))
3988 return false;
3989
3990 // apply style change (forceStyle=true so that new style is applied
3991 // even if the font changed from valid to wxNullFont):
3992 ApplyWidgetStyle(true);
3993
3994 return true;
3995 }
3996
3997 void wxWindowGTK::DoCaptureMouse()
3998 {
3999 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4000
4001 GdkWindow *window = (GdkWindow*) NULL;
4002 if (m_wxwindow)
4003 window = m_wxwindow->window;
4004 else
4005 window = GetConnectWidget()->window;
4006
4007 wxCHECK_RET( window, _T("CaptureMouse() failed") );
4008
4009 const wxCursor* cursor = &m_cursor;
4010 if (!cursor->Ok())
4011 cursor = wxSTANDARD_CURSOR;
4012
4013 gdk_pointer_grab( window, FALSE,
4014 (GdkEventMask)
4015 (GDK_BUTTON_PRESS_MASK |
4016 GDK_BUTTON_RELEASE_MASK |
4017 GDK_POINTER_MOTION_HINT_MASK |
4018 GDK_POINTER_MOTION_MASK),
4019 (GdkWindow *) NULL,
4020 cursor->GetCursor(),
4021 (guint32)GDK_CURRENT_TIME );
4022 g_captureWindow = this;
4023 g_captureWindowHasMouse = true;
4024 }
4025
4026 void wxWindowGTK::DoReleaseMouse()
4027 {
4028 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4029
4030 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4031
4032 g_captureWindow = (wxWindowGTK*) NULL;
4033
4034 GdkWindow *window = (GdkWindow*) NULL;
4035 if (m_wxwindow)
4036 window = m_wxwindow->window;
4037 else
4038 window = GetConnectWidget()->window;
4039
4040 if (!window)
4041 return;
4042
4043 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4044 }
4045
4046 void wxWindowGTK::GTKReleaseMouseAndNotify()
4047 {
4048 DoReleaseMouse();
4049 wxMouseCaptureLostEvent evt(GetId());
4050 evt.SetEventObject( this );
4051 HandleWindowEvent( evt );
4052 }
4053
4054 /* static */
4055 wxWindow *wxWindowBase::GetCapture()
4056 {
4057 return (wxWindow *)g_captureWindow;
4058 }
4059
4060 bool wxWindowGTK::IsRetained() const
4061 {
4062 return false;
4063 }
4064
4065 void wxWindowGTK::SetScrollbar(int orient,
4066 int pos,
4067 int thumbVisible,
4068 int range,
4069 bool WXUNUSED(update))
4070 {
4071 const int dir = ScrollDirFromOrient(orient);
4072 GtkRange* const sb = m_scrollBar[dir];
4073 wxCHECK_RET( sb, _T("this window is not scrollable") );
4074
4075 if (range <= 0)
4076 {
4077 // GtkRange requires upper > lower
4078 range =
4079 thumbVisible = 1;
4080 }
4081
4082 GtkAdjustment * const adj = sb->adjustment;
4083 adj->step_increment = 1;
4084 adj->page_increment =
4085 adj->page_size = thumbVisible;
4086 adj->value = pos;
4087
4088 g_signal_handlers_block_by_func(
4089 sb, (void*)gtk_scrollbar_value_changed, this);
4090
4091 gtk_range_set_range(sb, 0, range);
4092 m_scrollPos[dir] = sb->adjustment->value;
4093
4094 g_signal_handlers_unblock_by_func(
4095 sb, (void*)gtk_scrollbar_value_changed, this);
4096 }
4097
4098 void wxWindowGTK::SetScrollPos(int orient, int pos, bool WXUNUSED(refresh))
4099 {
4100 const int dir = ScrollDirFromOrient(orient);
4101 GtkRange * const sb = m_scrollBar[dir];
4102 wxCHECK_RET( sb, _T("this window is not scrollable") );
4103
4104 // This check is more than an optimization. Without it, the slider
4105 // will not move smoothly while tracking when using wxScrollHelper.
4106 if (GetScrollPos(orient) != pos)
4107 {
4108 g_signal_handlers_block_by_func(
4109 sb, (void*)gtk_scrollbar_value_changed, this);
4110
4111 gtk_range_set_value(sb, pos);
4112 m_scrollPos[dir] = sb->adjustment->value;
4113
4114 g_signal_handlers_unblock_by_func(
4115 sb, (void*)gtk_scrollbar_value_changed, this);
4116 }
4117 }
4118
4119 int wxWindowGTK::GetScrollThumb(int orient) const
4120 {
4121 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4122 wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
4123
4124 return int(sb->adjustment->page_size);
4125 }
4126
4127 int wxWindowGTK::GetScrollPos( int orient ) const
4128 {
4129 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4130 wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
4131
4132 return int(sb->adjustment->value + 0.5);
4133 }
4134
4135 int wxWindowGTK::GetScrollRange( int orient ) const
4136 {
4137 GtkRange * const sb = m_scrollBar[ScrollDirFromOrient(orient)];
4138 wxCHECK_MSG( sb, 0, _T("this window is not scrollable") );
4139
4140 return int(sb->adjustment->upper);
4141 }
4142
4143 // Determine if increment is the same as +/-x, allowing for some small
4144 // difference due to possible inexactness in floating point arithmetic
4145 static inline bool IsScrollIncrement(double increment, double x)
4146 {
4147 wxASSERT(increment > 0);
4148 const double tolerance = 1.0 / 1024;
4149 return fabs(increment - fabs(x)) < tolerance;
4150 }
4151
4152 wxEventType wxWindowGTK::GetScrollEventType(GtkRange* range)
4153 {
4154 wxASSERT(range == m_scrollBar[0] || range == m_scrollBar[1]);
4155
4156 const int barIndex = range == m_scrollBar[1];
4157 GtkAdjustment* adj = range->adjustment;
4158
4159 const int value = int(adj->value + 0.5);
4160
4161 // save previous position
4162 const double oldPos = m_scrollPos[barIndex];
4163 // update current position
4164 m_scrollPos[barIndex] = adj->value;
4165 // If event should be ignored, or integral position has not changed
4166 if (!m_hasVMT || g_blockEventsOnDrag || value == int(oldPos + 0.5))
4167 {
4168 return wxEVT_NULL;
4169 }
4170
4171 wxEventType eventType = wxEVT_SCROLL_THUMBTRACK;
4172 if (!m_isScrolling)
4173 {
4174 // Difference from last change event
4175 const double diff = adj->value - oldPos;
4176 const bool isDown = diff > 0;
4177
4178 if (IsScrollIncrement(adj->step_increment, diff))
4179 {
4180 eventType = isDown ? wxEVT_SCROLL_LINEDOWN : wxEVT_SCROLL_LINEUP;
4181 }
4182 else if (IsScrollIncrement(adj->page_increment, diff))
4183 {
4184 eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
4185 }
4186 else if (m_mouseButtonDown)
4187 {
4188 // Assume track event
4189 m_isScrolling = true;
4190 }
4191 }
4192 return eventType;
4193 }
4194
4195 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4196 {
4197 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4198
4199 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4200
4201 // No scrolling requested.
4202 if ((dx == 0) && (dy == 0)) return;
4203
4204 m_clipPaintRegion = true;
4205
4206 WX_PIZZA(m_wxwindow)->scroll(dx, dy);
4207
4208 m_clipPaintRegion = false;
4209
4210 #if wxUSE_CARET
4211 bool restoreCaret = (GetCaret() != NULL && GetCaret()->IsVisible());
4212 if (restoreCaret)
4213 {
4214 wxRect caretRect(GetCaret()->GetPosition(), GetCaret()->GetSize());
4215 if (dx > 0)
4216 caretRect.width += dx;
4217 else
4218 {
4219 caretRect.x += dx; caretRect.width -= dx;
4220 }
4221 if (dy > 0)
4222 caretRect.height += dy;
4223 else
4224 {
4225 caretRect.y += dy; caretRect.height -= dy;
4226 }
4227
4228 RefreshRect(caretRect);
4229 }
4230 #endif // wxUSE_CARET
4231 }
4232
4233 void wxWindowGTK::GtkScrolledWindowSetBorder(GtkWidget* w, int wxstyle)
4234 {
4235 //RN: Note that static controls usually have no border on gtk, so maybe
4236 //it makes sense to treat that as simply no border at the wx level
4237 //as well...
4238 if (!(wxstyle & wxNO_BORDER) && !(wxstyle & wxBORDER_STATIC))
4239 {
4240 GtkShadowType gtkstyle;
4241
4242 if(wxstyle & wxBORDER_RAISED)
4243 gtkstyle = GTK_SHADOW_OUT;
4244 else if (wxstyle & wxBORDER_SUNKEN)
4245 gtkstyle = GTK_SHADOW_IN;
4246 #if 0
4247 // Now obsolete
4248 else if (wxstyle & wxBORDER_DOUBLE)
4249 gtkstyle = GTK_SHADOW_ETCHED_IN;
4250 #endif
4251 else //default
4252 gtkstyle = GTK_SHADOW_IN;
4253
4254 gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(w),
4255 gtkstyle );
4256 }
4257 }
4258
4259 void wxWindowGTK::SetWindowStyleFlag( long style )
4260 {
4261 // Updates the internal variable. NB: Now m_windowStyle bits carry the _new_ style values already
4262 wxWindowBase::SetWindowStyleFlag(style);
4263 }
4264
4265 // Find the wxWindow at the current mouse position, also returning the mouse
4266 // position.
4267 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4268 {
4269 pt = wxGetMousePosition();
4270 wxWindow* found = wxFindWindowAtPoint(pt);
4271 return found;
4272 }
4273
4274 // Get the current mouse position.
4275 wxPoint wxGetMousePosition()
4276 {
4277 /* This crashes when used within wxHelpContext,
4278 so we have to use the X-specific implementation below.
4279 gint x, y;
4280 GdkModifierType *mask;
4281 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4282
4283 return wxPoint(x, y);
4284 */
4285
4286 int x, y;
4287 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4288
4289 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4290 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4291 Window rootReturn, childReturn;
4292 int rootX, rootY, winX, winY;
4293 unsigned int maskReturn;
4294
4295 XQueryPointer (display,
4296 rootWindow,
4297 &rootReturn,
4298 &childReturn,
4299 &rootX, &rootY, &winX, &winY, &maskReturn);
4300 return wxPoint(rootX, rootY);
4301
4302 }
4303
4304 GdkWindow* wxWindowGTK::GTKGetDrawingWindow() const
4305 {
4306 GdkWindow* window = NULL;
4307 if (m_wxwindow)
4308 window = m_wxwindow->window;
4309 return window;
4310 }
4311
4312 // ----------------------------------------------------------------------------
4313 // freeze/thaw
4314 // ----------------------------------------------------------------------------
4315
4316 extern "C"
4317 {
4318
4319 // this is called if we attempted to freeze unrealized widget when it finally
4320 // is realized (and so can be frozen):
4321 static void wx_frozen_widget_realize(GtkWidget* w, void* WXUNUSED(data))
4322 {
4323 wxASSERT( w && !GTK_WIDGET_NO_WINDOW(w) );
4324 wxASSERT( GTK_WIDGET_REALIZED(w) );
4325
4326 g_signal_handlers_disconnect_by_func
4327 (
4328 w,
4329 (void*)wx_frozen_widget_realize,
4330 NULL
4331 );
4332
4333 gdk_window_freeze_updates(w->window);
4334 }
4335
4336 } // extern "C"
4337
4338 void wxWindowGTK::GTKFreezeWidget(GtkWidget *w)
4339 {
4340 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4341 return; // window-less widget, cannot be frozen
4342
4343 if ( !GTK_WIDGET_REALIZED(w) )
4344 {
4345 // we can't thaw unrealized widgets because they don't have GdkWindow,
4346 // so set it up to be done immediately after realization:
4347 g_signal_connect_after
4348 (
4349 w,
4350 "realize",
4351 G_CALLBACK(wx_frozen_widget_realize),
4352 NULL
4353 );
4354 return;
4355 }
4356
4357 gdk_window_freeze_updates(w->window);
4358 }
4359
4360 void wxWindowGTK::GTKThawWidget(GtkWidget *w)
4361 {
4362 if ( !w || GTK_WIDGET_NO_WINDOW(w) )
4363 return; // window-less widget, cannot be frozen
4364
4365 if ( !GTK_WIDGET_REALIZED(w) )
4366 {
4367 // the widget wasn't realized yet, no need to thaw
4368 g_signal_handlers_disconnect_by_func
4369 (
4370 w,
4371 (void*)wx_frozen_widget_realize,
4372 NULL
4373 );
4374 return;
4375 }
4376
4377 gdk_window_thaw_updates(w->window);
4378 }
4379
4380 void wxWindowGTK::DoFreeze()
4381 {
4382 GTKFreezeWidget(m_widget);
4383 if ( m_wxwindow && m_widget != m_wxwindow )
4384 GTKFreezeWidget(m_wxwindow);
4385 }
4386
4387 void wxWindowGTK::DoThaw()
4388 {
4389 GTKThawWidget(m_widget);
4390 if ( m_wxwindow && m_widget != m_wxwindow )
4391 GTKThawWidget(m_wxwindow);
4392 }
wxWidgets (Impactor)