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