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