]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/window.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
fixed Xcode 1.2 warnings; code cleanup
[wxWidgets.git] / src / gtk1 / 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 event.m_linesPerAction = 3; \
1369 if (((GdkEventButton*)gdk_event)->button == 4) \
1370 event.m_wheelRotation = 120; \
1371 else if (((GdkEventButton*)gdk_event)->button == 5) \
1372 event.m_wheelRotation = -120; \
1373 } \
1374 \
1375 wxPoint pt = win->GetClientAreaOrigin(); \
1376 event.m_x = (wxCoord)gdk_event->x - pt.x; \
1377 event.m_y = (wxCoord)gdk_event->y - pt.y; \
1378 \
1379 event.SetEventObject( win ); \
1380 event.SetId( win->GetId() ); \
1381 event.SetTimestamp( gdk_event->time ); \
1382} \
1383
1384static void AdjustEventButtonState(wxMouseEvent& event)
1385{
1386 // GDK reports the old state of the button for a button press event, but
1387 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1388 // for a LEFT_DOWN event, not FALSE, so we will invert
1389 // left/right/middleDown for the corresponding click events
1390
1391 if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1392 (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1393 (event.GetEventType() == wxEVT_LEFT_UP))
1394 {
1395 event.m_leftDown = !event.m_leftDown;
1396 return;
1397 }
1398
1399 if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1400 (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1401 (event.GetEventType() == wxEVT_MIDDLE_UP))
1402 {
1403 event.m_middleDown = !event.m_middleDown;
1404 return;
1405 }
1406
1407 if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1408 (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1409 (event.GetEventType() == wxEVT_RIGHT_UP))
1410 {
1411 event.m_rightDown = !event.m_rightDown;
1412 return;
1413 }
1414}
1415
1416// find the window to send the mouse event too
1417static
1418wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1419{
1420 wxCoord xx = x;
1421 wxCoord yy = y;
1422
1423 if (win->m_wxwindow)
1424 {
1425 GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
1426 xx += pizza->xoffset;
1427 yy += pizza->yoffset;
1428 }
1429
1430 wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
1431 while (node)
1432 {
1433 wxWindowGTK *child = node->GetData();
1434
1435 node = node->GetNext();
1436 if (!child->IsShown())
1437 continue;
1438
1439 if (child->IsTransparentForMouse())
1440 {
1441 // wxStaticBox is transparent in the box itself
1442 int xx1 = child->m_x;
1443 int yy1 = child->m_y;
1444 int xx2 = child->m_x + child->m_width;
1445 int yy2 = child->m_y + child->m_height;
1446
1447 // left
1448 if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
1449 // right
1450 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
1451 // top
1452 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
1453 // bottom
1454 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
1455 {
1456 win = child;
1457 x -= child->m_x;
1458 y -= child->m_y;
1459 break;
1460 }
1461
1462 }
1463 else
1464 {
1465 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
1466 (child->m_x <= xx) &&
1467 (child->m_y <= yy) &&
1468 (child->m_x+child->m_width >= xx) &&
1469 (child->m_y+child->m_height >= yy))
1470 {
1471 win = child;
1472 x -= child->m_x;
1473 y -= child->m_y;
1474 break;
1475 }
1476 }
1477 }
1478
1479 return win;
1480}
1481
1482//-----------------------------------------------------------------------------
1483// "button_press_event"
1484//-----------------------------------------------------------------------------
1485
1486static gint gtk_window_button_press_callback( GtkWidget *widget,
1487 GdkEventButton *gdk_event,
1488 wxWindowGTK *win )
1489{
1490 DEBUG_MAIN_THREAD
1491
1492 if (g_isIdle)
1493 wxapp_install_idle_handler();
1494
1495/*
1496 wxPrintf( wxT("1) OnButtonPress from ") );
1497 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1498 wxPrintf( win->GetClassInfo()->GetClassName() );
1499 wxPrintf( wxT(".\n") );
1500*/
1501 if (!win->m_hasVMT) return FALSE;
1502 if (g_blockEventsOnDrag) return TRUE;
1503 if (g_blockEventsOnScroll) return TRUE;
1504
1505 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1506
1507 if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())
1508 {
1509 gtk_widget_grab_focus( win->m_wxwindow );
1510/*
1511 wxPrintf( wxT("GrabFocus from ") );
1512 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1513 wxPrintf( win->GetClassInfo()->GetClassName() );
1514 wxPrintf( wxT(".\n") );
1515*/
1516 }
1517
1518 // GDK sends surplus button down event
1519 // before a double click event. We
1520 // need to filter these out.
1521 if (gdk_event->type == GDK_BUTTON_PRESS)
1522 {
1523 GdkEvent *peek_event = gdk_event_peek();
1524 if (peek_event)
1525 {
1526 if ((peek_event->type == GDK_2BUTTON_PRESS) ||
1527 (peek_event->type == GDK_3BUTTON_PRESS))
1528 {
1529 gdk_event_free( peek_event );
1530 return TRUE;
1531 }
1532 else
1533 {
1534 gdk_event_free( peek_event );
1535 }
1536 }
1537 }
1538
1539 wxEventType event_type = wxEVT_NULL;
1540
1541 // GdkDisplay is a GTK+ 2.1.0 thing
1542#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 1, 0)
1543 if ( gdk_event->type == GDK_2BUTTON_PRESS &&
1544 gdk_event->button >= 1 && gdk_event->button <= 3 )
1545 {
1546 // Reset GDK internal timestamp variables in order to disable GDK
1547 // triple click events. GDK will then next time believe no button has
1548 // been clicked just before, and send a normal button click event.
1549 GdkDisplay* display = gtk_widget_get_display (widget);
1550 display->button_click_time[1] = 0;
1551 display->button_click_time[0] = 0;
1552 }
1553#endif // GTK 2+
1554
1555 if (gdk_event->button == 1)
1556 {
1557 // note that GDK generates triple click events which are not supported
1558 // by wxWindows but still have to be passed to the app as otherwise
1559 // clicks would simply go missing
1560 switch (gdk_event->type)
1561 {
1562 // we shouldn't get triple clicks at all for GTK2 because we
1563 // suppress them artificially using the code above but we still
1564 // should map them to something for GTK1 and not just ignore them
1565 // as this would lose clicks
1566 case GDK_3BUTTON_PRESS: // we could also map this to DCLICK...
1567 case GDK_BUTTON_PRESS:
1568 event_type = wxEVT_LEFT_DOWN;
1569 break;
1570
1571 case GDK_2BUTTON_PRESS:
1572 event_type = wxEVT_LEFT_DCLICK;
1573 break;
1574
1575 default:
1576 // just to silence gcc warnings
1577 ;
1578 }
1579 }
1580 else if (gdk_event->button == 2)
1581 {
1582 switch (gdk_event->type)
1583 {
1584 case GDK_3BUTTON_PRESS:
1585 case GDK_BUTTON_PRESS:
1586 event_type = wxEVT_MIDDLE_DOWN;
1587 break;
1588
1589 case GDK_2BUTTON_PRESS:
1590 event_type = wxEVT_MIDDLE_DCLICK;
1591 break;
1592
1593 default:
1594 ;
1595 }
1596 }
1597 else if (gdk_event->button == 3)
1598 {
1599 switch (gdk_event->type)
1600 {
1601 case GDK_3BUTTON_PRESS:
1602 case GDK_BUTTON_PRESS:
1603 event_type = wxEVT_RIGHT_DOWN;
1604 break;
1605
1606 case GDK_2BUTTON_PRESS:
1607 event_type = wxEVT_RIGHT_DCLICK;
1608 break;
1609
1610 default:
1611 ;
1612 }
1613 }
1614 else if (gdk_event->button == 4 || gdk_event->button == 5)
1615 {
1616 if (gdk_event->type == GDK_BUTTON_PRESS )
1617 {
1618 event_type = wxEVT_MOUSEWHEEL;
1619 }
1620 }
1621
1622 if ( event_type == wxEVT_NULL )
1623 {
1624 // unknown mouse button or click type
1625 return FALSE;
1626 }
1627
1628 wxMouseEvent event( event_type );
1629 InitMouseEvent( win, event, gdk_event );
1630
1631 AdjustEventButtonState(event);
1632
1633 // wxListBox actually get mouse events from the item, so we need to give it
1634 // a chance to correct this
1635 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1636
1637 // find the correct window to send the event too: it may be a different one
1638 // from the one which got it at GTK+ level because some control don't have
1639 // their own X window and thus cannot get any events.
1640 if ( !g_captureWindow )
1641 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1642
1643 gs_timeLastClick = gdk_event->time;
1644
1645/*
1646 wxPrintf( wxT("2) OnButtonPress from ") );
1647 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1648 wxPrintf( win->GetClassInfo()->GetClassName() );
1649 wxPrintf( wxT(".\n") );
1650*/
1651
1652#ifndef __WXGTK20__
1653 if (event_type == wxEVT_LEFT_DCLICK)
1654 {
1655 // GTK 1.2 crashes when intercepting double
1656 // click events from both wxSpinButton and
1657 // wxSpinCtrl
1658 if (GTK_IS_SPIN_BUTTON(win->m_widget))
1659 {
1660 // Just disable this event for now.
1661 return FALSE;
1662 }
1663 }
1664#endif
1665
1666 if (win->GetEventHandler()->ProcessEvent( event ))
1667 {
1668 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
1669 return TRUE;
1670 }
1671
1672 return FALSE;
1673}
1674
1675//-----------------------------------------------------------------------------
1676// "button_release_event"
1677//-----------------------------------------------------------------------------
1678
1679static gint gtk_window_button_release_callback( GtkWidget *widget,
1680 GdkEventButton *gdk_event,
1681 wxWindowGTK *win )
1682{
1683 DEBUG_MAIN_THREAD
1684
1685 if (g_isIdle)
1686 wxapp_install_idle_handler();
1687
1688 if (!win->m_hasVMT) return FALSE;
1689 if (g_blockEventsOnDrag) return FALSE;
1690 if (g_blockEventsOnScroll) return FALSE;
1691
1692 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1693
1694 wxEventType event_type = wxEVT_NULL;
1695
1696 switch (gdk_event->button)
1697 {
1698 case 1:
1699 event_type = wxEVT_LEFT_UP;
1700 break;
1701
1702 case 2:
1703 event_type = wxEVT_MIDDLE_UP;
1704 break;
1705
1706 case 3:
1707 event_type = wxEVT_RIGHT_UP;
1708 break;
1709
1710 default:
1711 // unknwon button, don't process
1712 return FALSE;
1713 }
1714
1715 wxMouseEvent event( event_type );
1716 InitMouseEvent( win, event, gdk_event );
1717
1718 AdjustEventButtonState(event);
1719
1720 // same wxListBox hack as above
1721 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1722
1723 if ( event_type == wxEVT_RIGHT_UP )
1724 {
1725 // generate a "context menu" event: this is similar to wxEVT_RIGHT_UP
1726 // except that:
1727 //
1728 // (a) it's a command event and so is propagated to the parent
1729 // (b) under MSW it can be generated from kbd too
1730 // (c) it uses screen coords (because of (a))
1731 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
1732 win->GetId(),
1733 win->ClientToScreen(event.GetPosition()));
1734 (void)win->GetEventHandler()->ProcessEvent(evtCtx);
1735 }
1736
1737 if ( !g_captureWindow )
1738 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1739
1740 if (win->GetEventHandler()->ProcessEvent( event ))
1741 {
1742 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
1743 return TRUE;
1744 }
1745
1746 return FALSE;
1747}
1748
1749//-----------------------------------------------------------------------------
1750// "motion_notify_event"
1751//-----------------------------------------------------------------------------
1752
1753static gint gtk_window_motion_notify_callback( GtkWidget *widget,
1754 GdkEventMotion *gdk_event,
1755 wxWindowGTK *win )
1756{
1757 DEBUG_MAIN_THREAD
1758
1759 if (g_isIdle)
1760 wxapp_install_idle_handler();
1761
1762 if (!win->m_hasVMT) return FALSE;
1763 if (g_blockEventsOnDrag) return FALSE;
1764 if (g_blockEventsOnScroll) return FALSE;
1765
1766 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1767
1768 if (gdk_event->is_hint)
1769 {
1770 int x = 0;
1771 int y = 0;
1772 GdkModifierType state;
1773 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1774 gdk_event->x = x;
1775 gdk_event->y = y;
1776 }
1777
1778/*
1779 printf( "OnMotion from " );
1780 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1781 printf( win->GetClassInfo()->GetClassName() );
1782 printf( ".\n" );
1783*/
1784
1785 wxMouseEvent event( wxEVT_MOTION );
1786 InitMouseEvent(win, event, gdk_event);
1787
1788 if ( g_captureWindow )
1789 {
1790 // synthetize a mouse enter or leave event if needed
1791 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1792 // This seems to be necessary and actually been added to
1793 // GDK itself in version 2.0.X
1794 gdk_flush();
1795
1796 bool hasMouse = winUnderMouse == gdk_event->window;
1797 if ( hasMouse != g_captureWindowHasMouse )
1798 {
1799 // the mouse changed window
1800 g_captureWindowHasMouse = hasMouse;
1801
1802 wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1803 : wxEVT_LEAVE_WINDOW);
1804 InitMouseEvent(win, event, gdk_event);
1805 event.SetEventObject(win);
1806 win->GetEventHandler()->ProcessEvent(event);
1807 }
1808 }
1809 else // no capture
1810 {
1811 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1812 }
1813
1814 if (win->GetEventHandler()->ProcessEvent( event ))
1815 {
1816 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
1817 return TRUE;
1818 }
1819
1820 return FALSE;
1821}
1822
1823#ifdef __WXGTK20__
1824//-----------------------------------------------------------------------------
1825// "mouse_wheel_event"
1826//-----------------------------------------------------------------------------
1827
1828static gint gtk_window_wheel_callback (GtkWidget * widget,
1829 GdkEventScroll * gdk_event,
1830 wxWindowGTK * win)
1831{
1832 DEBUG_MAIN_THREAD
1833
1834 if (g_isIdle)
1835 wxapp_install_idle_handler();
1836
1837 wxEventType event_type = wxEVT_NULL;
1838 if (gdk_event->direction == GDK_SCROLL_UP)
1839 event_type = wxEVT_MOUSEWHEEL;
1840 else if (gdk_event->direction == GDK_SCROLL_DOWN)
1841 event_type = wxEVT_MOUSEWHEEL;
1842 else
1843 return FALSE;
1844
1845 wxMouseEvent event( event_type );
1846 // Can't use InitMouse macro because scroll events don't have button
1847 event.SetTimestamp( gdk_event->time );
1848 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1849 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1850 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1851 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1852 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1853 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1854 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
1855 event.m_linesPerAction = 3;
1856 if (gdk_event->direction == GDK_SCROLL_UP)
1857 event.m_wheelRotation = 120;
1858 else
1859 event.m_wheelRotation = -120;
1860
1861 wxPoint pt = win->GetClientAreaOrigin();
1862 event.m_x = (wxCoord)gdk_event->x - pt.x;
1863 event.m_y = (wxCoord)gdk_event->y - pt.y;
1864
1865 event.SetEventObject( win );
1866 event.SetId( win->GetId() );
1867 event.SetTimestamp( gdk_event->time );
1868
1869 if (win->GetEventHandler()->ProcessEvent( event ))
1870 {
1871 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "scroll_event" );
1872 return TRUE;
1873 }
1874
1875 return FALSE;
1876}
1877#endif
1878
1879//-----------------------------------------------------------------------------
1880// "focus_in_event"
1881//-----------------------------------------------------------------------------
1882
1883// send the wxChildFocusEvent and wxFocusEvent, common code of
1884// gtk_window_focus_in_callback() and SetFocus()
1885static bool DoSendFocusEvents(wxWindow *win)
1886{
1887 // Notify the parent keeping track of focus for the kbd navigation
1888 // purposes that we got it.
1889 wxChildFocusEvent eventChildFocus(win);
1890 (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
1891
1892 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1893 eventFocus.SetEventObject(win);
1894
1895 return win->GetEventHandler()->ProcessEvent(eventFocus);
1896}
1897
1898static gint gtk_window_focus_in_callback( GtkWidget *widget,
1899 GdkEvent *WXUNUSED(event),
1900 wxWindow *win )
1901{
1902 DEBUG_MAIN_THREAD
1903
1904 if (g_isIdle)
1905 wxapp_install_idle_handler();
1906
1907 if (!win->m_hasVMT) return FALSE;
1908 if (g_blockEventsOnDrag) return FALSE;
1909
1910 switch ( g_sendActivateEvent )
1911 {
1912 case -1:
1913 // we've got focus from outside, synthetize wxActivateEvent
1914 g_sendActivateEvent = 1;
1915 break;
1916
1917 case 0:
1918 // another our window just lost focus, it was already ours before
1919 // - don't send any wxActivateEvent
1920 g_sendActivateEvent = -1;
1921 break;
1922 }
1923
1924 g_focusWindowLast =
1925 g_focusWindow = win;
1926
1927 wxLogTrace(TRACE_FOCUS,
1928 _T("%s: focus in"), win->GetName().c_str());
1929
1930#ifdef HAVE_XIM
1931 if (win->m_ic)
1932 gdk_im_begin(win->m_ic, win->m_wxwindow->window);
1933#endif
1934
1935#if wxUSE_CARET
1936 // caret needs to be informed about focus change
1937 wxCaret *caret = win->GetCaret();
1938 if ( caret )
1939 {
1940 caret->OnSetFocus();
1941 }
1942#endif // wxUSE_CARET
1943
1944 g_activeFrameLostFocus = FALSE;
1945
1946 wxWindowGTK *active = wxGetTopLevelParent(win);
1947 if ( active != g_activeFrame )
1948 {
1949 if ( g_activeFrame )
1950 {
1951 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame);
1952 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
1953 event.SetEventObject(g_activeFrame);
1954 g_activeFrame->GetEventHandler()->ProcessEvent(event);
1955 }
1956
1957 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active);
1958 g_activeFrame = active;
1959 wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
1960 event.SetEventObject(g_activeFrame);
1961 g_activeFrame->GetEventHandler()->ProcessEvent(event);
1962
1963 // Don't send focus events in addition to activate
1964 // if (win == g_activeFrame)
1965 // return TRUE;
1966 }
1967
1968 // does the window itself think that it has the focus?
1969 if ( !win->m_hasFocus )
1970 {
1971 // not yet, notify it
1972 win->m_hasFocus = TRUE;
1973
1974 if ( DoSendFocusEvents(win) )
1975 {
1976 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
1977 return TRUE;
1978 }
1979 }
1980
1981 return FALSE;
1982}
1983
1984//-----------------------------------------------------------------------------
1985// "focus_out_event"
1986//-----------------------------------------------------------------------------
1987
1988static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
1989{
1990 DEBUG_MAIN_THREAD
1991
1992 if (g_isIdle)
1993 wxapp_install_idle_handler();
1994
1995 if (!win->m_hasVMT) return FALSE;
1996 if (g_blockEventsOnDrag) return FALSE;
1997
1998 wxLogTrace( TRACE_FOCUS,
1999 _T("%s: focus out"), win->GetName().c_str() );
2000
2001 if ( !g_activeFrameLostFocus && g_activeFrame )
2002 {
2003 // VZ: commenting this out because it does happen (although not easy
2004 // to reproduce, I only see it when using wxMiniFrame and not
2005 // always) and makes using Mahogany quite annoying
2006#if 0
2007 wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame,
2008 wxT("unfocusing window that hasn't gained focus properly") );
2009#endif // 0
2010
2011 g_activeFrameLostFocus = TRUE;
2012 }
2013
2014 // if the focus goes out of our app alltogether, OnIdle() will send
2015 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
2016 // g_sendActivateEvent to -1
2017 g_sendActivateEvent = 0;
2018
2019 wxWindowGTK *winFocus = wxFindFocusedChild(win);
2020 if ( winFocus )
2021 win = winFocus;
2022
2023 g_focusWindow = (wxWindowGTK *)NULL;
2024
2025#ifdef HAVE_XIM
2026 if (win->m_ic)
2027 gdk_im_end();
2028#endif
2029
2030#if wxUSE_CARET
2031 // caret needs to be informed about focus change
2032 wxCaret *caret = win->GetCaret();
2033 if ( caret )
2034 {
2035 caret->OnKillFocus();
2036 }
2037#endif // wxUSE_CARET
2038
2039 // don't send the window a kill focus event if it thinks that it doesn't
2040 // have focus already
2041 if ( win->m_hasFocus )
2042 {
2043 win->m_hasFocus = FALSE;
2044
2045 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
2046 event.SetEventObject( win );
2047
2048 if (win->GetEventHandler()->ProcessEvent( event ))
2049 {
2050 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
2051 return TRUE;
2052 }
2053 }
2054
2055 return FALSE;
2056}
2057
2058//-----------------------------------------------------------------------------
2059// "enter_notify_event"
2060//-----------------------------------------------------------------------------
2061
2062static
2063gint gtk_window_enter_callback( GtkWidget *widget,
2064 GdkEventCrossing *gdk_event,
2065 wxWindowGTK *win )
2066{
2067 DEBUG_MAIN_THREAD
2068
2069 if (g_isIdle)
2070 wxapp_install_idle_handler();
2071
2072 if (!win->m_hasVMT) return FALSE;
2073 if (g_blockEventsOnDrag) return FALSE;
2074
2075 // Event was emitted after a grab
2076 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
2077
2078 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
2079
2080 int x = 0;
2081 int y = 0;
2082 GdkModifierType state = (GdkModifierType)0;
2083
2084 gdk_window_get_pointer( widget->window, &x, &y, &state );
2085
2086 wxMouseEvent event( wxEVT_ENTER_WINDOW );
2087 InitMouseEvent(win, event, gdk_event);
2088 wxPoint pt = win->GetClientAreaOrigin();
2089 event.m_x = x + pt.x;
2090 event.m_y = y + pt.y;
2091
2092 if (win->GetEventHandler()->ProcessEvent( event ))
2093 {
2094 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
2095 return TRUE;
2096 }
2097
2098 return FALSE;
2099}
2100
2101//-----------------------------------------------------------------------------
2102// "leave_notify_event"
2103//-----------------------------------------------------------------------------
2104
2105static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
2106{
2107 DEBUG_MAIN_THREAD
2108
2109 if (g_isIdle)
2110 wxapp_install_idle_handler();
2111
2112 if (!win->m_hasVMT) return FALSE;
2113 if (g_blockEventsOnDrag) return FALSE;
2114
2115 // Event was emitted after an ungrab
2116 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
2117
2118 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
2119
2120 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
2121 event.SetTimestamp( gdk_event->time );
2122 event.SetEventObject( win );
2123
2124 int x = 0;
2125 int y = 0;
2126 GdkModifierType state = (GdkModifierType)0;
2127
2128 gdk_window_get_pointer( widget->window, &x, &y, &state );
2129
2130 event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
2131 event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
2132 event.m_altDown = (state & GDK_MOD1_MASK) != 0;
2133 event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
2134 event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
2135 event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
2136 event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
2137
2138 wxPoint pt = win->GetClientAreaOrigin();
2139 event.m_x = x + pt.x;
2140 event.m_y = y + pt.y;
2141
2142 if (win->GetEventHandler()->ProcessEvent( event ))
2143 {
2144 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
2145 return TRUE;
2146 }
2147
2148 return FALSE;
2149}
2150
2151//-----------------------------------------------------------------------------
2152// "value_changed" from m_vAdjust
2153//-----------------------------------------------------------------------------
2154
2155static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
2156 SCROLLBAR_CBACK_ARG
2157 wxWindowGTK *win )
2158{
2159 DEBUG_MAIN_THREAD
2160
2161 if (g_isIdle)
2162 wxapp_install_idle_handler();
2163
2164 if (g_blockEventsOnDrag) return;
2165
2166 if (!win->m_hasVMT) return;
2167
2168 float diff = adjust->value - win->m_oldVerticalPos;
2169 if (fabs(diff) < 0.2) return;
2170
2171 win->m_oldVerticalPos = adjust->value;
2172
2173#ifndef __WXGTK20__
2174 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
2175#endif
2176 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
2177
2178 int value = (int)(adjust->value+0.5);
2179
2180 wxScrollWinEvent event( command, value, wxVERTICAL );
2181 event.SetEventObject( win );
2182 win->GetEventHandler()->ProcessEvent( event );
2183}
2184
2185//-----------------------------------------------------------------------------
2186// "value_changed" from m_hAdjust
2187//-----------------------------------------------------------------------------
2188
2189static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
2190 SCROLLBAR_CBACK_ARG
2191 wxWindowGTK *win )
2192{
2193 DEBUG_MAIN_THREAD
2194
2195 if (g_isIdle)
2196 wxapp_install_idle_handler();
2197
2198 if (g_blockEventsOnDrag) return;
2199 if (!win->m_hasVMT) return;
2200
2201 float diff = adjust->value - win->m_oldHorizontalPos;
2202 if (fabs(diff) < 0.2) return;
2203
2204#ifndef __WXGTK20__
2205 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
2206#endif
2207 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
2208
2209 win->m_oldHorizontalPos = adjust->value;
2210
2211 int value = (int)(adjust->value+0.5);
2212
2213 wxScrollWinEvent event( command, value, wxHORIZONTAL );
2214 event.SetEventObject( win );
2215 win->GetEventHandler()->ProcessEvent( event );
2216}
2217
2218//-----------------------------------------------------------------------------
2219// "button_press_event" from scrollbar
2220//-----------------------------------------------------------------------------
2221
2222static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
2223 GdkEventButton *gdk_event,
2224 wxWindowGTK *win)
2225{
2226 DEBUG_MAIN_THREAD
2227
2228 if (g_isIdle)
2229 wxapp_install_idle_handler();
2230
2231
2232 g_blockEventsOnScroll = TRUE;
2233
2234 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2235#ifndef __WXGTK20__
2236 win->m_isScrolling = (gdk_event->window == widget->slider);
2237#endif
2238
2239 return FALSE;
2240}
2241
2242//-----------------------------------------------------------------------------
2243// "button_release_event" from scrollbar
2244//-----------------------------------------------------------------------------
2245
2246static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
2247 GdkEventButton *WXUNUSED(gdk_event),
2248 wxWindowGTK *win)
2249{
2250 DEBUG_MAIN_THREAD
2251
2252// don't test here as we can release the mouse while being over
2253// a different window than the slider
2254//
2255// if (gdk_event->window != widget->slider) return FALSE;
2256
2257 g_blockEventsOnScroll = FALSE;
2258
2259 if (win->m_isScrolling)
2260 {
2261 wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
2262 int value = -1;
2263 int dir = -1;
2264
2265 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
2266 if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
2267 {
2268 value = (int)(win->m_hAdjust->value+0.5);
2269 dir = wxHORIZONTAL;
2270 }
2271 if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
2272 {
2273 value = (int)(win->m_vAdjust->value+0.5);
2274 dir = wxVERTICAL;
2275 }
2276
2277 wxScrollWinEvent event( command, value, dir );
2278 event.SetEventObject( win );
2279 win->GetEventHandler()->ProcessEvent( event );
2280 }
2281
2282 win->m_isScrolling = FALSE;
2283
2284 return FALSE;
2285}
2286
2287// ----------------------------------------------------------------------------
2288// this wxWindowBase function is implemented here (in platform-specific file)
2289// because it is static and so couldn't be made virtual
2290// ----------------------------------------------------------------------------
2291
2292wxWindow *wxWindowBase::FindFocus()
2293{
2294 // the cast is necessary when we compile in wxUniversal mode
2295 return (wxWindow *)g_focusWindow;
2296}
2297
2298
2299//-----------------------------------------------------------------------------
2300// "realize" from m_widget
2301//-----------------------------------------------------------------------------
2302
2303/* We cannot set colours and fonts before the widget has
2304 been realized, so we do this directly after realization. */
2305
2306static gint
2307gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
2308{
2309 DEBUG_MAIN_THREAD
2310
2311 if (g_isIdle)
2312 wxapp_install_idle_handler();
2313
2314 if (win->m_delayedBackgroundColour && !win->GetThemeEnabled())
2315 win->GtkSetBackgroundColour( win->GetBackgroundColour() );
2316
2317 if (win->m_delayedForegroundColour && !win->GetThemeEnabled())
2318 win->GtkSetForegroundColour( win->GetForegroundColour() );
2319
2320#ifdef __WXGTK20__
2321 if (win->m_imContext)
2322 {
2323 GtkPizza *pizza = GTK_PIZZA( m_widget );
2324 gtk_im_context_set_client_window( (GtkIMContext*) win->m_imContext, pizza->bin_window );
2325 }
2326#endif
2327
2328 wxWindowCreateEvent event( win );
2329 event.SetEventObject( win );
2330 win->GetEventHandler()->ProcessEvent( event );
2331
2332 return FALSE;
2333}
2334
2335//-----------------------------------------------------------------------------
2336// "size_allocate"
2337//-----------------------------------------------------------------------------
2338
2339static
2340void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2341 GtkAllocation *WXUNUSED(alloc),
2342 wxWindow *win )
2343{
2344 if (g_isIdle)
2345 wxapp_install_idle_handler();
2346
2347 if (!win->m_hasScrolling) return;
2348
2349 int client_width = 0;
2350 int client_height = 0;
2351 win->GetClientSize( &client_width, &client_height );
2352 if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2353 return;
2354
2355 win->m_oldClientWidth = client_width;
2356 win->m_oldClientHeight = client_height;
2357
2358 if (!win->m_nativeSizeEvent)
2359 {
2360 wxSizeEvent event( win->GetSize(), win->GetId() );
2361 event.SetEventObject( win );
2362 win->GetEventHandler()->ProcessEvent( event );
2363 }
2364}
2365
2366
2367#ifdef HAVE_XIM
2368 #define WXUNUSED_UNLESS_XIM(param) param
2369#else
2370 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2371#endif
2372
2373/* Resize XIM window */
2374
2375static
2376void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2377 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
2378 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
2379{
2380 if (g_isIdle)
2381 wxapp_install_idle_handler();
2382
2383#ifdef HAVE_XIM
2384 if (!win->m_ic)
2385 return;
2386
2387 if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2388 {
2389 gint width, height;
2390
2391 gdk_window_get_size (widget->window, &width, &height);
2392 win->m_icattr->preedit_area.width = width;
2393 win->m_icattr->preedit_area.height = height;
2394 gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2395 }
2396#endif // HAVE_XIM
2397}
2398
2399//-----------------------------------------------------------------------------
2400// "realize" from m_wxwindow
2401//-----------------------------------------------------------------------------
2402
2403/* Initialize XIM support */
2404
2405static gint
2406gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
2407 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
2408{
2409 if (g_isIdle)
2410 wxapp_install_idle_handler();
2411
2412#ifdef HAVE_XIM
2413 if (win->m_ic) return FALSE;
2414 if (!widget) return FALSE;
2415 if (!gdk_im_ready()) return FALSE;
2416
2417 win->m_icattr = gdk_ic_attr_new();
2418 if (!win->m_icattr) return FALSE;
2419
2420 gint width, height;
2421 GdkEventMask mask;
2422 GdkColormap *colormap;
2423 GdkICAttr *attr = win->m_icattr;
2424 unsigned attrmask = GDK_IC_ALL_REQ;
2425 GdkIMStyle style;
2426 GdkIMStyle supported_style = (GdkIMStyle)
2427 (GDK_IM_PREEDIT_NONE |
2428 GDK_IM_PREEDIT_NOTHING |
2429 GDK_IM_PREEDIT_POSITION |
2430 GDK_IM_STATUS_NONE |
2431 GDK_IM_STATUS_NOTHING);
2432
2433 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2434 supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
2435
2436 attr->style = style = gdk_im_decide_style (supported_style);
2437 attr->client_window = widget->window;
2438
2439 if ((colormap = gtk_widget_get_colormap (widget)) !=
2440 gtk_widget_get_default_colormap ())
2441 {
2442 attrmask |= GDK_IC_PREEDIT_COLORMAP;
2443 attr->preedit_colormap = colormap;
2444 }
2445
2446 attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2447 attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2448 attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2449 attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2450
2451 switch (style & GDK_IM_PREEDIT_MASK)
2452 {
2453 case GDK_IM_PREEDIT_POSITION:
2454 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2455 {
2456 g_warning ("over-the-spot style requires fontset");
2457 break;
2458 }
2459
2460 gdk_window_get_size (widget->window, &width, &height);
2461
2462 attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2463 attr->spot_location.x = 0;
2464 attr->spot_location.y = height;
2465 attr->preedit_area.x = 0;
2466 attr->preedit_area.y = 0;
2467 attr->preedit_area.width = width;
2468 attr->preedit_area.height = height;
2469 attr->preedit_fontset = widget->style->font;
2470
2471 break;
2472 }
2473
2474 win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2475
2476 if (win->m_ic == NULL)
2477 g_warning ("Can't create input context.");
2478 else
2479 {
2480 mask = gdk_window_get_events (widget->window);
2481 mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2482 gdk_window_set_events (widget->window, mask);
2483
2484 if (GTK_WIDGET_HAS_FOCUS(widget))
2485 gdk_im_begin (win->m_ic, widget->window);
2486 }
2487#endif // HAVE_XIM
2488
2489 return FALSE;
2490}
2491
2492//-----------------------------------------------------------------------------
2493// InsertChild for wxWindowGTK.
2494//-----------------------------------------------------------------------------
2495
2496/* Callback for wxWindowGTK. This very strange beast has to be used because
2497 * C++ has no virtual methods in a constructor. We have to emulate a
2498 * virtual function here as wxNotebook requires a different way to insert
2499 * a child in it. I had opted for creating a wxNotebookPage window class
2500 * which would have made this superfluous (such in the MDI window system),
2501 * but no-one was listening to me... */
2502
2503static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
2504{
2505 /* the window might have been scrolled already, do we
2506 have to adapt the position */
2507 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2508 child->m_x += pizza->xoffset;
2509 child->m_y += pizza->yoffset;
2510
2511 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
2512 GTK_WIDGET(child->m_widget),
2513 child->m_x,
2514 child->m_y,
2515 child->m_width,
2516 child->m_height );
2517}
2518
2519//-----------------------------------------------------------------------------
2520// global functions
2521//-----------------------------------------------------------------------------
2522
2523wxWindow *wxGetActiveWindow()
2524{
2525 return wxWindow::FindFocus();
2526}
2527
2528//-----------------------------------------------------------------------------
2529// wxWindowGTK
2530//-----------------------------------------------------------------------------
2531
2532// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2533// method
2534#ifdef __WXUNIVERSAL__
2535 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2536#else // __WXGTK__
2537 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
2538#endif // __WXUNIVERSAL__/__WXGTK__
2539
2540void wxWindowGTK::Init()
2541{
2542 // GTK specific
2543 m_widget = (GtkWidget *) NULL;
2544 m_wxwindow = (GtkWidget *) NULL;
2545 m_focusWidget = (GtkWidget *) NULL;
2546
2547 // position/size
2548 m_x = 0;
2549 m_y = 0;
2550 m_width = 0;
2551 m_height = 0;
2552
2553 m_sizeSet = FALSE;
2554 m_hasVMT = FALSE;
2555 m_needParent = TRUE;
2556 m_isBeingDeleted = FALSE;
2557
2558 m_noExpose = FALSE;
2559 m_nativeSizeEvent = FALSE;
2560
2561 m_hasScrolling = FALSE;
2562 m_isScrolling = FALSE;
2563
2564 m_hAdjust = (GtkAdjustment*) NULL;
2565 m_vAdjust = (GtkAdjustment*) NULL;
2566 m_oldHorizontalPos =
2567 m_oldVerticalPos = 0.0;
2568 m_oldClientWidth =
2569 m_oldClientHeight = 0;
2570
2571 m_resizing = FALSE;
2572 m_widgetStyle = (GtkStyle*) NULL;
2573
2574 m_insertCallback = (wxInsertChildFunction) NULL;
2575
2576 m_acceptsFocus = FALSE;
2577 m_hasFocus = FALSE;
2578
2579 m_clipPaintRegion = FALSE;
2580
2581 m_cursor = *wxSTANDARD_CURSOR;
2582
2583 m_delayedForegroundColour = FALSE;
2584 m_delayedBackgroundColour = FALSE;
2585
2586#ifdef __WXGTK20__
2587 m_imContext = NULL;
2588 m_x11Context = NULL;
2589#else
2590#ifdef HAVE_XIM
2591 m_ic = (GdkIC*) NULL;
2592 m_icattr = (GdkICAttr*) NULL;
2593#endif
2594#endif
2595}
2596
2597wxWindowGTK::wxWindowGTK()
2598{
2599 Init();
2600}
2601
2602wxWindowGTK::wxWindowGTK( wxWindow *parent,
2603 wxWindowID id,
2604 const wxPoint &pos,
2605 const wxSize &size,
2606 long style,
2607 const wxString &name )
2608{
2609 Init();
2610
2611 Create( parent, id, pos, size, style, name );
2612}
2613
2614bool wxWindowGTK::Create( wxWindow *parent,
2615 wxWindowID id,
2616 const wxPoint &pos,
2617 const wxSize &size,
2618 long style,
2619 const wxString &name )
2620{
2621 if (!PreCreation( parent, pos, size ) ||
2622 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2623 {
2624 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2625 return FALSE;
2626 }
2627
2628 m_insertCallback = wxInsertChildInWindow;
2629
2630 // always needed for background clearing
2631 m_delayedBackgroundColour = TRUE;
2632
2633 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
2634 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
2635
2636 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2637
2638 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2639 scroll_class->scrollbar_spacing = 0;
2640
2641 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2642
2643 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2644 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
2645
2646 m_wxwindow = gtk_pizza_new();
2647
2648#ifndef __WXUNIVERSAL__
2649 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2650
2651 if (HasFlag(wxRAISED_BORDER))
2652 {
2653 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
2654 }
2655 else if (HasFlag(wxSUNKEN_BORDER))
2656 {
2657 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
2658 }
2659 else if (HasFlag(wxSIMPLE_BORDER))
2660 {
2661 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
2662 }
2663 else
2664 {
2665 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
2666 }
2667#endif // __WXUNIVERSAL__
2668
2669 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2670
2671 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2672 m_acceptsFocus = TRUE;
2673
2674 // I _really_ don't want scrollbars in the beginning
2675 m_vAdjust->lower = 0.0;
2676 m_vAdjust->upper = 1.0;
2677 m_vAdjust->value = 0.0;
2678 m_vAdjust->step_increment = 1.0;
2679 m_vAdjust->page_increment = 1.0;
2680 m_vAdjust->page_size = 5.0;
2681 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2682 m_hAdjust->lower = 0.0;
2683 m_hAdjust->upper = 1.0;
2684 m_hAdjust->value = 0.0;
2685 m_hAdjust->step_increment = 1.0;
2686 m_hAdjust->page_increment = 1.0;
2687 m_hAdjust->page_size = 5.0;
2688 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2689
2690 // these handlers block mouse events to any window during scrolling such as
2691 // motion events and prevent GTK and wxWindows from fighting over where the
2692 // slider should be
2693
2694 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
2695 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2696
2697 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
2698 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2699
2700 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
2701 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2702
2703 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
2704 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2705
2706 // these handlers get notified when screen updates are required either when
2707 // scrolling or when the window size (and therefore scrollbar configuration)
2708 // has changed
2709
2710 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2711 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2712 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2713 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2714
2715#ifdef __WXGTK20__
2716 // Create input method handler
2717 m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new ();
2718
2719 // Cannot handle drawing preedited text yet
2720 gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE );
2721
2722 g_signal_connect (G_OBJECT (m_imContext), "commit",
2723 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2724#endif
2725
2726 gtk_widget_show( m_wxwindow );
2727
2728 if (m_parent)
2729 m_parent->DoAddChild( this );
2730
2731 m_focusWidget = m_wxwindow;
2732
2733 PostCreation();
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 // unless the window was created initially hidden (i.e. Hide() had been
2921 // called before Create()), we should show it at GTK+ level as well
2922 if ( IsShown() )
2923 gtk_widget_show( m_widget );
2924}
2925
2926void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2927{
2928 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2929 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
2930
2931 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2932 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2933
2934 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2935 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2936
2937 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2938 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2939
2940 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2941 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2942
2943#ifdef __WXGTK20__
2944 gtk_signal_connect( GTK_OBJECT(widget), "scroll_event",
2945 GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this );
2946#endif
2947
2948 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2949 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2950
2951 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2952 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2953}
2954
2955bool wxWindowGTK::Destroy()
2956{
2957 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2958
2959 m_hasVMT = FALSE;
2960
2961 return wxWindowBase::Destroy();
2962}
2963
2964void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2965{
2966 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2967}
2968
2969void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2970{
2971 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2972 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2973
2974/*
2975 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2976*/
2977
2978 if (m_resizing) return; /* I don't like recursions */
2979 m_resizing = TRUE;
2980
2981 int currentX, currentY;
2982 GetPosition(&currentX, &currentY);
2983 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2984 x = currentX;
2985 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2986 y = currentY;
2987 AdjustForParentClientOrigin(x, y, sizeFlags);
2988
2989 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
2990 {
2991 /* don't set the size for children of wxNotebook, just take the values. */
2992 m_x = x;
2993 m_y = y;
2994 m_width = width;
2995 m_height = height;
2996 }
2997 else
2998 {
2999 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
3000 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
3001 {
3002 if (x != -1) m_x = x + pizza->xoffset;
3003 if (y != -1) m_y = y + pizza->yoffset;
3004 }
3005 else
3006 {
3007 m_x = x + pizza->xoffset;
3008 m_y = y + pizza->yoffset;
3009 }
3010
3011 // calculate the best size if we should auto size the window
3012 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
3013 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
3014 {
3015 const wxSize sizeBest = GetBestSize();
3016 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
3017 width = sizeBest.x;
3018 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
3019 height = sizeBest.y;
3020 }
3021
3022 if (width != -1)
3023 m_width = width;
3024 if (height != -1)
3025 m_height = height;
3026
3027 int minWidth = GetMinWidth(),
3028 minHeight = GetMinHeight(),
3029 maxWidth = GetMaxWidth(),
3030 maxHeight = GetMaxHeight();
3031
3032 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
3033 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
3034 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
3035 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
3036
3037 int border = 0;
3038 int bottom_border = 0;
3039
3040#ifndef __WXGTK20__
3041 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
3042 {
3043 /* the default button has a border around it */
3044 border = 6;
3045 bottom_border = 5;
3046 }
3047#endif
3048
3049 DoMoveWindow( m_x-border,
3050 m_y-border,
3051 m_width+2*border,
3052 m_height+border+bottom_border );
3053 }
3054
3055 if (m_hasScrolling)
3056 {
3057 /* Sometimes the client area changes size without the
3058 whole windows's size changing, but if the whole
3059 windows's size doesn't change, no wxSizeEvent will
3060 normally be sent. Here we add an extra test if
3061 the client test has been changed and this will
3062 be used then. */
3063 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
3064 }
3065
3066/*
3067 wxPrintf( "OnSize sent from " );
3068 if (GetClassInfo() && GetClassInfo()->GetClassName())
3069 wxPrintf( GetClassInfo()->GetClassName() );
3070 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3071*/
3072
3073 if (!m_nativeSizeEvent)
3074 {
3075 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
3076 event.SetEventObject( this );
3077 GetEventHandler()->ProcessEvent( event );
3078 }
3079
3080 m_resizing = FALSE;
3081}
3082
3083void wxWindowGTK::OnInternalIdle()
3084{
3085 // Update invalidated regions.
3086 GtkUpdate();
3087
3088 // Synthetize activate events.
3089 if ( g_sendActivateEvent != -1 )
3090 {
3091 bool activate = g_sendActivateEvent != 0;
3092
3093 // do it only once
3094 g_sendActivateEvent = -1;
3095
3096 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
3097 }
3098
3099 if ( g_activeFrameLostFocus )
3100 {
3101 if ( g_activeFrame )
3102 {
3103 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
3104 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
3105 event.SetEventObject(g_activeFrame);
3106 g_activeFrame->GetEventHandler()->ProcessEvent(event);
3107 g_activeFrame = NULL;
3108 }
3109 g_activeFrameLostFocus = FALSE;
3110 }
3111
3112 wxCursor cursor = m_cursor;
3113 if (g_globalCursor.Ok()) cursor = g_globalCursor;
3114
3115 if (cursor.Ok())
3116 {
3117 /* I now set the cursor anew in every OnInternalIdle call
3118 as setting the cursor in a parent window also effects the
3119 windows above so that checking for the current cursor is
3120 not possible. */
3121
3122 if (m_wxwindow)
3123 {
3124 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
3125 if (window)
3126 gdk_window_set_cursor( window, cursor.GetCursor() );
3127
3128 if (!g_globalCursor.Ok())
3129 cursor = *wxSTANDARD_CURSOR;
3130
3131 window = m_widget->window;
3132 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
3133 gdk_window_set_cursor( window, cursor.GetCursor() );
3134
3135 }
3136 else
3137 {
3138
3139 GdkWindow *window = m_widget->window;
3140 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
3141 gdk_window_set_cursor( window, cursor.GetCursor() );
3142
3143 }
3144 }
3145
3146 if (wxUpdateUIEvent::CanUpdate(this))
3147 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
3148}
3149
3150void wxWindowGTK::DoGetSize( int *width, int *height ) const
3151{
3152 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3153
3154 if (width) (*width) = m_width;
3155 if (height) (*height) = m_height;
3156}
3157
3158void wxWindowGTK::DoSetClientSize( int width, int height )
3159{
3160 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3161
3162 if (!m_wxwindow)
3163 {
3164 SetSize( width, height );
3165 }
3166 else
3167 {
3168 int dw = 0;
3169 int dh = 0;
3170
3171#ifndef __WXUNIVERSAL__
3172 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3173 {
3174 /* when using GTK 1.2 we set the shadow border size to 2 */
3175 dw += 2 * 2;
3176 dh += 2 * 2;
3177 }
3178 if (HasFlag(wxSIMPLE_BORDER))
3179 {
3180 /* when using GTK 1.2 we set the simple border size to 1 */
3181 dw += 1 * 2;
3182 dh += 1 * 2;
3183 }
3184#endif // __WXUNIVERSAL__
3185
3186 if (m_hasScrolling)
3187 {
3188 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3189
3190 GtkRequisition vscroll_req;
3191 vscroll_req.width = 2;
3192 vscroll_req.height = 2;
3193 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3194 (scroll_window->vscrollbar, &vscroll_req );
3195
3196 GtkRequisition hscroll_req;
3197 hscroll_req.width = 2;
3198 hscroll_req.height = 2;
3199 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3200 (scroll_window->hscrollbar, &hscroll_req );
3201
3202 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3203
3204 if (scroll_window->vscrollbar_visible)
3205 {
3206 dw += vscroll_req.width;
3207 dw += scroll_class->scrollbar_spacing;
3208 }
3209
3210 if (scroll_window->hscrollbar_visible)
3211 {
3212 dh += hscroll_req.height;
3213 dh += scroll_class->scrollbar_spacing;
3214 }
3215 }
3216
3217 SetSize( width+dw, height+dh );
3218 }
3219}
3220
3221void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
3222{
3223 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3224
3225 if (!m_wxwindow)
3226 {
3227 if (width) (*width) = m_width;
3228 if (height) (*height) = m_height;
3229 }
3230 else
3231 {
3232 int dw = 0;
3233 int dh = 0;
3234
3235#ifndef __WXUNIVERSAL__
3236 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3237 {
3238 /* when using GTK 1.2 we set the shadow border size to 2 */
3239 dw += 2 * 2;
3240 dh += 2 * 2;
3241 }
3242 if (HasFlag(wxSIMPLE_BORDER))
3243 {
3244 /* when using GTK 1.2 we set the simple border size to 1 */
3245 dw += 1 * 2;
3246 dh += 1 * 2;
3247 }
3248#endif // __WXUNIVERSAL__
3249
3250 if (m_hasScrolling)
3251 {
3252 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3253
3254 GtkRequisition vscroll_req;
3255 vscroll_req.width = 2;
3256 vscroll_req.height = 2;
3257 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3258 (scroll_window->vscrollbar, &vscroll_req );
3259
3260 GtkRequisition hscroll_req;
3261 hscroll_req.width = 2;
3262 hscroll_req.height = 2;
3263 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3264 (scroll_window->hscrollbar, &hscroll_req );
3265
3266 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3267
3268 if (scroll_window->vscrollbar_visible)
3269 {
3270 dw += vscroll_req.width;
3271 dw += scroll_class->scrollbar_spacing;
3272 }
3273
3274 if (scroll_window->hscrollbar_visible)
3275 {
3276 dh += hscroll_req.height;
3277 dh += scroll_class->scrollbar_spacing;
3278 }
3279 }
3280
3281 if (width) (*width) = m_width - dw;
3282 if (height) (*height) = m_height - dh;
3283 }
3284
3285/*
3286 printf( "GetClientSize, name %s ", GetName().c_str() );
3287 if (width) printf( " width = %d", (*width) );
3288 if (height) printf( " height = %d", (*height) );
3289 printf( "\n" );
3290*/
3291}
3292
3293void wxWindowGTK::DoGetPosition( int *x, int *y ) const
3294{
3295 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3296
3297 int dx = 0;
3298 int dy = 0;
3299 if (m_parent && m_parent->m_wxwindow)
3300 {
3301 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
3302 dx = pizza->xoffset;
3303 dy = pizza->yoffset;
3304 }
3305
3306 if (x) (*x) = m_x - dx;
3307 if (y) (*y) = m_y - dy;
3308}
3309
3310void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
3311{
3312 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3313
3314 if (!m_widget->window) return;
3315
3316 GdkWindow *source = (GdkWindow *) NULL;
3317 if (m_wxwindow)
3318 source = GTK_PIZZA(m_wxwindow)->bin_window;
3319 else
3320 source = m_widget->window;
3321
3322 int org_x = 0;
3323 int org_y = 0;
3324 gdk_window_get_origin( source, &org_x, &org_y );
3325
3326 if (!m_wxwindow)
3327 {
3328 if (GTK_WIDGET_NO_WINDOW (m_widget))
3329 {
3330 org_x += m_widget->allocation.x;
3331 org_y += m_widget->allocation.y;
3332 }
3333 }
3334
3335 if (x) *x += org_x;
3336 if (y) *y += org_y;
3337}
3338
3339void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
3340{
3341 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3342
3343 if (!m_widget->window) return;
3344
3345 GdkWindow *source = (GdkWindow *) NULL;
3346 if (m_wxwindow)
3347 source = GTK_PIZZA(m_wxwindow)->bin_window;
3348 else
3349 source = m_widget->window;
3350
3351 int org_x = 0;
3352 int org_y = 0;
3353 gdk_window_get_origin( source, &org_x, &org_y );
3354
3355 if (!m_wxwindow)
3356 {
3357 if (GTK_WIDGET_NO_WINDOW (m_widget))
3358 {
3359 org_x += m_widget->allocation.x;
3360 org_y += m_widget->allocation.y;
3361 }
3362 }
3363
3364 if (x) *x -= org_x;
3365 if (y) *y -= org_y;
3366}
3367
3368bool wxWindowGTK::Show( bool show )
3369{
3370 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3371
3372 if (!wxWindowBase::Show(show))
3373 {
3374 // nothing to do
3375 return FALSE;
3376 }
3377
3378 if (show)
3379 gtk_widget_show( m_widget );
3380 else
3381 gtk_widget_hide( m_widget );
3382
3383 wxShowEvent eventShow(GetId(), show);
3384 eventShow.m_eventObject = this;
3385
3386 GetEventHandler()->ProcessEvent(eventShow);
3387
3388 return TRUE;
3389}
3390
3391static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
3392{
3393 win->OnParentEnable(enable);
3394
3395 // Recurse, so that children have the opportunity to Do The Right Thing
3396 // and reset colours that have been messed up by a parent's (really ancestor's)
3397 // Enable call
3398 for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
3399 node;
3400 node = node->GetNext() )
3401 {
3402 wxWindow *child = node->GetData();
3403 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3404 wxWindowNotifyEnable(child, enable);
3405 }
3406}
3407
3408bool wxWindowGTK::Enable( bool enable )
3409{
3410 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3411
3412 if (!wxWindowBase::Enable(enable))
3413 {
3414 // nothing to do
3415 return FALSE;
3416 }
3417
3418 gtk_widget_set_sensitive( m_widget, enable );
3419 if ( m_wxwindow )
3420 gtk_widget_set_sensitive( m_wxwindow, enable );
3421
3422 wxWindowNotifyEnable(this, enable);
3423
3424 return TRUE;
3425}
3426
3427int wxWindowGTK::GetCharHeight() const
3428{
3429 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3430
3431 wxFont font = GetFont();
3432 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
3433
3434#ifdef __WXGTK20__
3435 PangoContext *context = NULL;
3436 if (m_widget)
3437 context = gtk_widget_get_pango_context( m_widget );
3438
3439 if (!context)
3440 return 0;
3441
3442 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3443 PangoLayout *layout = pango_layout_new(context);
3444 pango_layout_set_font_description(layout, desc);
3445 pango_layout_set_text(layout, "H", 1);
3446 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3447
3448 PangoRectangle rect;
3449 pango_layout_line_get_extents(line, NULL, &rect);
3450
3451 g_object_unref( G_OBJECT( layout ) );
3452
3453 return (int) (rect.height / PANGO_SCALE);
3454#else
3455 GdkFont *gfont = font.GetInternalFont( 1.0 );
3456
3457 return gfont->ascent + gfont->descent;
3458#endif
3459}
3460
3461int wxWindowGTK::GetCharWidth() const
3462{
3463 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3464
3465 wxFont font = GetFont();
3466 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
3467
3468#ifdef __WXGTK20__
3469 PangoContext *context = NULL;
3470 if (m_widget)
3471 context = gtk_widget_get_pango_context( m_widget );
3472
3473 if (!context)
3474 return 0;
3475
3476 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3477 PangoLayout *layout = pango_layout_new(context);
3478 pango_layout_set_font_description(layout, desc);
3479 pango_layout_set_text(layout, "g", 1);
3480 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3481
3482 PangoRectangle rect;
3483 pango_layout_line_get_extents(line, NULL, &rect);
3484
3485 g_object_unref( G_OBJECT( layout ) );
3486
3487 return (int) (rect.width / PANGO_SCALE);
3488#else
3489 GdkFont *gfont = font.GetInternalFont( 1.0 );
3490
3491 return gdk_string_width( gfont, "g" );
3492#endif
3493}
3494
3495void wxWindowGTK::GetTextExtent( const wxString& string,
3496 int *x,
3497 int *y,
3498 int *descent,
3499 int *externalLeading,
3500 const wxFont *theFont ) const
3501{
3502 wxFont fontToUse = theFont ? *theFont : GetFont();
3503
3504 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3505
3506 if (string.IsEmpty())
3507 {
3508 if (x) (*x) = 0;
3509 if (y) (*y) = 0;
3510 return;
3511 }
3512
3513#ifdef __WXGTK20__
3514 PangoContext *context = NULL;
3515 if (m_widget)
3516 context = gtk_widget_get_pango_context( m_widget );
3517
3518 if (!context)
3519 {
3520 if (x) (*x) = 0;
3521 if (y) (*y) = 0;
3522 return;
3523 }
3524
3525 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3526 PangoLayout *layout = pango_layout_new(context);
3527 pango_layout_set_font_description(layout, desc);
3528 {
3529#if wxUSE_UNICODE
3530 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
3531 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3532#else
3533 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
3534 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
3535 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3536#endif
3537 }
3538 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3539
3540 PangoRectangle rect;
3541 pango_layout_line_get_extents(line, NULL, &rect);
3542
3543 if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
3544 if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
3545 if (descent)
3546 {
3547 // Do something about metrics here
3548 (*descent) = 0;
3549 }
3550 if (externalLeading) (*externalLeading) = 0; // ??
3551
3552 g_object_unref( G_OBJECT( layout ) );
3553#else
3554 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
3555 if (x) (*x) = gdk_string_width( font, wxGTK_CONV( string ) );
3556 if (y) (*y) = font->ascent + font->descent;
3557 if (descent) (*descent) = font->descent;
3558 if (externalLeading) (*externalLeading) = 0; // ??
3559#endif
3560}
3561
3562void wxWindowGTK::SetFocus()
3563{
3564 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3565
3566 if ( m_hasFocus )
3567 {
3568 // don't do anything if we already have focus
3569 return;
3570 }
3571
3572 if (m_wxwindow)
3573 {
3574 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3575 {
3576 gtk_widget_grab_focus (m_wxwindow);
3577 }
3578 }
3579 else if (m_widget)
3580 {
3581 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3582 {
3583 if (!GTK_WIDGET_REALIZED(m_widget))
3584 {
3585 // we can't set the focus to the widget now so we remember that
3586 // it should be focused and will do it later, during the idle
3587 // time, as soon as we can
3588 wxLogTrace(TRACE_FOCUS,
3589 _T("Delaying setting focus to %s(%s)"),
3590 GetClassInfo()->GetClassName(), GetLabel().c_str());
3591
3592 g_delayedFocus = this;
3593 }
3594 else
3595 {
3596 wxLogTrace(TRACE_FOCUS,
3597 _T("Setting focus to %s(%s)"),
3598 GetClassInfo()->GetClassName(), GetLabel().c_str());
3599
3600 gtk_widget_grab_focus (m_widget);
3601 }
3602 }
3603 else if (GTK_IS_CONTAINER(m_widget))
3604 {
3605 SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );
3606 }
3607 else
3608 {
3609 wxLogTrace(TRACE_FOCUS,
3610 _T("Can't set focus to %s(%s)"),
3611 GetClassInfo()->GetClassName(), GetLabel().c_str());
3612 }
3613 }
3614}
3615
3616bool wxWindowGTK::AcceptsFocus() const
3617{
3618 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
3619}
3620
3621bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3622{
3623 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3624
3625 wxWindowGTK *oldParent = m_parent,
3626 *newParent = (wxWindowGTK *)newParentBase;
3627
3628 wxASSERT( GTK_IS_WIDGET(m_widget) );
3629
3630 if ( !wxWindowBase::Reparent(newParent) )
3631 return FALSE;
3632
3633 wxASSERT( GTK_IS_WIDGET(m_widget) );
3634
3635 /* prevent GTK from deleting the widget arbitrarily */
3636 gtk_widget_ref( m_widget );
3637
3638 if (oldParent)
3639 {
3640 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3641 }
3642
3643 wxASSERT( GTK_IS_WIDGET(m_widget) );
3644
3645 if (newParent)
3646 {
3647 /* insert GTK representation */
3648 (*(newParent->m_insertCallback))(newParent, this);
3649 }
3650
3651 /* reverse: prevent GTK from deleting the widget arbitrarily */
3652 gtk_widget_unref( m_widget );
3653
3654 return TRUE;
3655}
3656
3657void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3658{
3659 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3660
3661 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3662
3663 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3664
3665 /* add to list */
3666 AddChild( child );
3667
3668 /* insert GTK representation */
3669 (*m_insertCallback)(this, child);
3670}
3671
3672void wxWindowGTK::Raise()
3673{
3674 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3675
3676 if (!m_widget->window) return;
3677
3678 gdk_window_raise( m_widget->window );
3679}
3680
3681void wxWindowGTK::Lower()
3682{
3683 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3684
3685 if (!m_widget->window) return;
3686
3687 gdk_window_lower( m_widget->window );
3688}
3689
3690bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3691{
3692 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3693
3694 if (cursor == m_cursor)
3695 return FALSE;
3696
3697 if (g_isIdle)
3698 wxapp_install_idle_handler();
3699
3700 if (cursor == wxNullCursor)
3701 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3702 else
3703 return wxWindowBase::SetCursor( cursor );
3704}
3705
3706void wxWindowGTK::WarpPointer( int x, int y )
3707{
3708 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3709
3710 // We provide this function ourselves as it is
3711 // missing in GDK (top of this file).
3712
3713 GdkWindow *window = (GdkWindow*) NULL;
3714 if (m_wxwindow)
3715 window = GTK_PIZZA(m_wxwindow)->bin_window;
3716 else
3717 window = GetConnectWidget()->window;
3718
3719 if (window)
3720 gdk_window_warp_pointer( window, x, y );
3721}
3722
3723
3724void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3725{
3726 if (!m_widget) return;
3727 if (!m_widget->window) return;
3728
3729#ifndef __WXGTK20__
3730 if (g_isIdle)
3731 wxapp_install_idle_handler();
3732
3733 wxRect myRect(0,0,0,0);
3734 if (m_wxwindow && rect)
3735 {
3736 myRect.SetSize(wxSize( m_wxwindow->allocation.width,
3737 m_wxwindow->allocation.height));
3738 myRect.Intersect(*rect);
3739 if (!myRect.width || !myRect.height)
3740 // nothing to do, rectangle is empty
3741 return;
3742 rect = &myRect;
3743 }
3744
3745 if (eraseBackground && m_wxwindow && m_wxwindow->window)
3746 {
3747 if (rect)
3748 {
3749 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3750 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
3751 }
3752 else
3753 {
3754 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3755 m_clearRegion.Clear();
3756 m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3757 }
3758 }
3759
3760 if (rect)
3761 {
3762 if (m_wxwindow)
3763 {
3764 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3765 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
3766 }
3767 else
3768 {
3769 GdkRectangle gdk_rect;
3770 gdk_rect.x = rect->x;
3771 gdk_rect.y = rect->y;
3772 gdk_rect.width = rect->width;
3773 gdk_rect.height = rect->height;
3774 gtk_widget_draw( m_widget, &gdk_rect );
3775 }
3776 }
3777 else
3778 {
3779 if (m_wxwindow)
3780 {
3781 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3782 m_updateRegion.Clear();
3783 m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3784 }
3785 else
3786 {
3787 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
3788 }
3789 }
3790#else
3791 if (m_wxwindow)
3792 {
3793 if (rect)
3794 {
3795 GdkRectangle gdk_rect;
3796 gdk_rect.x = rect->x;
3797 gdk_rect.y = rect->y;
3798 gdk_rect.width = rect->width;
3799 gdk_rect.height = rect->height;
3800 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
3801 }
3802 else
3803 {
3804 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
3805 }
3806 }
3807#endif
3808}
3809
3810void wxWindowGTK::Update()
3811{
3812 GtkUpdate();
3813}
3814
3815void wxWindowGTK::GtkUpdate()
3816{
3817#ifdef __WXGTK20__
3818 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3819 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
3820#else
3821 if (!m_updateRegion.IsEmpty())
3822 GtkSendPaintEvents();
3823#endif
3824}
3825
3826void wxWindowGTK::GtkSendPaintEvents()
3827{
3828 if (!m_wxwindow)
3829 {
3830#ifndef __WXGTK20__
3831 m_clearRegion.Clear();
3832#endif
3833 m_updateRegion.Clear();
3834 return;
3835 }
3836
3837 // Clip to paint region in wxClientDC
3838 m_clipPaintRegion = TRUE;
3839
3840#ifndef __WXGTK20__
3841 // widget to draw on
3842 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
3843
3844 // later for GTK 2.0, too.
3845 if (GetThemeEnabled())
3846 {
3847 // find ancestor from which to steal background
3848 wxWindow *parent = GetParent();
3849 while (parent && !parent->IsTopLevel())
3850 parent = parent->GetParent();
3851 if (!parent)
3852 parent = (wxWindow*)this;
3853
3854 wxRegionIterator upd( m_updateRegion );
3855 while (upd)
3856 {
3857 GdkRectangle rect;
3858 rect.x = upd.GetX();
3859 rect.y = upd.GetY();
3860 rect.width = upd.GetWidth();
3861 rect.height = upd.GetHeight();
3862
3863 gtk_paint_flat_box( parent->m_widget->style,
3864 pizza->bin_window,
3865 GTK_STATE_NORMAL,
3866 GTK_SHADOW_NONE,
3867 &rect,
3868 parent->m_widget,
3869 (char *)"base",
3870 0, 0, -1, -1 );
3871
3872 upd ++;
3873 }
3874 }
3875 else
3876#endif
3877
3878#ifdef __WXGTK20__
3879 {
3880 wxWindowDC dc( (wxWindow*)this );
3881 dc.SetClippingRegion( m_updateRegion );
3882
3883 wxEraseEvent erase_event( GetId(), &dc );
3884 erase_event.SetEventObject( this );
3885
3886 GetEventHandler()->ProcessEvent(erase_event);
3887 }
3888#else
3889 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
3890 {
3891 wxWindowDC dc( (wxWindow*)this );
3892 if (m_clearRegion.IsEmpty())
3893 dc.SetClippingRegion( m_updateRegion );
3894 else
3895 dc.SetClippingRegion( m_clearRegion );
3896
3897 wxEraseEvent erase_event( GetId(), &dc );
3898 erase_event.SetEventObject( this );
3899
3900 if (!GetEventHandler()->ProcessEvent(erase_event))
3901 {
3902 if (!g_eraseGC)
3903 {
3904 g_eraseGC = gdk_gc_new( pizza->bin_window );
3905 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
3906 }
3907 gdk_gc_set_foreground( g_eraseGC, m_backgroundColour.GetColor() );
3908
3909 wxRegionIterator upd( m_clearRegion );
3910 while (upd)
3911 {
3912 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
3913 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
3914 upd ++;
3915 }
3916 }
3917 m_clearRegion.Clear();
3918 }
3919#endif
3920
3921 wxNcPaintEvent nc_paint_event( GetId() );
3922 nc_paint_event.SetEventObject( this );
3923 GetEventHandler()->ProcessEvent( nc_paint_event );
3924
3925 wxPaintEvent paint_event( GetId() );
3926 paint_event.SetEventObject( this );
3927 GetEventHandler()->ProcessEvent( paint_event );
3928
3929 m_clipPaintRegion = FALSE;
3930
3931#ifndef __WXUNIVERSAL__
3932#ifndef __WXGTK20__
3933 // The following code will result in all window-less widgets
3934 // being redrawn because the wxWindows class is allowed to
3935 // paint over the window-less widgets.
3936
3937 GList *children = pizza->children;
3938 while (children)
3939 {
3940 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
3941 children = children->next;
3942
3943 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
3944 GTK_WIDGET_DRAWABLE (child->widget))
3945 {
3946 // Get intersection of widget area and update region
3947 wxRegion region( m_updateRegion );
3948
3949 GdkEventExpose gdk_event;
3950 gdk_event.type = GDK_EXPOSE;
3951 gdk_event.window = pizza->bin_window;
3952 gdk_event.count = 0;
3953
3954 wxRegionIterator upd( m_updateRegion );
3955 while (upd)
3956 {
3957 GdkRectangle rect;
3958 rect.x = upd.GetX();
3959 rect.y = upd.GetY();
3960 rect.width = upd.GetWidth();
3961 rect.height = upd.GetHeight();
3962
3963 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
3964 {
3965 gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
3966 }
3967
3968 upd ++;
3969 }
3970 }
3971 }
3972#endif
3973#endif
3974
3975 m_updateRegion.Clear();
3976}
3977
3978void wxWindowGTK::ClearBackground()
3979{
3980 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3981
3982#ifndef __WXGTK20__
3983 if (m_wxwindow && m_wxwindow->window)
3984 {
3985 m_clearRegion.Clear();
3986 wxSize size( GetClientSize() );
3987 m_clearRegion.Union( 0,0,size.x,size.y );
3988
3989 // Better do this in idle?
3990 GtkUpdate();
3991 }
3992#endif
3993}
3994
3995#if wxUSE_TOOLTIPS
3996void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3997{
3998 wxWindowBase::DoSetToolTip(tip);
3999
4000 if (m_tooltip)
4001 m_tooltip->Apply( (wxWindow *)this );
4002}
4003
4004void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
4005{
4006 wxString tmp( tip );
4007 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );
4008}
4009#endif // wxUSE_TOOLTIPS
4010
4011void wxWindowGTK::GtkSetBackgroundColour( const wxColour &colour )
4012{
4013 GdkWindow *window = (GdkWindow*) NULL;
4014 if (m_wxwindow)
4015 window = GTK_PIZZA(m_wxwindow)->bin_window;
4016 else
4017 window = GetConnectWidget()->window;
4018
4019 wxASSERT( window );
4020
4021 // We need the pixel value e.g. for background clearing.
4022 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
4023
4024 if (m_wxwindow)
4025 {
4026 // wxMSW doesn't clear the window here, either.
4027 gdk_window_set_background( window, m_backgroundColour.GetColor() );
4028 }
4029
4030 ApplyWidgetStyle();
4031}
4032
4033bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
4034{
4035 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4036
4037 if (!wxWindowBase::SetBackgroundColour(colour))
4038 return FALSE;
4039
4040 GdkWindow *window = (GdkWindow*) NULL;
4041 if (m_wxwindow)
4042 window = GTK_PIZZA(m_wxwindow)->bin_window;
4043 else
4044 window = GetConnectWidget()->window;
4045
4046 if (!window)
4047 {
4048 // indicate that a new style has been set
4049 // but it couldn't get applied as the
4050 // widget hasn't been realized yet.
4051 m_delayedBackgroundColour = TRUE;
4052 return TRUE;
4053 }
4054 else
4055 {
4056 GtkSetBackgroundColour( colour );
4057 }
4058
4059 return TRUE;
4060}
4061
4062void wxWindowGTK::GtkSetForegroundColour( const wxColour &colour )
4063{
4064 GdkWindow *window = (GdkWindow*) NULL;
4065 if (m_wxwindow)
4066 window = GTK_PIZZA(m_wxwindow)->bin_window;
4067 else
4068 window = GetConnectWidget()->window;
4069
4070 wxASSERT( window );
4071
4072 ApplyWidgetStyle();
4073}
4074
4075bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
4076{
4077 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4078
4079 if (!wxWindowBase::SetForegroundColour(colour))
4080 {
4081 // don't leave if the GTK widget has just
4082 // been realized
4083 if (!m_delayedForegroundColour) return FALSE;
4084 }
4085
4086 GdkWindow *window = (GdkWindow*) NULL;
4087 if (m_wxwindow)
4088 window = GTK_PIZZA(m_wxwindow)->bin_window;
4089 else
4090 window = GetConnectWidget()->window;
4091
4092 if (!window)
4093 {
4094 // indicate that a new style has been set
4095 // but it couldn't get applied as the
4096 // widget hasn't been realized yet.
4097 m_delayedForegroundColour = TRUE;
4098 }
4099 else
4100 {
4101 GtkSetForegroundColour( colour );
4102 }
4103
4104 return TRUE;
4105}
4106
4107#ifdef __WXGTK20__
4108PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
4109{
4110 return gtk_widget_get_pango_context( m_widget );
4111}
4112
4113PangoContext *wxWindowGTK::GtkGetPangoX11Context()
4114{
4115 if (!m_x11Context)
4116 m_x11Context = pango_x_get_context( gdk_display );
4117
4118 return m_x11Context;
4119}
4120#endif
4121
4122GtkStyle *wxWindowGTK::GetWidgetStyle()
4123{
4124 if (m_widgetStyle)
4125 {
4126 GtkStyle *remake = gtk_style_copy( m_widgetStyle );
4127
4128 // FIXME: no more klass in 2.0
4129#ifndef __WXGTK20__
4130 remake->klass = m_widgetStyle->klass;
4131#endif
4132
4133 gtk_style_unref( m_widgetStyle );
4134 m_widgetStyle = remake;
4135 }
4136 else
4137 {
4138 GtkStyle *def = gtk_rc_get_style( m_widget );
4139
4140 if (!def)
4141 def = gtk_widget_get_default_style();
4142
4143 m_widgetStyle = gtk_style_copy( def );
4144
4145 // FIXME: no more klass in 2.0
4146#ifndef __WXGTK20__
4147 m_widgetStyle->klass = def->klass;
4148#endif
4149 }
4150
4151 return m_widgetStyle;
4152}
4153
4154void wxWindowGTK::SetWidgetStyle()
4155{
4156#if DISABLE_STYLE_IF_BROKEN_THEME
4157 if (m_widget->style->engine_data)
4158 {
4159 static bool s_warningPrinted = FALSE;
4160 if (!s_warningPrinted)
4161 {
4162 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
4163 s_warningPrinted = TRUE;
4164 }
4165 m_widgetStyle = m_widget->style;
4166 return;
4167 }
4168#endif
4169
4170 GtkStyle *style = GetWidgetStyle();
4171
4172 if ( m_hasFont )
4173 {
4174#ifdef __WXGTK20__
4175 pango_font_description_free( style->font_desc );
4176 style->font_desc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
4177#else
4178 gdk_font_unref( style->font );
4179 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
4180#endif
4181 }
4182
4183 if ( m_hasFgCol )
4184 {
4185 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
4186 if (m_foregroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT))
4187 {
4188 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
4189 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
4190 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
4191 }
4192 else
4193 {
4194 // Try to restore the gtk default style. This is still a little
4195 // oversimplified for what is probably really needed here for controls
4196 // other than buttons, but is better than not being able to (re)set a
4197 // control's foreground colour to *wxBLACK -- RL
4198 GtkStyle *def = gtk_rc_get_style( m_widget );
4199
4200 if (!def)
4201 def = gtk_widget_get_default_style();
4202
4203 style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
4204 style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
4205 style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
4206 }
4207 }
4208
4209 if ( m_hasBgCol && m_backgroundColour.Ok() )
4210 {
4211 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
4212 if (m_backgroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE))
4213 {
4214 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4215 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4216 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4217 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4218 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4219 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4220 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
4221 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
4222 }
4223 else
4224 {
4225 // Try to restore the gtk default style. This is still a little
4226 // oversimplified for what is probably really needed here for controls
4227 // other than buttons, but is better than not being able to (re)set a
4228 // control's background colour to default grey and means resetting a
4229 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
4230 // behavior -- RL
4231 GtkStyle *def = gtk_rc_get_style( m_widget );
4232
4233 if (!def)
4234 def = gtk_widget_get_default_style();
4235
4236 style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
4237 style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
4238 style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
4239 style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
4240 style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
4241 style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
4242 style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
4243 style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
4244 }
4245 }
4246}
4247
4248void wxWindowGTK::ApplyWidgetStyle()
4249{
4250}
4251
4252//-----------------------------------------------------------------------------
4253// Pop-up menu stuff
4254//-----------------------------------------------------------------------------
4255
4256#if wxUSE_MENUS_NATIVE
4257
4258extern "C"
4259void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
4260{
4261 *is_waiting = FALSE;
4262}
4263
4264static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
4265{
4266 menu->SetInvokingWindow( win );
4267 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
4268 while (node)
4269 {
4270 wxMenuItem *menuitem = node->GetData();
4271 if (menuitem->IsSubMenu())
4272 {
4273 SetInvokingWindow( menuitem->GetSubMenu(), win );
4274 }
4275
4276 node = node->GetNext();
4277 }
4278}
4279
4280// used to pass the coordinates from wxWindowGTK::DoPopupMenu() to
4281// wxPopupMenuPositionCallback()
4282//
4283// should be safe even in the MT case as the user can hardly popup 2 menus
4284// simultaneously, can he?
4285static gint gs_pop_x = 0;
4286static gint gs_pop_y = 0;
4287
4288extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
4289 gint *x, gint *y,
4290#ifdef __WXGTK20__
4291 gboolean * WXUNUSED(whatever),
4292#endif
4293 gpointer WXUNUSED(user_data) )
4294{
4295 // ensure that the menu appears entirely on screen
4296 GtkRequisition req;
4297 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4298
4299 wxSize sizeScreen = wxGetDisplaySize();
4300
4301 gint xmax = sizeScreen.x - req.width,
4302 ymax = sizeScreen.y - req.height;
4303
4304 *x = gs_pop_x < xmax ? gs_pop_x : xmax;
4305 *y = gs_pop_y < ymax ? gs_pop_y : ymax;
4306}
4307
4308bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4309{
4310 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4311
4312 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
4313
4314 SetInvokingWindow( menu, this );
4315
4316 menu->UpdateUI();
4317
4318 gs_pop_x = x;
4319 gs_pop_y = y;
4320 ClientToScreen( &gs_pop_x, &gs_pop_y );
4321
4322 bool is_waiting = TRUE;
4323
4324 gtk_signal_connect( GTK_OBJECT(menu->m_menu),
4325 "hide",
4326 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
4327 (gpointer)&is_waiting );
4328
4329 gtk_menu_popup(
4330 GTK_MENU(menu->m_menu),
4331 (GtkWidget *) NULL, // parent menu shell
4332 (GtkWidget *) NULL, // parent menu item
4333 wxPopupMenuPositionCallback, // function to position it
4334 NULL, // client data
4335 0, // button used to activate it
4336#ifdef __WXGTK20__
4337 gtk_get_current_event_time()
4338#else
4339 gs_timeLastClick // the time of activation
4340#endif
4341 );
4342
4343 while (is_waiting)
4344 {
4345 gtk_main_iteration();
4346 }
4347
4348 return TRUE;
4349}
4350
4351#endif // wxUSE_MENUS_NATIVE
4352
4353#if wxUSE_DRAG_AND_DROP
4354
4355void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4356{
4357 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4358
4359 GtkWidget *dnd_widget = GetConnectWidget();
4360
4361 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
4362
4363 if (m_dropTarget) delete m_dropTarget;
4364 m_dropTarget = dropTarget;
4365
4366 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
4367}
4368
4369#endif // wxUSE_DRAG_AND_DROP
4370
4371GtkWidget* wxWindowGTK::GetConnectWidget()
4372{
4373 GtkWidget *connect_widget = m_widget;
4374 if (m_wxwindow) connect_widget = m_wxwindow;
4375
4376 return connect_widget;
4377}
4378
4379bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
4380{
4381 if (m_wxwindow)
4382 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
4383
4384 return (window == m_widget->window);
4385}
4386
4387bool wxWindowGTK::SetFont( const wxFont &font )
4388{
4389 if (!wxWindowBase::SetFont(font) || !m_widget)
4390 {
4391 return FALSE;
4392 }
4393
4394 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
4395 if ( sysbg == m_backgroundColour )
4396 {
4397 m_backgroundColour = wxNullColour;
4398 ApplyWidgetStyle();
4399 m_backgroundColour = sysbg;
4400 }
4401 else
4402 {
4403 ApplyWidgetStyle();
4404 }
4405
4406 return TRUE;
4407}
4408
4409void wxWindowGTK::DoCaptureMouse()
4410{
4411 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4412
4413 GdkWindow *window = (GdkWindow*) NULL;
4414 if (m_wxwindow)
4415 window = GTK_PIZZA(m_wxwindow)->bin_window;
4416 else
4417 window = GetConnectWidget()->window;
4418
4419 wxCHECK_RET( window, _T("CaptureMouse() failed") );
4420
4421 wxCursor* cursor = & m_cursor;
4422 if (!cursor->Ok())
4423 cursor = wxSTANDARD_CURSOR;
4424
4425 gdk_pointer_grab( window, FALSE,
4426 (GdkEventMask)
4427 (GDK_BUTTON_PRESS_MASK |
4428 GDK_BUTTON_RELEASE_MASK |
4429 GDK_POINTER_MOTION_HINT_MASK |
4430 GDK_POINTER_MOTION_MASK),
4431 (GdkWindow *) NULL,
4432 cursor->GetCursor(),
4433 (guint32)GDK_CURRENT_TIME );
4434 g_captureWindow = this;
4435 g_captureWindowHasMouse = TRUE;
4436}
4437
4438void wxWindowGTK::DoReleaseMouse()
4439{
4440 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4441
4442 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4443
4444 g_captureWindow = (wxWindowGTK*) NULL;
4445
4446 GdkWindow *window = (GdkWindow*) NULL;
4447 if (m_wxwindow)
4448 window = GTK_PIZZA(m_wxwindow)->bin_window;
4449 else
4450 window = GetConnectWidget()->window;
4451
4452 if (!window)
4453 return;
4454
4455 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4456}
4457
4458/* static */
4459wxWindow *wxWindowBase::GetCapture()
4460{
4461 return (wxWindow *)g_captureWindow;
4462}
4463
4464bool wxWindowGTK::IsRetained() const
4465{
4466 return FALSE;
4467}
4468
4469void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
4470 int range, bool refresh )
4471{
4472 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4473
4474 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4475
4476 m_hasScrolling = TRUE;
4477
4478 if (orient == wxHORIZONTAL)
4479 {
4480 float fpos = (float)pos;
4481 float frange = (float)range;
4482 float fthumb = (float)thumbVisible;
4483 if (fpos > frange-fthumb) fpos = frange-fthumb;
4484 if (fpos < 0.0) fpos = 0.0;
4485
4486 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
4487 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
4488 {
4489 SetScrollPos( orient, pos, refresh );
4490 return;
4491 }
4492
4493 m_oldHorizontalPos = fpos;
4494
4495 m_hAdjust->lower = 0.0;
4496 m_hAdjust->upper = frange;
4497 m_hAdjust->value = fpos;
4498 m_hAdjust->step_increment = 1.0;
4499 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
4500 m_hAdjust->page_size = fthumb;
4501 }
4502 else
4503 {
4504 float fpos = (float)pos;
4505 float frange = (float)range;
4506 float fthumb = (float)thumbVisible;
4507 if (fpos > frange-fthumb) fpos = frange-fthumb;
4508 if (fpos < 0.0) fpos = 0.0;
4509
4510 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4511 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4512 {
4513 SetScrollPos( orient, pos, refresh );
4514 return;
4515 }
4516
4517 m_oldVerticalPos = fpos;
4518
4519 m_vAdjust->lower = 0.0;
4520 m_vAdjust->upper = frange;
4521 m_vAdjust->value = fpos;
4522 m_vAdjust->step_increment = 1.0;
4523 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4524 m_vAdjust->page_size = fthumb;
4525 }
4526
4527 if (orient == wxHORIZONTAL)
4528 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4529 else
4530 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
4531}
4532
4533void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
4534{
4535 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4536
4537 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4538
4539 if (orient == wxHORIZONTAL)
4540 {
4541 float fpos = (float)pos;
4542 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
4543 if (fpos < 0.0) fpos = 0.0;
4544 m_oldHorizontalPos = fpos;
4545
4546 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
4547 m_hAdjust->value = fpos;
4548 }
4549 else
4550 {
4551 float fpos = (float)pos;
4552 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
4553 if (fpos < 0.0) fpos = 0.0;
4554 m_oldVerticalPos = fpos;
4555
4556 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
4557 m_vAdjust->value = fpos;
4558 }
4559
4560 if (m_wxwindow->window)
4561 {
4562 if (orient == wxHORIZONTAL)
4563 {
4564 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
4565 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4566
4567 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
4568
4569 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
4570 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4571 }
4572 else
4573 {
4574 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
4575 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4576
4577 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
4578
4579 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
4580 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4581 }
4582 }
4583}
4584
4585int wxWindowGTK::GetScrollThumb( int orient ) const
4586{
4587 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4588
4589 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4590
4591 if (orient == wxHORIZONTAL)
4592 return (int)(m_hAdjust->page_size+0.5);
4593 else
4594 return (int)(m_vAdjust->page_size+0.5);
4595}
4596
4597int wxWindowGTK::GetScrollPos( int orient ) const
4598{
4599 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4600
4601 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4602
4603 if (orient == wxHORIZONTAL)
4604 return (int)(m_hAdjust->value+0.5);
4605 else
4606 return (int)(m_vAdjust->value+0.5);
4607}
4608
4609int wxWindowGTK::GetScrollRange( int orient ) const
4610{
4611 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4612
4613 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4614
4615 if (orient == wxHORIZONTAL)
4616 return (int)(m_hAdjust->upper+0.5);
4617 else
4618 return (int)(m_vAdjust->upper+0.5);
4619}
4620
4621void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4622{
4623 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4624
4625 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4626
4627 // No scrolling requested.
4628 if ((dx == 0) && (dy == 0)) return;
4629
4630#ifndef __WXGTK20__
4631 if (!m_updateRegion.IsEmpty())
4632 {
4633 m_updateRegion.Offset( dx, dy );
4634
4635 int cw = 0;
4636 int ch = 0;
4637 GetClientSize( &cw, &ch );
4638 m_updateRegion.Intersect( 0, 0, cw, ch );
4639 }
4640
4641 if (!m_clearRegion.IsEmpty())
4642 {
4643 m_clearRegion.Offset( dx, dy );
4644
4645 int cw = 0;
4646 int ch = 0;
4647 GetClientSize( &cw, &ch );
4648 m_clearRegion.Intersect( 0, 0, cw, ch );
4649 }
4650#endif
4651
4652 m_clipPaintRegion = TRUE;
4653
4654 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
4655
4656 m_clipPaintRegion = FALSE;
4657}
4658
4659
4660// Find the wxWindow at the current mouse position, also returning the mouse
4661// position.
4662wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4663{
4664 pt = wxGetMousePosition();
4665 wxWindow* found = wxFindWindowAtPoint(pt);
4666 return found;
4667}
4668
4669// Get the current mouse position.
4670wxPoint wxGetMousePosition()
4671{
4672 /* This crashes when used within wxHelpContext,
4673 so we have to use the X-specific implementation below.
4674 gint x, y;
4675 GdkModifierType *mask;
4676 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4677
4678 return wxPoint(x, y);
4679 */
4680
4681 int x, y;
4682 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4683
4684 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4685 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4686 Window rootReturn, childReturn;
4687 int rootX, rootY, winX, winY;
4688 unsigned int maskReturn;
4689
4690 XQueryPointer (display,
4691 rootWindow,
4692 &rootReturn,
4693 &childReturn,
4694 &rootX, &rootY, &winX, &winY, &maskReturn);
4695 return wxPoint(rootX, rootY);
4696
4697}
4698
4699// ----------------------------------------------------------------------------
4700// wxDCModule
4701// ----------------------------------------------------------------------------
4702
4703class wxWinModule : public wxModule
4704{
4705public:
4706 bool OnInit();
4707 void OnExit();
4708
4709private:
4710 DECLARE_DYNAMIC_CLASS(wxWinModule)
4711};
4712
4713IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4714
4715bool wxWinModule::OnInit()
4716{
4717 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4718 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4719
4720 return TRUE;
4721}
4722
4723void wxWinModule::OnExit()
4724{
4725 if (g_eraseGC)
4726 gdk_gc_unref( g_eraseGC );
4727}
4728
4729// vi:sts=4:sw=4:et
wxWidgets (Impactor)