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