]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/window.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
removed Win16 code (patch 905241), last version with remains of Win16 support tagged...
[wxWidgets.git] / src / gtk / window.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: gtk/window.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling, Julian Smart
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10
11#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
12 #pragma implementation "window.h"
13#endif
14
15// For compilers that support precompilation, includes "wx.h".
16#include "wx/wxprec.h"
17
18#ifdef __VMS
19#define XWarpPointer XWARPPOINTER
20#endif
21
22#include "wx/window.h"
23#include "wx/dcclient.h"
24#include "wx/frame.h"
25#include "wx/app.h"
26#include "wx/layout.h"
27#include "wx/utils.h"
28#include "wx/dialog.h"
29#include "wx/msgdlg.h"
30#include "wx/module.h"
31
32#if wxUSE_DRAG_AND_DROP
33 #include "wx/dnd.h"
34#endif
35
36#if wxUSE_TOOLTIPS
37 #include "wx/tooltip.h"
38#endif
39
40#if wxUSE_CARET
41 #include "wx/caret.h"
42#endif // wxUSE_CARET
43
44#if wxUSE_TEXTCTRL
45 #include "wx/textctrl.h"
46#endif
47
48#include "wx/menu.h"
49#include "wx/statusbr.h"
50#include "wx/intl.h"
51#include "wx/settings.h"
52#include "wx/log.h"
53#include "wx/fontutil.h"
54
55#ifdef __WXDEBUG__
56 #include "wx/thread.h"
57#endif
58
59#include <math.h>
60#include <ctype.h>
61
62#include "wx/gtk/private.h"
63#include <gdk/gdkprivate.h>
64#include <gdk/gdkkeysyms.h>
65#include <gdk/gdkx.h>
66
67#include <gtk/gtk.h>
68#include <gtk/gtkprivate.h>
69
70#include "wx/gtk/win_gtk.h"
71
72#ifdef __WXGTK20__
73#include <pango/pangox.h>
74#endif
75
76#ifdef __WXGTK20__
77 #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d))
78#else
79 #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d))
80#endif
81
82#ifdef __WXGTK20__
83 #ifdef HAVE_XIM
84 #undef HAVE_XIM
85 #endif
86#endif
87
88#ifdef __WXGTK20__
89extern GtkContainerClass *pizza_parent_class;
90#endif
91
92//-----------------------------------------------------------------------------
93// documentation on internals
94//-----------------------------------------------------------------------------
95
96/*
97 I have been asked several times about writing some documentation about
98 the GTK port of wxWindows, especially its internal structures. Obviously,
99 you cannot understand wxGTK without knowing a little about the GTK, but
100 some more information about what the wxWindow, which is the base class
101 for all other window classes, does seems required as well.
102
103 I)
104
105 What does wxWindow do? It contains the common interface for the following
106 jobs of its descendants:
107
108 1) Define the rudimentary behaviour common to all window classes, such as
109 resizing, intercepting user input (so as to make it possible to use these
110 events for special purposes in a derived class), window names etc.
111
112 2) Provide the possibility to contain and manage children, if the derived
113 class is allowed to contain children, which holds true for those window
114 classes which do not display a native GTK widget. To name them, these
115 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
116 work classes are a special case and are handled a bit differently from
117 the rest. The same holds true for the wxNotebook class.
118
119 3) Provide the possibility to draw into a client area of a window. This,
120 too, only holds true for classes that do not display a native GTK widget
121 as above.
122
123 4) Provide the entire mechanism for scrolling widgets. This actual inter-
124 face for this is usually in wxScrolledWindow, but the GTK implementation
125 is in this class.
126
127 5) A multitude of helper or extra methods for special purposes, such as
128 Drag'n'Drop, managing validators etc.
129
130 6) Display a border (sunken, raised, simple or none).
131
132 Normally one might expect, that one wxWindows window would always correspond
133 to one GTK widget. Under GTK, there is no such allround widget that has all
134 the functionality. Moreover, the GTK defines a client area as a different
135 widget from the actual widget you are handling. Last but not least some
136 special classes (e.g. wxFrame) handle different categories of widgets and
137 still have the possibility to draw something in the client area.
138 It was therefore required to write a special purpose GTK widget, that would
139 represent a client area in the sense of wxWindows capable to do the jobs
140 2), 3) and 4). I have written this class and it resides in win_gtk.c of
141 this directory.
142
143 All windows must have a widget, with which they interact with other under-
144 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
145 thw wxWindow class has a member variable called m_widget which holds a
146 pointer to this widget. When the window class represents a GTK native widget,
147 this is (in most cases) the only GTK widget the class manages. E.g. the
148 wxStatitText class handles only a GtkLabel widget a pointer to which you
149 can find in m_widget (defined in wxWindow)
150
151 When the class has a client area for drawing into and for containing children
152 it has to handle the client area widget (of the type GtkPizza, defined in
153 win_gtk.c), but there could be any number of widgets, handled by a class
154 The common rule for all windows is only, that the widget that interacts with
155 the rest of GTK must be referenced in m_widget and all other widgets must be
156 children of this widget on the GTK level. The top-most widget, which also
157 represents the client area, must be in the m_wxwindow field and must be of
158 the type GtkPizza.
159
160 As I said, the window classes that display a GTK native widget only have
161 one widget, so in the case of e.g. the wxButton class m_widget holds a
162 pointer to a GtkButton widget. But windows with client areas (for drawing
163 and children) have a m_widget field that is a pointer to a GtkScrolled-
164 Window and a m_wxwindow field that is pointer to a GtkPizza and this
165 one is (in the GTK sense) a child of the GtkScrolledWindow.
166
167 If the m_wxwindow field is set, then all input to this widget is inter-
168 cepted and sent to the wxWindows class. If not, all input to the widget
169 that gets pointed to by m_widget gets intercepted and sent to the class.
170
171 II)
172
173 The design of scrolling in wxWindows is markedly different from that offered
174 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
175 clicking on a scrollbar belonging to scrolled window will inevitably move
176 the window. In wxWindows, the scrollbar will only emit an event, send this
177 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
178 which actually moves the window and its subchildren. Note that GtkPizza
179 memorizes how much it has been scrolled but that wxWindows forgets this
180 so that the two coordinates systems have to be kept in synch. This is done
181 in various places using the pizza->xoffset and pizza->yoffset values.
182
183 III)
184
185 Singularily the most broken code in GTK is the code that is supposes to
186 inform subwindows (child windows) about new positions. Very often, duplicate
187 events are sent without changes in size or position, equally often no
188 events are sent at all (All this is due to a bug in the GtkContainer code
189 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
190 GTK's own system and it simply waits for size events for toplevel windows
191 and then iterates down the respective size events to all window. This has
192 the disadvantage, that windows might get size events before the GTK widget
193 actually has the reported size. This doesn't normally pose any problem, but
194 the OpenGl drawing routines rely on correct behaviour. Therefore, I have
195 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
196 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
197 window that is used for OpenGl output really has that size (as reported by
198 GTK).
199
200 IV)
201
202 If someone at some point of time feels the immense desire to have a look at,
203 change or attempt to optimse the Refresh() logic, this person will need an
204 intimate understanding of what a "draw" and what an "expose" events are and
205 what there are used for, in particular when used in connection with GTK's
206 own windowless widgets. Beware.
207
208 V)
209
210 Cursors, too, have been a constant source of pleasure. The main difficulty
211 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
212 for the parent. To prevent this from doing too much harm, I use idle time
213 to set the cursor over and over again, starting from the toplevel windows
214 and ending with the youngest generation (speaking of parent and child windows).
215 Also don't forget that cursors (like much else) are connected to GdkWindows,
216 not GtkWidgets and that the "window" field of a GtkWidget might very well
217 point to the GdkWindow of the parent widget (-> "window less widget") and
218 that the two obviously have very different meanings.
219
220*/
221
222//-----------------------------------------------------------------------------
223// data
224//-----------------------------------------------------------------------------
225
226extern wxList wxPendingDelete;
227extern bool g_blockEventsOnDrag;
228extern bool g_blockEventsOnScroll;
229extern wxCursor g_globalCursor;
230
231static GdkGC *g_eraseGC = NULL;
232
233// mouse capture state: the window which has it and if the mouse is currently
234// inside it
235static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
236static bool g_captureWindowHasMouse = FALSE;
237
238/* extern */ wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL;
239
240// the last window which had the focus - this is normally never NULL (except
241// if we never had focus at all) as even when g_focusWindow is NULL it still
242// keeps its previous value
243static wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL;
244
245// the frame that is currently active (i.e. its child has focus). It is
246// used to generate wxActivateEvents
247static wxWindowGTK *g_activeFrame = (wxWindowGTK*) NULL;
248static bool g_activeFrameLostFocus = FALSE;
249
250// If a window get the focus set but has not been realized
251// yet, defer setting the focus to idle time.
252wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;
253
254// if we detect that the app has got/lost the focus, we set this variable to
255// either TRUE or FALSE and an activate event will be sent during the next
256// OnIdle() call and it is reset to -1: this value means that we shouldn't
257// send any activate events at all
258static int g_sendActivateEvent = -1;
259
260// hack: we need something to pass to gtk_menu_popup, so we store the time of
261// the last click here
262static guint32 gs_timeLastClick = 0;
263
264extern bool g_mainThreadLocked;
265
266//-----------------------------------------------------------------------------
267// debug
268//-----------------------------------------------------------------------------
269
270#ifndef __WXGTK20__
271#define DISABLE_STYLE_IF_BROKEN_THEME 0
272#endif
273
274#ifdef __WXDEBUG__
275
276#if wxUSE_THREADS
277# define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
278#else
279# define DEBUG_MAIN_THREAD
280#endif
281#else
282#define DEBUG_MAIN_THREAD
283#endif // Debug
284
285// the trace mask used for the focus debugging messages
286#define TRACE_FOCUS _T("focus")
287
288//-----------------------------------------------------------------------------
289// missing gdk functions
290//-----------------------------------------------------------------------------
291
292void
293gdk_window_warp_pointer (GdkWindow *window,
294 gint x,
295 gint y)
296{
297#ifndef __WXGTK20__
298 GdkWindowPrivate *priv;
299#endif
300
301 if (!window)
302 window = GDK_ROOT_PARENT();
303
304#ifdef __WXGTK20__
305 if (!GDK_WINDOW_DESTROYED(window))
306 {
307 XWarpPointer (GDK_WINDOW_XDISPLAY(window),
308 None, /* not source window -> move from anywhere */
309 GDK_WINDOW_XID(window), /* dest window */
310 0, 0, 0, 0, /* not source window -> move from anywhere */
311 x, y );
312 }
313#else
314 priv = (GdkWindowPrivate*) window;
315
316 if (!priv->destroyed)
317 {
318 XWarpPointer (priv->xdisplay,
319 None, /* not source window -> move from anywhere */
320 priv->xwindow, /* dest window */
321 0, 0, 0, 0, /* not source window -> move from anywhere */
322 x, y );
323 }
324#endif
325}
326
327//-----------------------------------------------------------------------------
328// idle system
329//-----------------------------------------------------------------------------
330
331extern void wxapp_install_idle_handler();
332extern bool g_isIdle;
333
334//-----------------------------------------------------------------------------
335// local code (see below)
336//-----------------------------------------------------------------------------
337
338// returns the child of win which currently has focus or NULL if not found
339//
340// Note: can't be static, needed by textctrl.cpp.
341wxWindow *wxFindFocusedChild(wxWindowGTK *win)
342{
343 wxWindow *winFocus = wxWindowGTK::FindFocus();
344 if ( !winFocus )
345 return (wxWindow *)NULL;
346
347 if ( winFocus == win )
348 return (wxWindow *)win;
349
350 for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
351 node;
352 node = node->GetNext() )
353 {
354 wxWindow *child = wxFindFocusedChild(node->GetData());
355 if ( child )
356 return child;
357 }
358
359 return (wxWindow *)NULL;
360}
361
362static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
363{
364 // wxUniversal widgets draw the borders and scrollbars themselves
365#ifndef __WXUNIVERSAL__
366 if (!win->m_hasVMT)
367 return;
368
369 int dw = 0;
370 int dh = 0;
371
372 if (win->m_hasScrolling)
373 {
374 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
375
376 GtkRequisition vscroll_req;
377 vscroll_req.width = 2;
378 vscroll_req.height = 2;
379 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
380 (scroll_window->vscrollbar, &vscroll_req );
381
382 GtkRequisition hscroll_req;
383 hscroll_req.width = 2;
384 hscroll_req.height = 2;
385 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
386 (scroll_window->hscrollbar, &hscroll_req );
387
388 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget) );
389
390 if (scroll_window->vscrollbar_visible)
391 {
392 dw += vscroll_req.width;
393 dw += scroll_class->scrollbar_spacing;
394 }
395
396 if (scroll_window->hscrollbar_visible)
397 {
398 dh += hscroll_req.height;
399 dh += scroll_class->scrollbar_spacing;
400 }
401}
402
403 int dx = 0;
404 int dy = 0;
405 if (GTK_WIDGET_NO_WINDOW (widget))
406 {
407 dx += widget->allocation.x;
408 dy += widget->allocation.y;
409 }
410
411 if (win->HasFlag(wxRAISED_BORDER))
412 {
413 gtk_draw_shadow( widget->style,
414 widget->window,
415 GTK_STATE_NORMAL,
416 GTK_SHADOW_OUT,
417 dx, dy,
418 widget->allocation.width-dw, widget->allocation.height-dh );
419 return;
420 }
421
422 if (win->HasFlag(wxSUNKEN_BORDER))
423 {
424 gtk_draw_shadow( widget->style,
425 widget->window,
426 GTK_STATE_NORMAL,
427 GTK_SHADOW_IN,
428 dx, dy,
429 widget->allocation.width-dw, widget->allocation.height-dh );
430 return;
431 }
432
433 if (win->HasFlag(wxSIMPLE_BORDER))
434 {
435 GdkGC *gc;
436 gc = gdk_gc_new( widget->window );
437 gdk_gc_set_foreground( gc, &widget->style->black );
438 gdk_draw_rectangle( widget->window, gc, FALSE,
439 dx, dy,
440 widget->allocation.width-dw-1, widget->allocation.height-dh-1 );
441 gdk_gc_unref( gc );
442 return;
443 }
444#endif // __WXUNIVERSAL__
445}
446
447//-----------------------------------------------------------------------------
448// "expose_event" of m_widget
449//-----------------------------------------------------------------------------
450
451gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )
452{
453 if (gdk_event->count > 0) return FALSE;
454
455 draw_frame( widget, win );
456
457#ifdef __WXGTK20__
458
459 (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
460
461#endif
462 return TRUE;
463}
464
465//-----------------------------------------------------------------------------
466// "draw" of m_widget
467//-----------------------------------------------------------------------------
468
469#ifndef __WXGTK20__
470
471static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
472{
473 draw_frame( widget, win );
474}
475
476#endif // GTK+ < 2.0
477
478//-----------------------------------------------------------------------------
479// "size_request" of m_widget
480//-----------------------------------------------------------------------------
481
482// make it extern because wxStatitText needs to disconnect this one
483extern "C"
484void wxgtk_window_size_request_callback(GtkWidget *widget,
485 GtkRequisition *requisition,
486 wxWindow *win)
487{
488 int w, h;
489 win->GetSize( &w, &h );
490 if (w < 2)
491 w = 2;
492 if (h < 2)
493 h = 2;
494
495 requisition->height = h;
496 requisition->width = w;
497}
498
499//-----------------------------------------------------------------------------
500// "expose_event" of m_wxwindow
501//-----------------------------------------------------------------------------
502
503static int gtk_window_expose_callback( GtkWidget *widget,
504 GdkEventExpose *gdk_event,
505 wxWindow *win )
506{
507 DEBUG_MAIN_THREAD
508
509 if (g_isIdle)
510 wxapp_install_idle_handler();
511
512#ifdef __WXGTK20__
513 // This callback gets called in drawing-idle time under
514 // GTK 2.0, so we don't need to defer anything to idle
515 // time anymore.
516
517 GtkPizza *pizza = GTK_PIZZA( widget );
518 if (gdk_event->window != pizza->bin_window) return FALSE;
519
520#if 0
521 if (win->GetName())
522 {
523 wxPrintf( wxT("OnExpose from ") );
524 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
525 wxPrintf( win->GetClassInfo()->GetClassName() );
526 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event->area.x,
527 (int)gdk_event->area.y,
528 (int)gdk_event->area.width,
529 (int)gdk_event->area.height );
530 }
531
532 gtk_paint_box
533 (
534 win->m_wxwindow->style,
535 pizza->bin_window,
536 GTK_STATE_NORMAL,
537 GTK_SHADOW_OUT,
538 (GdkRectangle*) NULL,
539 win->m_wxwindow,
540 (char *)"button", // const_cast
541 20,20,24,24
542 );
543#endif
544
545 win->GetUpdateRegion() = wxRegion( gdk_event->region );
546
547 win->GtkSendPaintEvents();
548
549
550 // Let parent window draw window less widgets
551 (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
552#else
553 // This gets called immediately after an expose event
554 // under GTK 1.2 so we collect the calls and wait for
555 // the idle handler to pick things up.
556
557 win->GetUpdateRegion().Union( gdk_event->area.x,
558 gdk_event->area.y,
559 gdk_event->area.width,
560 gdk_event->area.height );
561 win->m_clearRegion.Union( gdk_event->area.x,
562 gdk_event->area.y,
563 gdk_event->area.width,
564 gdk_event->area.height );
565
566 // Actual redrawing takes place in idle time.
567 // win->GtkUpdate();
568#endif
569
570 return FALSE;
571}
572
573//-----------------------------------------------------------------------------
574// "event" of m_wxwindow
575//-----------------------------------------------------------------------------
576
577// GTK thinks it is clever and filters out a certain amount of "unneeded"
578// expose events. We need them, of course, so we override the main event
579// procedure in GtkWidget by giving our own handler for all system events.
580// There, we look for expose events ourselves whereas all other events are
581// handled normally.
582
583gint gtk_window_event_event_callback( GtkWidget *widget,
584 GdkEventExpose *event,
585 wxWindow *win )
586{
587 if (event->type == GDK_EXPOSE)
588 {
589 gint ret = gtk_window_expose_callback( widget, event, win );
590 return ret;
591 }
592
593 return FALSE;
594}
595
596//-----------------------------------------------------------------------------
597// "draw" of m_wxwindow
598//-----------------------------------------------------------------------------
599
600#ifndef __WXGTK20__
601
602// This callback is a complete replacement of the gtk_pizza_draw() function,
603// which is disabled.
604
605static void gtk_window_draw_callback( GtkWidget *widget,
606 GdkRectangle *rect,
607 wxWindow *win )
608{
609 DEBUG_MAIN_THREAD
610
611 if (g_isIdle)
612 wxapp_install_idle_handler();
613
614 // if there are any children we must refresh everything
615 //
616 // VZ: why?
617 if ( !win->HasFlag(wxFULL_REPAINT_ON_RESIZE) &&
618 win->GetChildren().IsEmpty() )
619 {
620 return;
621 }
622
623#if 0
624 if (win->GetName())
625 {
626 wxPrintf( wxT("OnDraw from ") );
627 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
628 wxPrintf( win->GetClassInfo()->GetClassName() );
629 wxPrintf( wxT(" %d %d %d %d\n"), (int)rect->x,
630 (int)rect->y,
631 (int)rect->width,
632 (int)rect->height );
633 }
634#endif
635
636#ifndef __WXUNIVERSAL__
637 GtkPizza *pizza = GTK_PIZZA (widget);
638
639 if (win->GetThemeEnabled())
640 {
641 wxWindow *parent = win->GetParent();
642 while (parent && !parent->IsTopLevel())
643 parent = parent->GetParent();
644 if (!parent)
645 parent = win;
646
647 gtk_paint_flat_box (parent->m_widget->style,
648 pizza->bin_window,
649 GTK_STATE_NORMAL,
650 GTK_SHADOW_NONE,
651 rect,
652 parent->m_widget,
653 (char *)"base",
654 0, 0, -1, -1);
655 }
656#endif
657
658 win->m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
659 win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
660
661 // Update immediately, not in idle time.
662 win->GtkUpdate();
663
664#ifndef __WXUNIVERSAL__
665 // Redraw child widgets
666 GList *children = pizza->children;
667 while (children)
668 {
669 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
670 children = children->next;
671
672 GdkRectangle child_area;
673 if (gtk_widget_intersect (child->widget, rect, &child_area))
674 {
675 gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ );
676 }
677 }
678#endif
679}
680
681#endif
682
683//-----------------------------------------------------------------------------
684// "key_press_event" from any window
685//-----------------------------------------------------------------------------
686
687// set WXTRACE to this to see the key event codes on the console
688#define TRACE_KEYS _T("keyevent")
689
690// translates an X key symbol to WXK_XXX value
691//
692// if isChar is true it means that the value returned will be used for EVT_CHAR
693// event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
694// for example, while if it is false it means that the value is going to be
695// used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
696// WXK_NUMPAD_DIVIDE
697static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
698{
699 long key_code;
700
701 switch ( keysym )
702 {
703 // Shift, Control and Alt don't generate the CHAR events at all
704 case GDK_Shift_L:
705 case GDK_Shift_R:
706 key_code = isChar ? 0 : WXK_SHIFT;
707 break;
708 case GDK_Control_L:
709 case GDK_Control_R:
710 key_code = isChar ? 0 : WXK_CONTROL;
711 break;
712 case GDK_Meta_L:
713 case GDK_Meta_R:
714 case GDK_Alt_L:
715 case GDK_Alt_R:
716 case GDK_Super_L:
717 case GDK_Super_R:
718 key_code = isChar ? 0 : WXK_ALT;
719 break;
720
721 // neither do the toggle modifies
722 case GDK_Scroll_Lock:
723 key_code = isChar ? 0 : WXK_SCROLL;
724 break;
725
726 case GDK_Caps_Lock:
727 key_code = isChar ? 0 : WXK_CAPITAL;
728 break;
729
730 case GDK_Num_Lock:
731 key_code = isChar ? 0 : WXK_NUMLOCK;
732 break;
733
734
735 // various other special keys
736 case GDK_Menu:
737 key_code = WXK_MENU;
738 break;
739
740 case GDK_Help:
741 key_code = WXK_HELP;
742 break;
743
744 case GDK_BackSpace:
745 key_code = WXK_BACK;
746 break;
747
748 case GDK_ISO_Left_Tab:
749 case GDK_Tab:
750 key_code = WXK_TAB;
751 break;
752
753 case GDK_Linefeed:
754 case GDK_Return:
755 key_code = WXK_RETURN;
756 break;
757
758 case GDK_Clear:
759 key_code = WXK_CLEAR;
760 break;
761
762 case GDK_Pause:
763 key_code = WXK_PAUSE;
764 break;
765
766 case GDK_Select:
767 key_code = WXK_SELECT;
768 break;
769
770 case GDK_Print:
771 key_code = WXK_PRINT;
772 break;
773
774 case GDK_Execute:
775 key_code = WXK_EXECUTE;
776 break;
777
778 case GDK_Escape:
779 key_code = WXK_ESCAPE;
780 break;
781
782 // cursor and other extended keyboard keys
783 case GDK_Delete:
784 key_code = WXK_DELETE;
785 break;
786
787 case GDK_Home:
788 key_code = WXK_HOME;
789 break;
790
791 case GDK_Left:
792 key_code = WXK_LEFT;
793 break;
794
795 case GDK_Up:
796 key_code = WXK_UP;
797 break;
798
799 case GDK_Right:
800 key_code = WXK_RIGHT;
801 break;
802
803 case GDK_Down:
804 key_code = WXK_DOWN;
805 break;
806
807 case GDK_Prior: // == GDK_Page_Up
808 key_code = WXK_PRIOR;
809 break;
810
811 case GDK_Next: // == GDK_Page_Down
812 key_code = WXK_NEXT;
813 break;
814
815 case GDK_End:
816 key_code = WXK_END;
817 break;
818
819 case GDK_Begin:
820 key_code = WXK_HOME;
821 break;
822
823 case GDK_Insert:
824 key_code = WXK_INSERT;
825 break;
826
827
828 // numpad keys
829 case GDK_KP_0:
830 case GDK_KP_1:
831 case GDK_KP_2:
832 case GDK_KP_3:
833 case GDK_KP_4:
834 case GDK_KP_5:
835 case GDK_KP_6:
836 case GDK_KP_7:
837 case GDK_KP_8:
838 case GDK_KP_9:
839 key_code = (isChar ? '0' : WXK_NUMPAD0) + keysym - GDK_KP_0;
840 break;
841
842 case GDK_KP_Space:
843 key_code = isChar ? ' ' : WXK_NUMPAD_SPACE;
844 break;
845
846 case GDK_KP_Tab:
847 key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
848 break;
849
850 case GDK_KP_Enter:
851 key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
852 break;
853
854 case GDK_KP_F1:
855 key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
856 break;
857
858 case GDK_KP_F2:
859 key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
860 break;
861
862 case GDK_KP_F3:
863 key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
864 break;
865
866 case GDK_KP_F4:
867 key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
868 break;
869
870 case GDK_KP_Home:
871 key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
872 break;
873
874 case GDK_KP_Left:
875 key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
876 break;
877
878 case GDK_KP_Up:
879 key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
880 break;
881
882 case GDK_KP_Right:
883 key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
884 break;
885
886 case GDK_KP_Down:
887 key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
888 break;
889
890 case GDK_KP_Prior: // == GDK_KP_Page_Up
891 key_code = isChar ? WXK_PRIOR : WXK_NUMPAD_PRIOR;
892 break;
893
894 case GDK_KP_Next: // == GDK_KP_Page_Down
895 key_code = isChar ? WXK_NEXT : WXK_NUMPAD_NEXT;
896 break;
897
898 case GDK_KP_End:
899 key_code = isChar ? WXK_END : WXK_NUMPAD_END;
900 break;
901
902 case GDK_KP_Begin:
903 key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
904 break;
905
906 case GDK_KP_Insert:
907 key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
908 break;
909
910 case GDK_KP_Delete:
911 key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
912 break;
913
914 case GDK_KP_Equal:
915 key_code = isChar ? '=' : WXK_NUMPAD_EQUAL;
916 break;
917
918 case GDK_KP_Multiply:
919 key_code = isChar ? '*' : WXK_NUMPAD_MULTIPLY;
920 break;
921
922 case GDK_KP_Add:
923 key_code = isChar ? '+' : WXK_NUMPAD_ADD;
924 break;
925
926 case GDK_KP_Separator:
927 // FIXME: what is this?
928 key_code = isChar ? '.' : WXK_NUMPAD_SEPARATOR;
929 break;
930
931 case GDK_KP_Subtract:
932 key_code = isChar ? '-' : WXK_NUMPAD_SUBTRACT;
933 break;
934
935 case GDK_KP_Decimal:
936 key_code = isChar ? '.' : WXK_NUMPAD_DECIMAL;
937 break;
938
939 case GDK_KP_Divide:
940 key_code = isChar ? '/' : WXK_NUMPAD_DIVIDE;
941 break;
942
943
944 // function keys
945 case GDK_F1:
946 case GDK_F2:
947 case GDK_F3:
948 case GDK_F4:
949 case GDK_F5:
950 case GDK_F6:
951 case GDK_F7:
952 case GDK_F8:
953 case GDK_F9:
954 case GDK_F10:
955 case GDK_F11:
956 case GDK_F12:
957 key_code = WXK_F1 + keysym - GDK_F1;
958 break;
959
960 default:
961 key_code = 0;
962 }
963
964 return key_code;
965}
966
967static inline bool wxIsAsciiKeysym(KeySym ks)
968{
969 return ks < 256;
970}
971
972static bool
973wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
974 wxWindowGTK *win,
975 GdkEventKey *gdk_event)
976{
977 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
978 // but only event->keyval which is quite useless to us, so remember
979 // the last character from GDK_KEY_PRESS and reuse it as last resort
980 //
981 // NB: should be MT-safe as we're always called from the main thread only
982 static struct
983 {
984 KeySym keysym;
985 long keycode;
986 } s_lastKeyPress = { 0, 0 };
987
988 KeySym keysym = gdk_event->keyval;
989
990 wxLogTrace(TRACE_KEYS, _T("Key %s event: keysym = %ld"),
991 event.GetEventType() == wxEVT_KEY_UP ? _T("release")
992 : _T("press"),
993 keysym);
994
995 long key_code = wxTranslateKeySymToWXKey(keysym, FALSE /* !isChar */);
996
997 if ( !key_code )
998 {
999 // do we have the translation or is it a plain ASCII character?
1000 if ( (gdk_event->length == 1) || wxIsAsciiKeysym(keysym) )
1001 {
1002 // we should use keysym if it is ASCII as X does some translations
1003 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
1004 // which we don't want here (but which we do use for OnChar())
1005 if ( !wxIsAsciiKeysym(keysym) )
1006 {
1007 keysym = (KeySym)gdk_event->string[0];
1008 }
1009
1010 // we want to always get the same key code when the same key is
1011 // pressed regardless of the state of the modifies, i.e. on a
1012 // standard US keyboard pressing '5' or '%' ('5' key with
1013 // Shift) should result in the same key code in OnKeyDown():
1014 // '5' (although OnChar() will get either '5' or '%').
1015 //
1016 // to do it we first translate keysym to keycode (== scan code)
1017 // and then back but always using the lower register
1018 Display *dpy = (Display *)wxGetDisplay();
1019 KeyCode keycode = XKeysymToKeycode(dpy, keysym);
1020
1021 wxLogTrace(TRACE_KEYS, _T("\t-> keycode %d"), keycode);
1022
1023 KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
1024
1025 // use the normalized, i.e. lower register, keysym if we've
1026 // got one
1027 key_code = keysymNormalized ? keysymNormalized : keysym;
1028
1029 // as explained above, we want to have lower register key codes
1030 // normally but for the letter keys we want to have the upper ones
1031 //
1032 // NB: don't use XConvertCase() here, we want to do it for letters
1033 // only
1034 key_code = toupper(key_code);
1035 }
1036 else // non ASCII key, what to do?
1037 {
1038 // by default, ignore it
1039 key_code = 0;
1040
1041 // but if we have cached information from the last KEY_PRESS
1042 if ( gdk_event->type == GDK_KEY_RELEASE )
1043 {
1044 // then reuse it
1045 if ( keysym == s_lastKeyPress.keysym )
1046 {
1047 key_code = s_lastKeyPress.keycode;
1048 }
1049 }
1050 }
1051
1052 if ( gdk_event->type == GDK_KEY_PRESS )
1053 {
1054 // remember it to be reused for KEY_UP event later
1055 s_lastKeyPress.keysym = keysym;
1056 s_lastKeyPress.keycode = key_code;
1057 }
1058 }
1059
1060 wxLogTrace(TRACE_KEYS, _T("\t-> wxKeyCode %ld"), key_code);
1061
1062 // sending unknown key events doesn't really make sense
1063 if ( !key_code )
1064 return FALSE;
1065
1066 // now fill all the other fields
1067 int x = 0;
1068 int y = 0;
1069 GdkModifierType state;
1070 if (gdk_event->window)
1071 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1072
1073 event.SetTimestamp( gdk_event->time );
1074 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
1075 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
1076 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
1077 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
1078 event.m_keyCode = key_code;
1079 event.m_scanCode = gdk_event->keyval;
1080 event.m_rawCode = (wxUint32) gdk_event->keyval;
1081 event.m_rawFlags = 0;
1082 event.m_x = x;
1083 event.m_y = y;
1084 event.SetEventObject( win );
1085
1086 return TRUE;
1087}
1088
1089
1090static gint gtk_window_key_press_callback( GtkWidget *widget,
1091 GdkEventKey *gdk_event,
1092 wxWindow *win )
1093{
1094 DEBUG_MAIN_THREAD
1095
1096 if (g_isIdle)
1097 wxapp_install_idle_handler();
1098
1099 if (!win->m_hasVMT)
1100 return FALSE;
1101 if (g_blockEventsOnDrag)
1102 return FALSE;
1103
1104
1105 wxKeyEvent event( wxEVT_KEY_DOWN );
1106 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1107 {
1108 // unknown key pressed, ignore (the event would be useless anyhow)
1109 return FALSE;
1110 }
1111
1112 // Emit KEY_DOWN event
1113 bool ret = win->GetEventHandler()->ProcessEvent( event );
1114
1115#if wxUSE_ACCEL
1116 if (!ret)
1117 {
1118 wxWindowGTK *ancestor = win;
1119 while (ancestor)
1120 {
1121 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1122 if (command != -1)
1123 {
1124 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1125 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
1126 break;
1127 }
1128 if (ancestor->IsTopLevel())
1129 break;
1130 ancestor = ancestor->GetParent();
1131 }
1132 }
1133#endif // wxUSE_ACCEL
1134
1135 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1136 // will only be sent if it is not in an accelerator table.
1137 if (!ret)
1138 {
1139 long key_code;
1140 KeySym keysym = gdk_event->keyval;
1141#ifdef __WXGTK20__
1142 // In GTK 2.0, we need to hand over the key event to an input method
1143 // and the IM will emit a "commit" event containing the actual utf8
1144 // character. In that case the EVT_CHAR events will be sent from
1145 // there. But only do it this way for non-KeySym keys.
1146 key_code = wxTranslateKeySymToWXKey(gdk_event->keyval, FALSE /* isChar */);
1147 if ( !key_code && win->m_imContext )
1148 {
1149 gtk_im_context_filter_keypress ( (GtkIMContext*) win->m_imContext, gdk_event );
1150 ret = TRUE;
1151 }
1152 else
1153#endif
1154 {
1155 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1156 key_code = wxTranslateKeySymToWXKey(keysym, TRUE /* isChar */);
1157 if ( !key_code )
1158 {
1159 if ( gdk_event->length == 1 )
1160 {
1161 key_code = (unsigned char)gdk_event->string[0];
1162 }
1163 else if ( wxIsAsciiKeysym(keysym) )
1164 {
1165 // ASCII key
1166 key_code = (unsigned char)keysym;
1167 }
1168 }
1169
1170 if ( key_code )
1171 {
1172 wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);
1173
1174 event.m_keyCode = key_code;
1175
1176 // Implement OnCharHook by checking ancesteror top level windows
1177 wxWindow *parent = win;
1178 while (parent && !parent->IsTopLevel())
1179 parent = parent->GetParent();
1180 if (parent)
1181 {
1182 event.SetEventType( wxEVT_CHAR_HOOK );
1183 ret = parent->GetEventHandler()->ProcessEvent( event );
1184 }
1185
1186 if (!ret)
1187 {
1188 event.SetEventType(wxEVT_CHAR);
1189 ret = win->GetEventHandler()->ProcessEvent( event );
1190 }
1191 }
1192 }
1193 }
1194
1195 // win is a control: tab can be propagated up
1196 if ( !ret &&
1197 ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
1198// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1199// have this style, yet choose not to process this particular TAB in which
1200// case TAB must still work as a navigational character
1201#if 0
1202 !win->HasFlag(wxTE_PROCESS_TAB) &&
1203#endif // 0
1204 win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1205 {
1206 wxNavigationKeyEvent new_event;
1207 new_event.SetEventObject( win->GetParent() );
1208 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1209 new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
1210 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1211 new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
1212 new_event.SetCurrentFocus( win );
1213 ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
1214 }
1215
1216 // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
1217 if ( !ret &&
1218 (gdk_event->keyval == GDK_Escape) )
1219 {
1220 // however only do it if we have a Cancel button in the dialog,
1221 // otherwise the user code may get confused by the events from a
1222 // non-existing button and, worse, a wxButton might get button event
1223 // from another button which is not really expected
1224 wxWindow *winForCancel = win,
1225 *btnCancel = NULL;
1226 while ( winForCancel )
1227 {
1228 btnCancel = winForCancel->FindWindow(wxID_CANCEL);
1229 if ( btnCancel )
1230 {
1231 // found a cancel button
1232 break;
1233 }
1234
1235 if ( winForCancel->IsTopLevel() )
1236 {
1237 // no need to look further
1238 break;
1239 }
1240
1241 // maybe our parent has a cancel button?
1242 winForCancel = winForCancel->GetParent();
1243 }
1244
1245 if ( btnCancel )
1246 {
1247 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
1248 event.SetEventObject(btnCancel);
1249 ret = btnCancel->GetEventHandler()->ProcessEvent(event);
1250 }
1251 }
1252
1253 if (ret)
1254 {
1255 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
1256 return TRUE;
1257 }
1258
1259 return FALSE;
1260}
1261
1262#ifdef __WXGTK20__
1263static void gtk_wxwindow_commit_cb (GtkIMContext *context,
1264 const gchar *str,
1265 wxWindow *window)
1266{
1267 bool ret = FALSE;
1268
1269 wxKeyEvent event( wxEVT_KEY_DOWN );
1270
1271#if wxUSE_UNICODE
1272 event.m_uniChar = g_utf8_get_char( str );
1273
1274 // Backward compatible for ISO-8859
1275 if (event.m_uniChar < 256)
1276 event.m_keyCode = event.m_uniChar;
1277#else
1278 gunichar uniChar = g_utf8_get_char( str );
1279 // We cannot handle Unicode in non-Unicode mode
1280 if (uniChar > 255) return;
1281
1282 event.m_keyCode = uniChar;
1283#endif
1284
1285
1286 // TODO: We still need to set all the extra attributes of the
1287 // event, modifiers and such...
1288
1289
1290 // Implement OnCharHook by checking ancestor top level windows
1291 wxWindow *parent = window;
1292 while (parent && !parent->IsTopLevel())
1293 parent = parent->GetParent();
1294 if (parent)
1295 {
1296 event.SetEventType( wxEVT_CHAR_HOOK );
1297 ret = parent->GetEventHandler()->ProcessEvent( event );
1298 }
1299
1300 if (!ret)
1301 {
1302 event.SetEventType(wxEVT_CHAR);
1303 ret = window->GetEventHandler()->ProcessEvent( event );
1304 }
1305}
1306#endif
1307
1308
1309//-----------------------------------------------------------------------------
1310// "key_release_event" from any window
1311//-----------------------------------------------------------------------------
1312
1313static gint gtk_window_key_release_callback( GtkWidget *widget,
1314 GdkEventKey *gdk_event,
1315 wxWindowGTK *win )
1316{
1317 DEBUG_MAIN_THREAD
1318
1319 if (g_isIdle)
1320 wxapp_install_idle_handler();
1321
1322 if (!win->m_hasVMT)
1323 return FALSE;
1324
1325 if (g_blockEventsOnDrag)
1326 return FALSE;
1327
1328 wxKeyEvent event( wxEVT_KEY_UP );
1329 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1330 {
1331 // unknown key pressed, ignore (the event would be useless anyhow
1332 return FALSE;
1333 }
1334
1335 if ( !win->GetEventHandler()->ProcessEvent( event ) )
1336 return FALSE;
1337
1338 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
1339 return TRUE;
1340}
1341
1342// ============================================================================
1343// the mouse events
1344// ============================================================================
1345
1346// ----------------------------------------------------------------------------
1347// mouse event processing helpers
1348// ----------------------------------------------------------------------------
1349
1350// init wxMouseEvent with the info from gdk_event
1351//
1352// NB: this has to be a macro as gdk_event type is different for different
1353// events we're used with
1354#define InitMouseEvent(/* wxWindowGTK * */ win, \
1355 /* wxMouseEvent& */ event, \
1356 /* GdkEventXXX * */ gdk_event) \
1357{ \
1358 event.SetTimestamp( gdk_event->time ); \
1359 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); \
1360 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); \
1361 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); \
1362 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK); \
1363 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); \
1364 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); \
1365 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); \
1366 if (event.GetEventType()==wxEVT_MOUSEWHEEL) \
1367 { \
1368 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 Show( TRUE );
2736
2737 return TRUE;
2738}
2739
2740wxWindowGTK::~wxWindowGTK()
2741{
2742 SendDestroyEvent();
2743
2744 if (g_focusWindow == this)
2745 g_focusWindow = NULL;
2746
2747 if (g_activeFrame == this)
2748 g_activeFrame = NULL;
2749
2750 if ( g_delayedFocus == this )
2751 g_delayedFocus = NULL;
2752
2753 m_isBeingDeleted = TRUE;
2754 m_hasVMT = FALSE;
2755
2756 if (m_widget)
2757 Show( FALSE );
2758
2759 DestroyChildren();
2760
2761#ifdef HAVE_XIM
2762 if (m_ic)
2763 gdk_ic_destroy (m_ic);
2764 if (m_icattr)
2765 gdk_ic_attr_destroy (m_icattr);
2766#endif
2767
2768 if (m_widgetStyle)
2769 {
2770#if DISABLE_STYLE_IF_BROKEN_THEME
2771 // don't delete if it's a pixmap theme style
2772 if (!m_widgetStyle->engine_data)
2773 gtk_style_unref( m_widgetStyle );
2774#endif
2775 m_widgetStyle = (GtkStyle*) NULL;
2776 }
2777
2778 if (m_wxwindow)
2779 {
2780 gtk_widget_destroy( m_wxwindow );
2781 m_wxwindow = (GtkWidget*) NULL;
2782 }
2783
2784 if (m_widget)
2785 {
2786 gtk_widget_destroy( m_widget );
2787 m_widget = (GtkWidget*) NULL;
2788 }
2789}
2790
2791bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2792{
2793 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
2794
2795 // Use either the given size, or the default if -1 is given.
2796 // See wxWindowBase for these functions.
2797 m_width = WidthDefault(size.x) ;
2798 m_height = HeightDefault(size.y);
2799
2800 m_x = (int)pos.x;
2801 m_y = (int)pos.y;
2802
2803 // some reasonable defaults
2804 if (!parent)
2805 {
2806 if (m_x == -1)
2807 {
2808 m_x = (gdk_screen_width () - m_width) / 2;
2809 if (m_x < 10) m_x = 10;
2810 }
2811 if (m_y == -1)
2812 {
2813 m_y = (gdk_screen_height () - m_height) / 2;
2814 if (m_y < 10) m_y = 10;
2815 }
2816 }
2817
2818 return TRUE;
2819}
2820
2821void wxWindowGTK::PostCreation()
2822{
2823 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2824
2825 if (m_wxwindow)
2826 {
2827 if (!m_noExpose)
2828 {
2829 // these get reported to wxWindows -> wxPaintEvent
2830
2831 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2832
2833 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2834 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2835
2836#ifndef __WXGTK20__
2837 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2838 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
2839
2840 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
2841 {
2842 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2843 GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2844 }
2845#else
2846 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2847#endif
2848
2849#ifdef __WXGTK20__
2850 // Create input method handler
2851 m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new ();
2852
2853 // Cannot handle drawing preedited text yet
2854 gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE );
2855
2856 g_signal_connect (G_OBJECT (m_imContext), "commit",
2857 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2858#endif
2859 }
2860
2861 // these are called when the "sunken" or "raised" borders are drawn
2862 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2863 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2864
2865#ifndef __WXGTK20__
2866 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2867 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
2868#endif
2869 }
2870
2871 // focus handling
2872
2873 if (m_focusWidget == NULL)
2874 m_focusWidget = m_widget;
2875
2876 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2877 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2878
2879 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
2880 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2881
2882 // connect to the various key and mouse handlers
2883
2884 GtkWidget *connect_widget = GetConnectWidget();
2885
2886 ConnectWidget( connect_widget );
2887
2888 /* We cannot set colours, fonts and cursors before the widget has
2889 been realized, so we do this directly after realization */
2890 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
2891 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2892
2893 if (m_wxwindow)
2894 {
2895 // Catch native resize events
2896 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2897 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2898
2899 // Initialize XIM support
2900 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2901 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
2902
2903 // And resize XIM window
2904 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2905 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
2906 }
2907
2908 if ( !GTK_IS_COMBO(m_widget))
2909 {
2910 // This is needed if we want to add our windows into native
2911 // GTK control, such as the toolbar. With this callback, the
2912 // toolbar gets to know the correct size (the one set by the
2913 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2914 // when moving to GTK 2.0.
2915 gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
2916 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
2917 (gpointer) this );
2918 }
2919
2920 m_hasVMT = TRUE;
2921}
2922
2923void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2924{
2925 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2926 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
2927
2928 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2929 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2930
2931 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2932 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2933
2934 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2935 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2936
2937 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2938 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2939
2940#ifdef __WXGTK20__
2941 gtk_signal_connect( GTK_OBJECT(widget), "scroll_event",
2942 GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this );
2943#endif
2944
2945 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2946 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2947
2948 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2949 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2950}
2951
2952bool wxWindowGTK::Destroy()
2953{
2954 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2955
2956 m_hasVMT = FALSE;
2957
2958 return wxWindowBase::Destroy();
2959}
2960
2961void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2962{
2963 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2964}
2965
2966void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2967{
2968 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2969 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2970
2971/*
2972 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2973*/
2974
2975 if (m_resizing) return; /* I don't like recursions */
2976 m_resizing = TRUE;
2977
2978 int currentX, currentY;
2979 GetPosition(&currentX, &currentY);
2980 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2981 x = currentX;
2982 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2983 y = currentY;
2984 AdjustForParentClientOrigin(x, y, sizeFlags);
2985
2986 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
2987 {
2988 /* don't set the size for children of wxNotebook, just take the values. */
2989 m_x = x;
2990 m_y = y;
2991 m_width = width;
2992 m_height = height;
2993 }
2994 else
2995 {
2996 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2997 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2998 {
2999 if (x != -1) m_x = x + pizza->xoffset;
3000 if (y != -1) m_y = y + pizza->yoffset;
3001 }
3002 else
3003 {
3004 m_x = x + pizza->xoffset;
3005 m_y = y + pizza->yoffset;
3006 }
3007
3008 // calculate the best size if we should auto size the window
3009 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) ||
3010 (sizeFlags & wxSIZE_AUTO_HEIGHT) )
3011 {
3012 const wxSize sizeBest = GetBestSize();
3013 if ( sizeFlags & wxSIZE_AUTO_WIDTH )
3014 width = sizeBest.x;
3015 if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
3016 height = sizeBest.y;
3017 }
3018
3019 if (width != -1)
3020 m_width = width;
3021 if (height != -1)
3022 m_height = height;
3023
3024 int minWidth = GetMinWidth(),
3025 minHeight = GetMinHeight(),
3026 maxWidth = GetMaxWidth(),
3027 maxHeight = GetMaxHeight();
3028
3029 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
3030 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
3031 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
3032 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
3033
3034 int border = 0;
3035 int bottom_border = 0;
3036
3037#ifndef __WXGTK20__
3038 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
3039 {
3040 /* the default button has a border around it */
3041 border = 6;
3042 bottom_border = 5;
3043 }
3044#endif
3045
3046 DoMoveWindow( m_x-border,
3047 m_y-border,
3048 m_width+2*border,
3049 m_height+border+bottom_border );
3050 }
3051
3052 if (m_hasScrolling)
3053 {
3054 /* Sometimes the client area changes size without the
3055 whole windows's size changing, but if the whole
3056 windows's size doesn't change, no wxSizeEvent will
3057 normally be sent. Here we add an extra test if
3058 the client test has been changed and this will
3059 be used then. */
3060 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
3061 }
3062
3063/*
3064 wxPrintf( "OnSize sent from " );
3065 if (GetClassInfo() && GetClassInfo()->GetClassName())
3066 wxPrintf( GetClassInfo()->GetClassName() );
3067 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3068*/
3069
3070 if (!m_nativeSizeEvent)
3071 {
3072 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
3073 event.SetEventObject( this );
3074 GetEventHandler()->ProcessEvent( event );
3075 }
3076
3077 m_resizing = FALSE;
3078}
3079
3080void wxWindowGTK::OnInternalIdle()
3081{
3082 // Update invalidated regions.
3083 GtkUpdate();
3084
3085 // Synthetize activate events.
3086 if ( g_sendActivateEvent != -1 )
3087 {
3088 bool activate = g_sendActivateEvent != 0;
3089
3090 // do it only once
3091 g_sendActivateEvent = -1;
3092
3093 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
3094 }
3095
3096 if ( g_activeFrameLostFocus )
3097 {
3098 if ( g_activeFrame )
3099 {
3100 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
3101 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
3102 event.SetEventObject(g_activeFrame);
3103 g_activeFrame->GetEventHandler()->ProcessEvent(event);
3104 g_activeFrame = NULL;
3105 }
3106 g_activeFrameLostFocus = FALSE;
3107 }
3108
3109 wxCursor cursor = m_cursor;
3110 if (g_globalCursor.Ok()) cursor = g_globalCursor;
3111
3112 if (cursor.Ok())
3113 {
3114 /* I now set the cursor anew in every OnInternalIdle call
3115 as setting the cursor in a parent window also effects the
3116 windows above so that checking for the current cursor is
3117 not possible. */
3118
3119 if (m_wxwindow)
3120 {
3121 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
3122 if (window)
3123 gdk_window_set_cursor( window, cursor.GetCursor() );
3124
3125 if (!g_globalCursor.Ok())
3126 cursor = *wxSTANDARD_CURSOR;
3127
3128 window = m_widget->window;
3129 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
3130 gdk_window_set_cursor( window, cursor.GetCursor() );
3131
3132 }
3133 else
3134 {
3135
3136 GdkWindow *window = m_widget->window;
3137 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
3138 gdk_window_set_cursor( window, cursor.GetCursor() );
3139
3140 }
3141 }
3142
3143 if (wxUpdateUIEvent::CanUpdate(this))
3144 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
3145}
3146
3147void wxWindowGTK::DoGetSize( int *width, int *height ) const
3148{
3149 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3150
3151 if (width) (*width) = m_width;
3152 if (height) (*height) = m_height;
3153}
3154
3155void wxWindowGTK::DoSetClientSize( int width, int height )
3156{
3157 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3158
3159 if (!m_wxwindow)
3160 {
3161 SetSize( width, height );
3162 }
3163 else
3164 {
3165 int dw = 0;
3166 int dh = 0;
3167
3168#ifndef __WXUNIVERSAL__
3169 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3170 {
3171 /* when using GTK 1.2 we set the shadow border size to 2 */
3172 dw += 2 * 2;
3173 dh += 2 * 2;
3174 }
3175 if (HasFlag(wxSIMPLE_BORDER))
3176 {
3177 /* when using GTK 1.2 we set the simple border size to 1 */
3178 dw += 1 * 2;
3179 dh += 1 * 2;
3180 }
3181#endif // __WXUNIVERSAL__
3182
3183 if (m_hasScrolling)
3184 {
3185 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3186
3187 GtkRequisition vscroll_req;
3188 vscroll_req.width = 2;
3189 vscroll_req.height = 2;
3190 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3191 (scroll_window->vscrollbar, &vscroll_req );
3192
3193 GtkRequisition hscroll_req;
3194 hscroll_req.width = 2;
3195 hscroll_req.height = 2;
3196 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3197 (scroll_window->hscrollbar, &hscroll_req );
3198
3199 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3200
3201 if (scroll_window->vscrollbar_visible)
3202 {
3203 dw += vscroll_req.width;
3204 dw += scroll_class->scrollbar_spacing;
3205 }
3206
3207 if (scroll_window->hscrollbar_visible)
3208 {
3209 dh += hscroll_req.height;
3210 dh += scroll_class->scrollbar_spacing;
3211 }
3212 }
3213
3214 SetSize( width+dw, height+dh );
3215 }
3216}
3217
3218void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
3219{
3220 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3221
3222 if (!m_wxwindow)
3223 {
3224 if (width) (*width) = m_width;
3225 if (height) (*height) = m_height;
3226 }
3227 else
3228 {
3229 int dw = 0;
3230 int dh = 0;
3231
3232#ifndef __WXUNIVERSAL__
3233 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3234 {
3235 /* when using GTK 1.2 we set the shadow border size to 2 */
3236 dw += 2 * 2;
3237 dh += 2 * 2;
3238 }
3239 if (HasFlag(wxSIMPLE_BORDER))
3240 {
3241 /* when using GTK 1.2 we set the simple border size to 1 */
3242 dw += 1 * 2;
3243 dh += 1 * 2;
3244 }
3245#endif // __WXUNIVERSAL__
3246
3247 if (m_hasScrolling)
3248 {
3249 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3250
3251 GtkRequisition vscroll_req;
3252 vscroll_req.width = 2;
3253 vscroll_req.height = 2;
3254 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3255 (scroll_window->vscrollbar, &vscroll_req );
3256
3257 GtkRequisition hscroll_req;
3258 hscroll_req.width = 2;
3259 hscroll_req.height = 2;
3260 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3261 (scroll_window->hscrollbar, &hscroll_req );
3262
3263 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3264
3265 if (scroll_window->vscrollbar_visible)
3266 {
3267 dw += vscroll_req.width;
3268 dw += scroll_class->scrollbar_spacing;
3269 }
3270
3271 if (scroll_window->hscrollbar_visible)
3272 {
3273 dh += hscroll_req.height;
3274 dh += scroll_class->scrollbar_spacing;
3275 }
3276 }
3277
3278 if (width) (*width) = m_width - dw;
3279 if (height) (*height) = m_height - dh;
3280 }
3281
3282/*
3283 printf( "GetClientSize, name %s ", GetName().c_str() );
3284 if (width) printf( " width = %d", (*width) );
3285 if (height) printf( " height = %d", (*height) );
3286 printf( "\n" );
3287*/
3288}
3289
3290void wxWindowGTK::DoGetPosition( int *x, int *y ) const
3291{
3292 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3293
3294 int dx = 0;
3295 int dy = 0;
3296 if (m_parent && m_parent->m_wxwindow)
3297 {
3298 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
3299 dx = pizza->xoffset;
3300 dy = pizza->yoffset;
3301 }
3302
3303 if (x) (*x) = m_x - dx;
3304 if (y) (*y) = m_y - dy;
3305}
3306
3307void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
3308{
3309 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3310
3311 if (!m_widget->window) return;
3312
3313 GdkWindow *source = (GdkWindow *) NULL;
3314 if (m_wxwindow)
3315 source = GTK_PIZZA(m_wxwindow)->bin_window;
3316 else
3317 source = m_widget->window;
3318
3319 int org_x = 0;
3320 int org_y = 0;
3321 gdk_window_get_origin( source, &org_x, &org_y );
3322
3323 if (!m_wxwindow)
3324 {
3325 if (GTK_WIDGET_NO_WINDOW (m_widget))
3326 {
3327 org_x += m_widget->allocation.x;
3328 org_y += m_widget->allocation.y;
3329 }
3330 }
3331
3332 if (x) *x += org_x;
3333 if (y) *y += org_y;
3334}
3335
3336void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
3337{
3338 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3339
3340 if (!m_widget->window) return;
3341
3342 GdkWindow *source = (GdkWindow *) NULL;
3343 if (m_wxwindow)
3344 source = GTK_PIZZA(m_wxwindow)->bin_window;
3345 else
3346 source = m_widget->window;
3347
3348 int org_x = 0;
3349 int org_y = 0;
3350 gdk_window_get_origin( source, &org_x, &org_y );
3351
3352 if (!m_wxwindow)
3353 {
3354 if (GTK_WIDGET_NO_WINDOW (m_widget))
3355 {
3356 org_x += m_widget->allocation.x;
3357 org_y += m_widget->allocation.y;
3358 }
3359 }
3360
3361 if (x) *x -= org_x;
3362 if (y) *y -= org_y;
3363}
3364
3365bool wxWindowGTK::Show( bool show )
3366{
3367 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3368
3369 if (!wxWindowBase::Show(show))
3370 {
3371 // nothing to do
3372 return FALSE;
3373 }
3374
3375 if (show)
3376 gtk_widget_show( m_widget );
3377 else
3378 gtk_widget_hide( m_widget );
3379
3380 wxShowEvent eventShow(GetId(), show);
3381 eventShow.m_eventObject = this;
3382
3383 GetEventHandler()->ProcessEvent(eventShow);
3384
3385 return TRUE;
3386}
3387
3388static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
3389{
3390 win->OnParentEnable(enable);
3391
3392 // Recurse, so that children have the opportunity to Do The Right Thing
3393 // and reset colours that have been messed up by a parent's (really ancestor's)
3394 // Enable call
3395 for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
3396 node;
3397 node = node->GetNext() )
3398 {
3399 wxWindow *child = node->GetData();
3400 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3401 wxWindowNotifyEnable(child, enable);
3402 }
3403}
3404
3405bool wxWindowGTK::Enable( bool enable )
3406{
3407 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3408
3409 if (!wxWindowBase::Enable(enable))
3410 {
3411 // nothing to do
3412 return FALSE;
3413 }
3414
3415 gtk_widget_set_sensitive( m_widget, enable );
3416 if ( m_wxwindow )
3417 gtk_widget_set_sensitive( m_wxwindow, enable );
3418
3419 wxWindowNotifyEnable(this, enable);
3420
3421 return TRUE;
3422}
3423
3424int wxWindowGTK::GetCharHeight() const
3425{
3426 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3427
3428 wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
3429
3430#ifdef __WXGTK20__
3431 PangoContext *context = NULL;
3432 if (m_widget)
3433 context = gtk_widget_get_pango_context( m_widget );
3434
3435 if (!context)
3436 return 0;
3437
3438 PangoFontDescription *desc = m_font.GetNativeFontInfo()->description;
3439 PangoLayout *layout = pango_layout_new(context);
3440 pango_layout_set_font_description(layout, desc);
3441 pango_layout_set_text(layout, "H", 1);
3442 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3443
3444 PangoRectangle rect;
3445 pango_layout_line_get_extents(line, NULL, &rect);
3446
3447 g_object_unref( G_OBJECT( layout ) );
3448
3449 return (int) (rect.height / PANGO_SCALE);
3450#else
3451 GdkFont *font = m_font.GetInternalFont( 1.0 );
3452
3453 return font->ascent + font->descent;
3454#endif
3455}
3456
3457int wxWindowGTK::GetCharWidth() const
3458{
3459 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3460
3461 wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
3462
3463#ifdef __WXGTK20__
3464 PangoContext *context = NULL;
3465 if (m_widget)
3466 context = gtk_widget_get_pango_context( m_widget );
3467
3468 if (!context)
3469 return 0;
3470
3471 PangoFontDescription *desc = m_font.GetNativeFontInfo()->description;
3472 PangoLayout *layout = pango_layout_new(context);
3473 pango_layout_set_font_description(layout, desc);
3474 pango_layout_set_text(layout, "g", 1);
3475 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3476
3477 PangoRectangle rect;
3478 pango_layout_line_get_extents(line, NULL, &rect);
3479
3480 g_object_unref( G_OBJECT( layout ) );
3481
3482 return (int) (rect.width / PANGO_SCALE);
3483#else
3484 GdkFont *font = m_font.GetInternalFont( 1.0 );
3485
3486 return gdk_string_width( font, "g" );
3487#endif
3488}
3489
3490void wxWindowGTK::GetTextExtent( const wxString& string,
3491 int *x,
3492 int *y,
3493 int *descent,
3494 int *externalLeading,
3495 const wxFont *theFont ) const
3496{
3497 wxFont fontToUse = m_font;
3498 if (theFont) fontToUse = *theFont;
3499
3500 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3501
3502 if (string.IsEmpty())
3503 {
3504 if (x) (*x) = 0;
3505 if (y) (*y) = 0;
3506 return;
3507 }
3508
3509#ifdef __WXGTK20__
3510 PangoContext *context = NULL;
3511 if (m_widget)
3512 context = gtk_widget_get_pango_context( m_widget );
3513
3514 if (!context)
3515 {
3516 if (x) (*x) = 0;
3517 if (y) (*y) = 0;
3518 return;
3519 }
3520
3521 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3522 PangoLayout *layout = pango_layout_new(context);
3523 pango_layout_set_font_description(layout, desc);
3524 {
3525#if wxUSE_UNICODE
3526 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
3527 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3528#else
3529 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
3530 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
3531 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3532#endif
3533 }
3534 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3535
3536 PangoRectangle rect;
3537 pango_layout_line_get_extents(line, NULL, &rect);
3538
3539 if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
3540 if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
3541 if (descent)
3542 {
3543 // Do something about metrics here
3544 (*descent) = 0;
3545 }
3546 if (externalLeading) (*externalLeading) = 0; // ??
3547
3548 g_object_unref( G_OBJECT( layout ) );
3549#else
3550 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
3551 if (x) (*x) = gdk_string_width( font, wxGTK_CONV( string ) );
3552 if (y) (*y) = font->ascent + font->descent;
3553 if (descent) (*descent) = font->descent;
3554 if (externalLeading) (*externalLeading) = 0; // ??
3555#endif
3556}
3557
3558void wxWindowGTK::SetFocus()
3559{
3560 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3561
3562 if ( m_hasFocus )
3563 {
3564 // don't do anything if we already have focus
3565 return;
3566 }
3567
3568 if (m_wxwindow)
3569 {
3570 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3571 {
3572 gtk_widget_grab_focus (m_wxwindow);
3573 }
3574 }
3575 else if (m_widget)
3576 {
3577 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3578 {
3579 if (!GTK_WIDGET_REALIZED(m_widget))
3580 {
3581 // we can't set the focus to the widget now so we remember that
3582 // it should be focused and will do it later, during the idle
3583 // time, as soon as we can
3584 wxLogTrace(TRACE_FOCUS,
3585 _T("Delaying setting focus to %s(%s)"),
3586 GetClassInfo()->GetClassName(), GetLabel().c_str());
3587
3588 g_delayedFocus = this;
3589 }
3590 else
3591 {
3592 wxLogTrace(TRACE_FOCUS,
3593 _T("Setting focus to %s(%s)"),
3594 GetClassInfo()->GetClassName(), GetLabel().c_str());
3595
3596 gtk_widget_grab_focus (m_widget);
3597 }
3598 }
3599 else if (GTK_IS_CONTAINER(m_widget))
3600 {
3601 SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );
3602 }
3603 else
3604 {
3605 wxLogTrace(TRACE_FOCUS,
3606 _T("Can't set focus to %s(%s)"),
3607 GetClassInfo()->GetClassName(), GetLabel().c_str());
3608 }
3609 }
3610}
3611
3612bool wxWindowGTK::AcceptsFocus() const
3613{
3614 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
3615}
3616
3617bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3618{
3619 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3620
3621 wxWindowGTK *oldParent = m_parent,
3622 *newParent = (wxWindowGTK *)newParentBase;
3623
3624 wxASSERT( GTK_IS_WIDGET(m_widget) );
3625
3626 if ( !wxWindowBase::Reparent(newParent) )
3627 return FALSE;
3628
3629 wxASSERT( GTK_IS_WIDGET(m_widget) );
3630
3631 /* prevent GTK from deleting the widget arbitrarily */
3632 gtk_widget_ref( m_widget );
3633
3634 if (oldParent)
3635 {
3636 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3637 }
3638
3639 wxASSERT( GTK_IS_WIDGET(m_widget) );
3640
3641 if (newParent)
3642 {
3643 /* insert GTK representation */
3644 (*(newParent->m_insertCallback))(newParent, this);
3645 }
3646
3647 /* reverse: prevent GTK from deleting the widget arbitrarily */
3648 gtk_widget_unref( m_widget );
3649
3650 return TRUE;
3651}
3652
3653void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3654{
3655 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3656
3657 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3658
3659 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3660
3661 /* add to list */
3662 AddChild( child );
3663
3664 /* insert GTK representation */
3665 (*m_insertCallback)(this, child);
3666}
3667
3668void wxWindowGTK::Raise()
3669{
3670 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3671
3672 if (!m_widget->window) return;
3673
3674 gdk_window_raise( m_widget->window );
3675}
3676
3677void wxWindowGTK::Lower()
3678{
3679 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3680
3681 if (!m_widget->window) return;
3682
3683 gdk_window_lower( m_widget->window );
3684}
3685
3686bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3687{
3688 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3689
3690 if (cursor == m_cursor)
3691 return FALSE;
3692
3693 if (g_isIdle)
3694 wxapp_install_idle_handler();
3695
3696 if (cursor == wxNullCursor)
3697 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3698 else
3699 return wxWindowBase::SetCursor( cursor );
3700}
3701
3702void wxWindowGTK::WarpPointer( int x, int y )
3703{
3704 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3705
3706 // We provide this function ourselves as it is
3707 // missing in GDK (top of this file).
3708
3709 GdkWindow *window = (GdkWindow*) NULL;
3710 if (m_wxwindow)
3711 window = GTK_PIZZA(m_wxwindow)->bin_window;
3712 else
3713 window = GetConnectWidget()->window;
3714
3715 if (window)
3716 gdk_window_warp_pointer( window, x, y );
3717}
3718
3719
3720void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3721{
3722 if (!m_widget) return;
3723 if (!m_widget->window) return;
3724
3725#ifndef __WXGTK20__
3726 if (g_isIdle)
3727 wxapp_install_idle_handler();
3728
3729 wxRect myRect(0,0,0,0);
3730 if (m_wxwindow && rect)
3731 {
3732 myRect.SetSize(wxSize( m_wxwindow->allocation.width,
3733 m_wxwindow->allocation.height));
3734 myRect.Intersect(*rect);
3735 if (!myRect.width || !myRect.height)
3736 // nothing to do, rectangle is empty
3737 return;
3738 rect = &myRect;
3739 }
3740
3741 if (eraseBackground && m_wxwindow && m_wxwindow->window)
3742 {
3743 if (rect)
3744 {
3745 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3746 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
3747 }
3748 else
3749 {
3750 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3751 m_clearRegion.Clear();
3752 m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3753 }
3754 }
3755
3756 if (rect)
3757 {
3758 if (m_wxwindow)
3759 {
3760 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3761 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
3762 }
3763 else
3764 {
3765 GdkRectangle gdk_rect;
3766 gdk_rect.x = rect->x;
3767 gdk_rect.y = rect->y;
3768 gdk_rect.width = rect->width;
3769 gdk_rect.height = rect->height;
3770 gtk_widget_draw( m_widget, &gdk_rect );
3771 }
3772 }
3773 else
3774 {
3775 if (m_wxwindow)
3776 {
3777 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3778 m_updateRegion.Clear();
3779 m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3780 }
3781 else
3782 {
3783 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
3784 }
3785 }
3786#else
3787 if (m_wxwindow)
3788 {
3789 if (rect)
3790 {
3791 GdkRectangle gdk_rect;
3792 gdk_rect.x = rect->x;
3793 gdk_rect.y = rect->y;
3794 gdk_rect.width = rect->width;
3795 gdk_rect.height = rect->height;
3796 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
3797 }
3798 else
3799 {
3800 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
3801 }
3802 }
3803#endif
3804}
3805
3806void wxWindowGTK::Update()
3807{
3808 GtkUpdate();
3809}
3810
3811void wxWindowGTK::GtkUpdate()
3812{
3813#ifdef __WXGTK20__
3814 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3815 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
3816#else
3817 if (!m_updateRegion.IsEmpty())
3818 GtkSendPaintEvents();
3819#endif
3820}
3821
3822void wxWindowGTK::GtkSendPaintEvents()
3823{
3824 if (!m_wxwindow)
3825 {
3826#ifndef __WXGTK20__
3827 m_clearRegion.Clear();
3828#endif
3829 m_updateRegion.Clear();
3830 return;
3831 }
3832
3833 // Clip to paint region in wxClientDC
3834 m_clipPaintRegion = TRUE;
3835
3836#ifndef __WXGTK20__
3837 // widget to draw on
3838 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
3839
3840 // later for GTK 2.0, too.
3841 if (GetThemeEnabled())
3842 {
3843 // find ancestor from which to steal background
3844 wxWindow *parent = GetParent();
3845 while (parent && !parent->IsTopLevel())
3846 parent = parent->GetParent();
3847 if (!parent)
3848 parent = (wxWindow*)this;
3849
3850 wxRegionIterator upd( m_updateRegion );
3851 while (upd)
3852 {
3853 GdkRectangle rect;
3854 rect.x = upd.GetX();
3855 rect.y = upd.GetY();
3856 rect.width = upd.GetWidth();
3857 rect.height = upd.GetHeight();
3858
3859 gtk_paint_flat_box( parent->m_widget->style,
3860 pizza->bin_window,
3861 GTK_STATE_NORMAL,
3862 GTK_SHADOW_NONE,
3863 &rect,
3864 parent->m_widget,
3865 (char *)"base",
3866 0, 0, -1, -1 );
3867
3868 upd ++;
3869 }
3870 }
3871 else
3872#endif
3873
3874#ifdef __WXGTK20__
3875 {
3876 wxWindowDC dc( (wxWindow*)this );
3877 dc.SetClippingRegion( m_updateRegion );
3878
3879 wxEraseEvent erase_event( GetId(), &dc );
3880 erase_event.SetEventObject( this );
3881
3882 GetEventHandler()->ProcessEvent(erase_event);
3883 }
3884#else
3885 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
3886 {
3887 wxWindowDC dc( (wxWindow*)this );
3888 if (m_clearRegion.IsEmpty())
3889 dc.SetClippingRegion( m_updateRegion );
3890 else
3891 dc.SetClippingRegion( m_clearRegion );
3892
3893 wxEraseEvent erase_event( GetId(), &dc );
3894 erase_event.SetEventObject( this );
3895
3896 if (!GetEventHandler()->ProcessEvent(erase_event))
3897 {
3898 if (!g_eraseGC)
3899 {
3900 g_eraseGC = gdk_gc_new( pizza->bin_window );
3901 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
3902 }
3903 gdk_gc_set_foreground( g_eraseGC, m_backgroundColour.GetColor() );
3904
3905 wxRegionIterator upd( m_clearRegion );
3906 while (upd)
3907 {
3908 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
3909 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
3910 upd ++;
3911 }
3912 }
3913 m_clearRegion.Clear();
3914 }
3915#endif
3916
3917 wxNcPaintEvent nc_paint_event( GetId() );
3918 nc_paint_event.SetEventObject( this );
3919 GetEventHandler()->ProcessEvent( nc_paint_event );
3920
3921 wxPaintEvent paint_event( GetId() );
3922 paint_event.SetEventObject( this );
3923 GetEventHandler()->ProcessEvent( paint_event );
3924
3925 m_clipPaintRegion = FALSE;
3926
3927#ifndef __WXUNIVERSAL__
3928#ifndef __WXGTK20__
3929 // The following code will result in all window-less widgets
3930 // being redrawn because the wxWindows class is allowed to
3931 // paint over the window-less widgets.
3932
3933 GList *children = pizza->children;
3934 while (children)
3935 {
3936 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
3937 children = children->next;
3938
3939 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
3940 GTK_WIDGET_DRAWABLE (child->widget))
3941 {
3942 // Get intersection of widget area and update region
3943 wxRegion region( m_updateRegion );
3944
3945 GdkEventExpose gdk_event;
3946 gdk_event.type = GDK_EXPOSE;
3947 gdk_event.window = pizza->bin_window;
3948 gdk_event.count = 0;
3949
3950 wxRegionIterator upd( m_updateRegion );
3951 while (upd)
3952 {
3953 GdkRectangle rect;
3954 rect.x = upd.GetX();
3955 rect.y = upd.GetY();
3956 rect.width = upd.GetWidth();
3957 rect.height = upd.GetHeight();
3958
3959 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
3960 {
3961 gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
3962 }
3963
3964 upd ++;
3965 }
3966 }
3967 }
3968#endif
3969#endif
3970
3971 m_updateRegion.Clear();
3972}
3973
3974void wxWindowGTK::ClearBackground()
3975{
3976 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3977
3978#ifndef __WXGTK20__
3979 if (m_wxwindow && m_wxwindow->window)
3980 {
3981 m_clearRegion.Clear();
3982 wxSize size( GetClientSize() );
3983 m_clearRegion.Union( 0,0,size.x,size.y );
3984
3985 // Better do this in idle?
3986 GtkUpdate();
3987 }
3988#endif
3989}
3990
3991#if wxUSE_TOOLTIPS
3992void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3993{
3994 wxWindowBase::DoSetToolTip(tip);
3995
3996 if (m_tooltip)
3997 m_tooltip->Apply( (wxWindow *)this );
3998}
3999
4000void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
4001{
4002 wxString tmp( tip );
4003 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );
4004}
4005#endif // wxUSE_TOOLTIPS
4006
4007void wxWindowGTK::GtkSetBackgroundColour( const wxColour &colour )
4008{
4009 GdkWindow *window = (GdkWindow*) NULL;
4010 if (m_wxwindow)
4011 window = GTK_PIZZA(m_wxwindow)->bin_window;
4012 else
4013 window = GetConnectWidget()->window;
4014
4015 wxASSERT( window );
4016
4017 // We need the pixel value e.g. for background clearing.
4018 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
4019
4020 if (m_wxwindow)
4021 {
4022 // wxMSW doesn't clear the window here, either.
4023 gdk_window_set_background( window, m_backgroundColour.GetColor() );
4024 }
4025
4026 ApplyWidgetStyle();
4027}
4028
4029bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
4030{
4031 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4032
4033 if (!wxWindowBase::SetBackgroundColour(colour))
4034 return FALSE;
4035
4036 GdkWindow *window = (GdkWindow*) NULL;
4037 if (m_wxwindow)
4038 window = GTK_PIZZA(m_wxwindow)->bin_window;
4039 else
4040 window = GetConnectWidget()->window;
4041
4042 if (!window)
4043 {
4044 // indicate that a new style has been set
4045 // but it couldn't get applied as the
4046 // widget hasn't been realized yet.
4047 m_delayedBackgroundColour = TRUE;
4048 return TRUE;
4049 }
4050 else
4051 {
4052 GtkSetBackgroundColour( colour );
4053 }
4054
4055 return TRUE;
4056}
4057
4058void wxWindowGTK::GtkSetForegroundColour( const wxColour &colour )
4059{
4060 GdkWindow *window = (GdkWindow*) NULL;
4061 if (m_wxwindow)
4062 window = GTK_PIZZA(m_wxwindow)->bin_window;
4063 else
4064 window = GetConnectWidget()->window;
4065
4066 wxASSERT( window );
4067
4068 ApplyWidgetStyle();
4069}
4070
4071bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
4072{
4073 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4074
4075 if (!wxWindowBase::SetForegroundColour(colour))
4076 {
4077 // don't leave if the GTK widget has just
4078 // been realized
4079 if (!m_delayedForegroundColour) return FALSE;
4080 }
4081
4082 GdkWindow *window = (GdkWindow*) NULL;
4083 if (m_wxwindow)
4084 window = GTK_PIZZA(m_wxwindow)->bin_window;
4085 else
4086 window = GetConnectWidget()->window;
4087
4088 if (!window)
4089 {
4090 // indicate that a new style has been set
4091 // but it couldn't get applied as the
4092 // widget hasn't been realized yet.
4093 m_delayedForegroundColour = TRUE;
4094 }
4095 else
4096 {
4097 GtkSetForegroundColour( colour );
4098 }
4099
4100 return TRUE;
4101}
4102
4103#ifdef __WXGTK20__
4104PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
4105{
4106 return gtk_widget_get_pango_context( m_widget );
4107}
4108
4109PangoContext *wxWindowGTK::GtkGetPangoX11Context()
4110{
4111 if (!m_x11Context)
4112 m_x11Context = pango_x_get_context( gdk_display );
4113
4114 return m_x11Context;
4115}
4116#endif
4117
4118GtkStyle *wxWindowGTK::GetWidgetStyle()
4119{
4120 if (m_widgetStyle)
4121 {
4122 GtkStyle *remake = gtk_style_copy( m_widgetStyle );
4123
4124 // FIXME: no more klass in 2.0
4125#ifndef __WXGTK20__
4126 remake->klass = m_widgetStyle->klass;
4127#endif
4128
4129 gtk_style_unref( m_widgetStyle );
4130 m_widgetStyle = remake;
4131 }
4132 else
4133 {
4134 GtkStyle *def = gtk_rc_get_style( m_widget );
4135
4136 if (!def)
4137 def = gtk_widget_get_default_style();
4138
4139 m_widgetStyle = gtk_style_copy( def );
4140
4141 // FIXME: no more klass in 2.0
4142#ifndef __WXGTK20__
4143 m_widgetStyle->klass = def->klass;
4144#endif
4145 }
4146
4147 return m_widgetStyle;
4148}
4149
4150void wxWindowGTK::SetWidgetStyle()
4151{
4152#if DISABLE_STYLE_IF_BROKEN_THEME
4153 if (m_widget->style->engine_data)
4154 {
4155 static bool s_warningPrinted = FALSE;
4156 if (!s_warningPrinted)
4157 {
4158 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
4159 s_warningPrinted = TRUE;
4160 }
4161 m_widgetStyle = m_widget->style;
4162 return;
4163 }
4164#endif
4165
4166 GtkStyle *style = GetWidgetStyle();
4167
4168 if (m_font != wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ))
4169 {
4170#ifdef __WXGTK20__
4171 pango_font_description_free( style->font_desc );
4172 style->font_desc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
4173#else
4174 gdk_font_unref( style->font );
4175 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
4176#endif
4177 }
4178
4179 if (m_foregroundColour.Ok())
4180 {
4181 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
4182 if (m_foregroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT))
4183 {
4184 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
4185 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
4186 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
4187 }
4188 else
4189 {
4190 // Try to restore the gtk default style. This is still a little
4191 // oversimplified for what is probably really needed here for controls
4192 // other than buttons, but is better than not being able to (re)set a
4193 // control's foreground colour to *wxBLACK -- RL
4194 GtkStyle *def = gtk_rc_get_style( m_widget );
4195
4196 if (!def)
4197 def = gtk_widget_get_default_style();
4198
4199 style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
4200 style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
4201 style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
4202 }
4203 }
4204
4205 if (m_backgroundColour.Ok())
4206 {
4207 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
4208 if (m_backgroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE))
4209 {
4210 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4211 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4212 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4213 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4214 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4215 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4216 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
4217 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
4218 }
4219 else
4220 {
4221 // Try to restore the gtk default style. This is still a little
4222 // oversimplified for what is probably really needed here for controls
4223 // other than buttons, but is better than not being able to (re)set a
4224 // control's background colour to default grey and means resetting a
4225 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
4226 // behavior -- RL
4227 GtkStyle *def = gtk_rc_get_style( m_widget );
4228
4229 if (!def)
4230 def = gtk_widget_get_default_style();
4231
4232 style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
4233 style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
4234 style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
4235 style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
4236 style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
4237 style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
4238 style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
4239 style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
4240 }
4241 }
4242}
4243
4244void wxWindowGTK::ApplyWidgetStyle()
4245{
4246}
4247
4248//-----------------------------------------------------------------------------
4249// Pop-up menu stuff
4250//-----------------------------------------------------------------------------
4251
4252#if wxUSE_MENUS_NATIVE
4253
4254extern "C"
4255void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
4256{
4257 *is_waiting = FALSE;
4258}
4259
4260static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
4261{
4262 menu->SetInvokingWindow( win );
4263 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
4264 while (node)
4265 {
4266 wxMenuItem *menuitem = node->GetData();
4267 if (menuitem->IsSubMenu())
4268 {
4269 SetInvokingWindow( menuitem->GetSubMenu(), win );
4270 }
4271
4272 node = node->GetNext();
4273 }
4274}
4275
4276// used to pass the coordinates from wxWindowGTK::DoPopupMenu() to
4277// wxPopupMenuPositionCallback()
4278//
4279// should be safe even in the MT case as the user can hardly popup 2 menus
4280// simultaneously, can he?
4281static gint gs_pop_x = 0;
4282static gint gs_pop_y = 0;
4283
4284extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
4285 gint *x, gint *y,
4286#ifdef __WXGTK20__
4287 gboolean * WXUNUSED(whatever),
4288#endif
4289 gpointer WXUNUSED(user_data) )
4290{
4291 // ensure that the menu appears entirely on screen
4292 GtkRequisition req;
4293 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4294
4295 wxSize sizeScreen = wxGetDisplaySize();
4296
4297 gint xmax = sizeScreen.x - req.width,
4298 ymax = sizeScreen.y - req.height;
4299
4300 *x = gs_pop_x < xmax ? gs_pop_x : xmax;
4301 *y = gs_pop_y < ymax ? gs_pop_y : ymax;
4302}
4303
4304bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4305{
4306 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4307
4308 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
4309
4310 SetInvokingWindow( menu, this );
4311
4312 menu->UpdateUI();
4313
4314 gs_pop_x = x;
4315 gs_pop_y = y;
4316 ClientToScreen( &gs_pop_x, &gs_pop_y );
4317
4318 bool is_waiting = TRUE;
4319
4320 gtk_signal_connect( GTK_OBJECT(menu->m_menu),
4321 "hide",
4322 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
4323 (gpointer)&is_waiting );
4324
4325 gtk_menu_popup(
4326 GTK_MENU(menu->m_menu),
4327 (GtkWidget *) NULL, // parent menu shell
4328 (GtkWidget *) NULL, // parent menu item
4329 wxPopupMenuPositionCallback, // function to position it
4330 NULL, // client data
4331 0, // button used to activate it
4332#ifdef __WXGTK20__
4333 gtk_get_current_event_time()
4334#else
4335 gs_timeLastClick // the time of activation
4336#endif
4337 );
4338
4339 while (is_waiting)
4340 {
4341 gtk_main_iteration();
4342 }
4343
4344 return TRUE;
4345}
4346
4347#endif // wxUSE_MENUS_NATIVE
4348
4349#if wxUSE_DRAG_AND_DROP
4350
4351void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4352{
4353 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4354
4355 GtkWidget *dnd_widget = GetConnectWidget();
4356
4357 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
4358
4359 if (m_dropTarget) delete m_dropTarget;
4360 m_dropTarget = dropTarget;
4361
4362 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
4363}
4364
4365#endif // wxUSE_DRAG_AND_DROP
4366
4367GtkWidget* wxWindowGTK::GetConnectWidget()
4368{
4369 GtkWidget *connect_widget = m_widget;
4370 if (m_wxwindow) connect_widget = m_wxwindow;
4371
4372 return connect_widget;
4373}
4374
4375bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
4376{
4377 if (m_wxwindow)
4378 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
4379
4380 return (window == m_widget->window);
4381}
4382
4383bool wxWindowGTK::SetFont( const wxFont &font )
4384{
4385 if (!wxWindowBase::SetFont(font) || !m_widget)
4386 {
4387 return FALSE;
4388 }
4389
4390 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
4391 if ( sysbg == m_backgroundColour )
4392 {
4393 m_backgroundColour = wxNullColour;
4394 ApplyWidgetStyle();
4395 m_backgroundColour = sysbg;
4396 }
4397 else
4398 {
4399 ApplyWidgetStyle();
4400 }
4401
4402 return TRUE;
4403}
4404
4405void wxWindowGTK::DoCaptureMouse()
4406{
4407 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4408
4409 GdkWindow *window = (GdkWindow*) NULL;
4410 if (m_wxwindow)
4411 window = GTK_PIZZA(m_wxwindow)->bin_window;
4412 else
4413 window = GetConnectWidget()->window;
4414
4415 wxCHECK_RET( window, _T("CaptureMouse() failed") );
4416
4417 wxCursor* cursor = & m_cursor;
4418 if (!cursor->Ok())
4419 cursor = wxSTANDARD_CURSOR;
4420
4421 gdk_pointer_grab( window, FALSE,
4422 (GdkEventMask)
4423 (GDK_BUTTON_PRESS_MASK |
4424 GDK_BUTTON_RELEASE_MASK |
4425 GDK_POINTER_MOTION_HINT_MASK |
4426 GDK_POINTER_MOTION_MASK),
4427 (GdkWindow *) NULL,
4428 cursor->GetCursor(),
4429 (guint32)GDK_CURRENT_TIME );
4430 g_captureWindow = this;
4431 g_captureWindowHasMouse = TRUE;
4432}
4433
4434void wxWindowGTK::DoReleaseMouse()
4435{
4436 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4437
4438 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4439
4440 g_captureWindow = (wxWindowGTK*) NULL;
4441
4442 GdkWindow *window = (GdkWindow*) NULL;
4443 if (m_wxwindow)
4444 window = GTK_PIZZA(m_wxwindow)->bin_window;
4445 else
4446 window = GetConnectWidget()->window;
4447
4448 if (!window)
4449 return;
4450
4451 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4452}
4453
4454/* static */
4455wxWindow *wxWindowBase::GetCapture()
4456{
4457 return (wxWindow *)g_captureWindow;
4458}
4459
4460bool wxWindowGTK::IsRetained() const
4461{
4462 return FALSE;
4463}
4464
4465void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
4466 int range, bool refresh )
4467{
4468 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4469
4470 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4471
4472 m_hasScrolling = TRUE;
4473
4474 if (orient == wxHORIZONTAL)
4475 {
4476 float fpos = (float)pos;
4477 float frange = (float)range;
4478 float fthumb = (float)thumbVisible;
4479 if (fpos > frange-fthumb) fpos = frange-fthumb;
4480 if (fpos < 0.0) fpos = 0.0;
4481
4482 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
4483 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
4484 {
4485 SetScrollPos( orient, pos, refresh );
4486 return;
4487 }
4488
4489 m_oldHorizontalPos = fpos;
4490
4491 m_hAdjust->lower = 0.0;
4492 m_hAdjust->upper = frange;
4493 m_hAdjust->value = fpos;
4494 m_hAdjust->step_increment = 1.0;
4495 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
4496 m_hAdjust->page_size = fthumb;
4497 }
4498 else
4499 {
4500 float fpos = (float)pos;
4501 float frange = (float)range;
4502 float fthumb = (float)thumbVisible;
4503 if (fpos > frange-fthumb) fpos = frange-fthumb;
4504 if (fpos < 0.0) fpos = 0.0;
4505
4506 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4507 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4508 {
4509 SetScrollPos( orient, pos, refresh );
4510 return;
4511 }
4512
4513 m_oldVerticalPos = fpos;
4514
4515 m_vAdjust->lower = 0.0;
4516 m_vAdjust->upper = frange;
4517 m_vAdjust->value = fpos;
4518 m_vAdjust->step_increment = 1.0;
4519 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4520 m_vAdjust->page_size = fthumb;
4521 }
4522
4523 if (orient == wxHORIZONTAL)
4524 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4525 else
4526 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
4527}
4528
4529void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
4530{
4531 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4532
4533 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4534
4535 if (orient == wxHORIZONTAL)
4536 {
4537 float fpos = (float)pos;
4538 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
4539 if (fpos < 0.0) fpos = 0.0;
4540 m_oldHorizontalPos = fpos;
4541
4542 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
4543 m_hAdjust->value = fpos;
4544 }
4545 else
4546 {
4547 float fpos = (float)pos;
4548 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
4549 if (fpos < 0.0) fpos = 0.0;
4550 m_oldVerticalPos = fpos;
4551
4552 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
4553 m_vAdjust->value = fpos;
4554 }
4555
4556 if (m_wxwindow->window)
4557 {
4558 if (orient == wxHORIZONTAL)
4559 {
4560 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
4561 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4562
4563 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
4564
4565 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
4566 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4567 }
4568 else
4569 {
4570 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
4571 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4572
4573 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
4574
4575 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
4576 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4577 }
4578 }
4579}
4580
4581int wxWindowGTK::GetScrollThumb( int orient ) const
4582{
4583 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4584
4585 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4586
4587 if (orient == wxHORIZONTAL)
4588 return (int)(m_hAdjust->page_size+0.5);
4589 else
4590 return (int)(m_vAdjust->page_size+0.5);
4591}
4592
4593int wxWindowGTK::GetScrollPos( int orient ) const
4594{
4595 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4596
4597 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4598
4599 if (orient == wxHORIZONTAL)
4600 return (int)(m_hAdjust->value+0.5);
4601 else
4602 return (int)(m_vAdjust->value+0.5);
4603}
4604
4605int wxWindowGTK::GetScrollRange( int orient ) const
4606{
4607 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4608
4609 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4610
4611 if (orient == wxHORIZONTAL)
4612 return (int)(m_hAdjust->upper+0.5);
4613 else
4614 return (int)(m_vAdjust->upper+0.5);
4615}
4616
4617void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4618{
4619 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4620
4621 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4622
4623 // No scrolling requested.
4624 if ((dx == 0) && (dy == 0)) return;
4625
4626#ifndef __WXGTK20__
4627 if (!m_updateRegion.IsEmpty())
4628 {
4629 m_updateRegion.Offset( dx, dy );
4630
4631 int cw = 0;
4632 int ch = 0;
4633 GetClientSize( &cw, &ch );
4634 m_updateRegion.Intersect( 0, 0, cw, ch );
4635 }
4636
4637 if (!m_clearRegion.IsEmpty())
4638 {
4639 m_clearRegion.Offset( dx, dy );
4640
4641 int cw = 0;
4642 int ch = 0;
4643 GetClientSize( &cw, &ch );
4644 m_clearRegion.Intersect( 0, 0, cw, ch );
4645 }
4646#endif
4647
4648 m_clipPaintRegion = TRUE;
4649
4650 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
4651
4652 m_clipPaintRegion = FALSE;
4653}
4654
4655
4656// Find the wxWindow at the current mouse position, also returning the mouse
4657// position.
4658wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4659{
4660 pt = wxGetMousePosition();
4661 wxWindow* found = wxFindWindowAtPoint(pt);
4662 return found;
4663}
4664
4665// Get the current mouse position.
4666wxPoint wxGetMousePosition()
4667{
4668 /* This crashes when used within wxHelpContext,
4669 so we have to use the X-specific implementation below.
4670 gint x, y;
4671 GdkModifierType *mask;
4672 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4673
4674 return wxPoint(x, y);
4675 */
4676
4677 int x, y;
4678 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4679
4680 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4681 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4682 Window rootReturn, childReturn;
4683 int rootX, rootY, winX, winY;
4684 unsigned int maskReturn;
4685
4686 XQueryPointer (display,
4687 rootWindow,
4688 &rootReturn,
4689 &childReturn,
4690 &rootX, &rootY, &winX, &winY, &maskReturn);
4691 return wxPoint(rootX, rootY);
4692
4693}
4694
4695// ----------------------------------------------------------------------------
4696// wxDCModule
4697// ----------------------------------------------------------------------------
4698
4699class wxWinModule : public wxModule
4700{
4701public:
4702 bool OnInit();
4703 void OnExit();
4704
4705private:
4706 DECLARE_DYNAMIC_CLASS(wxWinModule)
4707};
4708
4709IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4710
4711bool wxWinModule::OnInit()
4712{
4713 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4714 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4715
4716 return TRUE;
4717}
4718
4719void wxWinModule::OnExit()
4720{
4721 if (g_eraseGC)
4722 gdk_gc_unref( g_eraseGC );
4723}
4724
4725// vi:sts=4:sw=4:et
wxWidgets (Impactor)