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