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