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