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