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