]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/window.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
don't call CopyBeforeWrite when returning non-const interator if the string is empty...
[wxWidgets.git] / src / gtk1 / window.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: gtk/window.cpp
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling, Julian Smart
7// Licence: wxWindows licence
8/////////////////////////////////////////////////////////////////////////////
9
10
11#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
12 #pragma implementation "window.h"
13#endif
14
15// For compilers that support precompilation, includes "wx.h".
16#include "wx/wxprec.h"
17
18#ifdef __VMS
19#define XWarpPointer XWARPPOINTER
20#endif
21
22#include "wx/window.h"
23#include "wx/dcclient.h"
24#include "wx/frame.h"
25#include "wx/app.h"
26#include "wx/layout.h"
27#include "wx/utils.h"
28#include "wx/dialog.h"
29#include "wx/msgdlg.h"
30#include "wx/module.h"
31
32#if wxUSE_DRAG_AND_DROP
33 #include "wx/dnd.h"
34#endif
35
36#if wxUSE_TOOLTIPS
37 #include "wx/tooltip.h"
38#endif
39
40#if wxUSE_CARET
41 #include "wx/caret.h"
42#endif // wxUSE_CARET
43
44#if wxUSE_TEXTCTRL
45 #include "wx/textctrl.h"
46#endif
47
48#include "wx/menu.h"
49#include "wx/statusbr.h"
50#include "wx/intl.h"
51#include "wx/settings.h"
52#include "wx/log.h"
53#include "wx/fontutil.h"
54
55#ifdef __WXDEBUG__
56 #include "wx/thread.h"
57#endif
58
59#include <math.h>
60#include <ctype.h>
61
62#include "wx/gtk/private.h"
63#include <gdk/gdkprivate.h>
64#include <gdk/gdkkeysyms.h>
65#include <gdk/gdkx.h>
66
67#include <gtk/gtk.h>
68#include <gtk/gtkprivate.h>
69
70#include "wx/gtk/win_gtk.h"
71
72#ifdef __WXGTK20__
73#include <pango/pangox.h>
74#endif
75
76#ifdef __WXGTK20__
77 #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d))
78#else
79 #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d))
80#endif
81
82#ifdef __WXGTK20__
83 #ifdef HAVE_XIM
84 #undef HAVE_XIM
85 #endif
86#endif
87
88#ifdef __WXGTK20__
89extern GtkContainerClass *pizza_parent_class;
90#endif
91
92//-----------------------------------------------------------------------------
93// documentation on internals
94//-----------------------------------------------------------------------------
95
96/*
97 I have been asked several times about writing some documentation about
98 the GTK port of wxWidgets, 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 wxWidgets 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 wxWidgets 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 wxWidgets 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 wxWidgets 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 wxWidgets, 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 wxWidgets 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 wxWidgets 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 wxWidgets from fighting over where the
2692 // slider should be
2693
2694 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
2695 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2696
2697 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
2698 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2699
2700 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
2701 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2702
2703 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
2704 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2705
2706 // these handlers get notified when screen updates are required either when
2707 // scrolling or when the window size (and therefore scrollbar configuration)
2708 // has changed
2709
2710 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2711 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2712 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2713 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2714
2715#ifdef __WXGTK20__
2716 // Create input method handler
2717 m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new ();
2718
2719 // Cannot handle drawing preedited text yet
2720 gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE );
2721
2722 g_signal_connect (G_OBJECT (m_imContext), "commit",
2723 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2724#endif
2725
2726 gtk_widget_show( m_wxwindow );
2727
2728 if (m_parent)
2729 m_parent->DoAddChild( this );
2730
2731 m_focusWidget = m_wxwindow;
2732
2733 PostCreation();
2734
2735 return TRUE;
2736}
2737
2738wxWindowGTK::~wxWindowGTK()
2739{
2740 SendDestroyEvent();
2741
2742 if (g_focusWindow == this)
2743 g_focusWindow = NULL;
2744
2745 if (g_activeFrame == this)
2746 g_activeFrame = NULL;
2747
2748 if ( g_delayedFocus == this )
2749 g_delayedFocus = NULL;
2750
2751 m_isBeingDeleted = TRUE;
2752 m_hasVMT = FALSE;
2753
2754 if (m_widget)
2755 Show( FALSE );
2756
2757 DestroyChildren();
2758
2759#ifdef HAVE_XIM
2760 if (m_ic)
2761 gdk_ic_destroy (m_ic);
2762 if (m_icattr)
2763 gdk_ic_attr_destroy (m_icattr);
2764#endif
2765
2766 if (m_widgetStyle)
2767 {
2768#if DISABLE_STYLE_IF_BROKEN_THEME
2769 // don't delete if it's a pixmap theme style
2770 if (!m_widgetStyle->engine_data)
2771 gtk_style_unref( m_widgetStyle );
2772#endif
2773 m_widgetStyle = (GtkStyle*) NULL;
2774 }
2775
2776 if (m_wxwindow)
2777 {
2778 gtk_widget_destroy( m_wxwindow );
2779 m_wxwindow = (GtkWidget*) NULL;
2780 }
2781
2782 if (m_widget)
2783 {
2784 gtk_widget_destroy( m_widget );
2785 m_widget = (GtkWidget*) NULL;
2786 }
2787}
2788
2789bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2790{
2791 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
2792
2793 // Use either the given size, or the default if -1 is given.
2794 // See wxWindowBase for these functions.
2795 m_width = WidthDefault(size.x) ;
2796 m_height = HeightDefault(size.y);
2797
2798 m_x = (int)pos.x;
2799 m_y = (int)pos.y;
2800
2801 return TRUE;
2802}
2803
2804void wxWindowGTK::PostCreation()
2805{
2806 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2807
2808 if (m_wxwindow)
2809 {
2810 if (!m_noExpose)
2811 {
2812 // these get reported to wxWidgets -> wxPaintEvent
2813
2814 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2815
2816 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2817 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2818
2819#ifndef __WXGTK20__
2820 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2821 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
2822
2823 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
2824 {
2825 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2826 GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2827 }
2828#else
2829 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2830#endif
2831
2832#ifdef __WXGTK20__
2833 // Create input method handler
2834 m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new ();
2835
2836 // Cannot handle drawing preedited text yet
2837 gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE );
2838
2839 g_signal_connect (G_OBJECT (m_imContext), "commit",
2840 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2841#endif
2842 }
2843
2844 // these are called when the "sunken" or "raised" borders are drawn
2845 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2846 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2847
2848#ifndef __WXGTK20__
2849 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2850 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
2851#endif
2852 }
2853
2854 // focus handling
2855
2856 if (m_focusWidget == NULL)
2857 m_focusWidget = m_widget;
2858
2859 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2860 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2861
2862 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
2863 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2864
2865 // connect to the various key and mouse handlers
2866
2867 GtkWidget *connect_widget = GetConnectWidget();
2868
2869 ConnectWidget( connect_widget );
2870
2871 /* We cannot set colours, fonts and cursors before the widget has
2872 been realized, so we do this directly after realization */
2873 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
2874 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2875
2876 if (m_wxwindow)
2877 {
2878 // Catch native resize events
2879 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2880 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2881
2882 // Initialize XIM support
2883 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2884 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
2885
2886 // And resize XIM window
2887 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2888 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
2889 }
2890
2891 if ( !GTK_IS_COMBO(m_widget))
2892 {
2893 // This is needed if we want to add our windows into native
2894 // GTK control, such as the toolbar. With this callback, the
2895 // toolbar gets to know the correct size (the one set by the
2896 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2897 // when moving to GTK 2.0.
2898 gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
2899 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
2900 (gpointer) this );
2901 }
2902
2903 m_hasVMT = TRUE;
2904
2905 // unless the window was created initially hidden (i.e. Hide() had been
2906 // called before Create()), we should show it at GTK+ level as well
2907 if ( IsShown() )
2908 gtk_widget_show( m_widget );
2909}
2910
2911void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2912{
2913 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2914 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
2915
2916 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2917 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2918
2919 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2920 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2921
2922 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2923 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2924
2925 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2926 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2927
2928#ifdef __WXGTK20__
2929 gtk_signal_connect( GTK_OBJECT(widget), "scroll_event",
2930 GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this );
2931#endif
2932
2933 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2934 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2935
2936 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2937 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2938}
2939
2940bool wxWindowGTK::Destroy()
2941{
2942 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2943
2944 m_hasVMT = FALSE;
2945
2946 return wxWindowBase::Destroy();
2947}
2948
2949void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2950{
2951 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2952}
2953
2954void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2955{
2956 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2957 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2958
2959/*
2960 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2961*/
2962
2963 if (m_resizing) return; /* I don't like recursions */
2964 m_resizing = TRUE;
2965
2966 int currentX, currentY;
2967 GetPosition(&currentX, &currentY);
2968 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2969 x = currentX;
2970 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
2971 y = currentY;
2972 AdjustForParentClientOrigin(x, y, sizeFlags);
2973
2974 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
2975 {
2976 /* don't set the size for children of wxNotebook, just take the values. */
2977 m_x = x;
2978 m_y = y;
2979 m_width = width;
2980 m_height = height;
2981 }
2982 else
2983 {
2984 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2985 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2986 {
2987 if (x != -1) m_x = x + pizza->xoffset;
2988 if (y != -1) m_y = y + pizza->yoffset;
2989 }
2990 else
2991 {
2992 m_x = x + pizza->xoffset;
2993 m_y = y + pizza->yoffset;
2994 }
2995
2996 // calculate the best size if we should auto size the window
2997 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
2998 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
2999 {
3000 const wxSize sizeBest = GetBestSize();
3001 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
3002 width = sizeBest.x;
3003 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
3004 height = sizeBest.y;
3005 }
3006
3007 if (width != -1)
3008 m_width = width;
3009 if (height != -1)
3010 m_height = height;
3011
3012 int minWidth = GetMinWidth(),
3013 minHeight = GetMinHeight(),
3014 maxWidth = GetMaxWidth(),
3015 maxHeight = GetMaxHeight();
3016
3017 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
3018 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
3019 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
3020 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
3021
3022 int border = 0;
3023 int bottom_border = 0;
3024
3025#ifndef __WXGTK20__
3026 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
3027 {
3028 /* the default button has a border around it */
3029 border = 6;
3030 bottom_border = 5;
3031 }
3032#endif
3033
3034 DoMoveWindow( m_x-border,
3035 m_y-border,
3036 m_width+2*border,
3037 m_height+border+bottom_border );
3038 }
3039
3040 if (m_hasScrolling)
3041 {
3042 /* Sometimes the client area changes size without the
3043 whole windows's size changing, but if the whole
3044 windows's size doesn't change, no wxSizeEvent will
3045 normally be sent. Here we add an extra test if
3046 the client test has been changed and this will
3047 be used then. */
3048 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
3049 }
3050
3051/*
3052 wxPrintf( "OnSize sent from " );
3053 if (GetClassInfo() && GetClassInfo()->GetClassName())
3054 wxPrintf( GetClassInfo()->GetClassName() );
3055 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3056*/
3057
3058 if (!m_nativeSizeEvent)
3059 {
3060 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
3061 event.SetEventObject( this );
3062 GetEventHandler()->ProcessEvent( event );
3063 }
3064
3065 m_resizing = FALSE;
3066}
3067
3068void wxWindowGTK::OnInternalIdle()
3069{
3070 // Update invalidated regions.
3071 GtkUpdate();
3072
3073 // Synthetize activate events.
3074 if ( g_sendActivateEvent != -1 )
3075 {
3076 bool activate = g_sendActivateEvent != 0;
3077
3078 // do it only once
3079 g_sendActivateEvent = -1;
3080
3081 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
3082 }
3083
3084 if ( g_activeFrameLostFocus )
3085 {
3086 if ( g_activeFrame )
3087 {
3088 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
3089 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
3090 event.SetEventObject(g_activeFrame);
3091 g_activeFrame->GetEventHandler()->ProcessEvent(event);
3092 g_activeFrame = NULL;
3093 }
3094 g_activeFrameLostFocus = FALSE;
3095 }
3096
3097 wxCursor cursor = m_cursor;
3098 if (g_globalCursor.Ok()) cursor = g_globalCursor;
3099
3100 if (cursor.Ok())
3101 {
3102 /* I now set the cursor anew in every OnInternalIdle call
3103 as setting the cursor in a parent window also effects the
3104 windows above so that checking for the current cursor is
3105 not possible. */
3106
3107 if (m_wxwindow)
3108 {
3109 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
3110 if (window)
3111 gdk_window_set_cursor( window, cursor.GetCursor() );
3112
3113 if (!g_globalCursor.Ok())
3114 cursor = *wxSTANDARD_CURSOR;
3115
3116 window = m_widget->window;
3117 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
3118 gdk_window_set_cursor( window, cursor.GetCursor() );
3119
3120 }
3121 else
3122 {
3123
3124 GdkWindow *window = m_widget->window;
3125 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
3126 gdk_window_set_cursor( window, cursor.GetCursor() );
3127
3128 }
3129 }
3130
3131 if (wxUpdateUIEvent::CanUpdate(this))
3132 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
3133}
3134
3135void wxWindowGTK::DoGetSize( int *width, int *height ) const
3136{
3137 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3138
3139 if (width) (*width) = m_width;
3140 if (height) (*height) = m_height;
3141}
3142
3143void wxWindowGTK::DoSetClientSize( int width, int height )
3144{
3145 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3146
3147 if (!m_wxwindow)
3148 {
3149 SetSize( width, height );
3150 }
3151 else
3152 {
3153 int dw = 0;
3154 int dh = 0;
3155
3156#ifndef __WXUNIVERSAL__
3157 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3158 {
3159 /* when using GTK 1.2 we set the shadow border size to 2 */
3160 dw += 2 * 2;
3161 dh += 2 * 2;
3162 }
3163 if (HasFlag(wxSIMPLE_BORDER))
3164 {
3165 /* when using GTK 1.2 we set the simple border size to 1 */
3166 dw += 1 * 2;
3167 dh += 1 * 2;
3168 }
3169#endif // __WXUNIVERSAL__
3170
3171 if (m_hasScrolling)
3172 {
3173 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3174
3175 GtkRequisition vscroll_req;
3176 vscroll_req.width = 2;
3177 vscroll_req.height = 2;
3178 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3179 (scroll_window->vscrollbar, &vscroll_req );
3180
3181 GtkRequisition hscroll_req;
3182 hscroll_req.width = 2;
3183 hscroll_req.height = 2;
3184 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3185 (scroll_window->hscrollbar, &hscroll_req );
3186
3187 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3188
3189 if (scroll_window->vscrollbar_visible)
3190 {
3191 dw += vscroll_req.width;
3192 dw += scroll_class->scrollbar_spacing;
3193 }
3194
3195 if (scroll_window->hscrollbar_visible)
3196 {
3197 dh += hscroll_req.height;
3198 dh += scroll_class->scrollbar_spacing;
3199 }
3200 }
3201
3202 SetSize( width+dw, height+dh );
3203 }
3204}
3205
3206void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
3207{
3208 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3209
3210 if (!m_wxwindow)
3211 {
3212 if (width) (*width) = m_width;
3213 if (height) (*height) = m_height;
3214 }
3215 else
3216 {
3217 int dw = 0;
3218 int dh = 0;
3219
3220#ifndef __WXUNIVERSAL__
3221 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3222 {
3223 /* when using GTK 1.2 we set the shadow border size to 2 */
3224 dw += 2 * 2;
3225 dh += 2 * 2;
3226 }
3227 if (HasFlag(wxSIMPLE_BORDER))
3228 {
3229 /* when using GTK 1.2 we set the simple border size to 1 */
3230 dw += 1 * 2;
3231 dh += 1 * 2;
3232 }
3233#endif // __WXUNIVERSAL__
3234
3235 if (m_hasScrolling)
3236 {
3237 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3238
3239 GtkRequisition vscroll_req;
3240 vscroll_req.width = 2;
3241 vscroll_req.height = 2;
3242 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3243 (scroll_window->vscrollbar, &vscroll_req );
3244
3245 GtkRequisition hscroll_req;
3246 hscroll_req.width = 2;
3247 hscroll_req.height = 2;
3248 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3249 (scroll_window->hscrollbar, &hscroll_req );
3250
3251 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3252
3253 if (scroll_window->vscrollbar_visible)
3254 {
3255 dw += vscroll_req.width;
3256 dw += scroll_class->scrollbar_spacing;
3257 }
3258
3259 if (scroll_window->hscrollbar_visible)
3260 {
3261 dh += hscroll_req.height;
3262 dh += scroll_class->scrollbar_spacing;
3263 }
3264 }
3265
3266 if (width) (*width) = m_width - dw;
3267 if (height) (*height) = m_height - dh;
3268 }
3269
3270/*
3271 printf( "GetClientSize, name %s ", GetName().c_str() );
3272 if (width) printf( " width = %d", (*width) );
3273 if (height) printf( " height = %d", (*height) );
3274 printf( "\n" );
3275*/
3276}
3277
3278void wxWindowGTK::DoGetPosition( int *x, int *y ) const
3279{
3280 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3281
3282 int dx = 0;
3283 int dy = 0;
3284 if (m_parent && m_parent->m_wxwindow)
3285 {
3286 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
3287 dx = pizza->xoffset;
3288 dy = pizza->yoffset;
3289 }
3290
3291 if (x) (*x) = m_x - dx;
3292 if (y) (*y) = m_y - dy;
3293}
3294
3295void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
3296{
3297 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3298
3299 if (!m_widget->window) return;
3300
3301 GdkWindow *source = (GdkWindow *) NULL;
3302 if (m_wxwindow)
3303 source = GTK_PIZZA(m_wxwindow)->bin_window;
3304 else
3305 source = m_widget->window;
3306
3307 int org_x = 0;
3308 int org_y = 0;
3309 gdk_window_get_origin( source, &org_x, &org_y );
3310
3311 if (!m_wxwindow)
3312 {
3313 if (GTK_WIDGET_NO_WINDOW (m_widget))
3314 {
3315 org_x += m_widget->allocation.x;
3316 org_y += m_widget->allocation.y;
3317 }
3318 }
3319
3320 if (x) *x += org_x;
3321 if (y) *y += org_y;
3322}
3323
3324void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
3325{
3326 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3327
3328 if (!m_widget->window) return;
3329
3330 GdkWindow *source = (GdkWindow *) NULL;
3331 if (m_wxwindow)
3332 source = GTK_PIZZA(m_wxwindow)->bin_window;
3333 else
3334 source = m_widget->window;
3335
3336 int org_x = 0;
3337 int org_y = 0;
3338 gdk_window_get_origin( source, &org_x, &org_y );
3339
3340 if (!m_wxwindow)
3341 {
3342 if (GTK_WIDGET_NO_WINDOW (m_widget))
3343 {
3344 org_x += m_widget->allocation.x;
3345 org_y += m_widget->allocation.y;
3346 }
3347 }
3348
3349 if (x) *x -= org_x;
3350 if (y) *y -= org_y;
3351}
3352
3353bool wxWindowGTK::Show( bool show )
3354{
3355 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3356
3357 if (!wxWindowBase::Show(show))
3358 {
3359 // nothing to do
3360 return FALSE;
3361 }
3362
3363 if (show)
3364 gtk_widget_show( m_widget );
3365 else
3366 gtk_widget_hide( m_widget );
3367
3368 wxShowEvent eventShow(GetId(), show);
3369 eventShow.m_eventObject = this;
3370
3371 GetEventHandler()->ProcessEvent(eventShow);
3372
3373 return TRUE;
3374}
3375
3376static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
3377{
3378 win->OnParentEnable(enable);
3379
3380 // Recurse, so that children have the opportunity to Do The Right Thing
3381 // and reset colours that have been messed up by a parent's (really ancestor's)
3382 // Enable call
3383 for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
3384 node;
3385 node = node->GetNext() )
3386 {
3387 wxWindow *child = node->GetData();
3388 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3389 wxWindowNotifyEnable(child, enable);
3390 }
3391}
3392
3393bool wxWindowGTK::Enable( bool enable )
3394{
3395 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3396
3397 if (!wxWindowBase::Enable(enable))
3398 {
3399 // nothing to do
3400 return FALSE;
3401 }
3402
3403 gtk_widget_set_sensitive( m_widget, enable );
3404 if ( m_wxwindow )
3405 gtk_widget_set_sensitive( m_wxwindow, enable );
3406
3407 wxWindowNotifyEnable(this, enable);
3408
3409 return TRUE;
3410}
3411
3412int wxWindowGTK::GetCharHeight() const
3413{
3414 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3415
3416 wxFont font = GetFont();
3417 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
3418
3419#ifdef __WXGTK20__
3420 PangoContext *context = NULL;
3421 if (m_widget)
3422 context = gtk_widget_get_pango_context( m_widget );
3423
3424 if (!context)
3425 return 0;
3426
3427 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3428 PangoLayout *layout = pango_layout_new(context);
3429 pango_layout_set_font_description(layout, desc);
3430 pango_layout_set_text(layout, "H", 1);
3431 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3432
3433 PangoRectangle rect;
3434 pango_layout_line_get_extents(line, NULL, &rect);
3435
3436 g_object_unref( G_OBJECT( layout ) );
3437
3438 return (int) (rect.height / PANGO_SCALE);
3439#else
3440 GdkFont *gfont = font.GetInternalFont( 1.0 );
3441
3442 return gfont->ascent + gfont->descent;
3443#endif
3444}
3445
3446int wxWindowGTK::GetCharWidth() const
3447{
3448 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3449
3450 wxFont font = GetFont();
3451 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
3452
3453#ifdef __WXGTK20__
3454 PangoContext *context = NULL;
3455 if (m_widget)
3456 context = gtk_widget_get_pango_context( m_widget );
3457
3458 if (!context)
3459 return 0;
3460
3461 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3462 PangoLayout *layout = pango_layout_new(context);
3463 pango_layout_set_font_description(layout, desc);
3464 pango_layout_set_text(layout, "g", 1);
3465 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3466
3467 PangoRectangle rect;
3468 pango_layout_line_get_extents(line, NULL, &rect);
3469
3470 g_object_unref( G_OBJECT( layout ) );
3471
3472 return (int) (rect.width / PANGO_SCALE);
3473#else
3474 GdkFont *gfont = font.GetInternalFont( 1.0 );
3475
3476 return gdk_string_width( gfont, "g" );
3477#endif
3478}
3479
3480void wxWindowGTK::GetTextExtent( const wxString& string,
3481 int *x,
3482 int *y,
3483 int *descent,
3484 int *externalLeading,
3485 const wxFont *theFont ) const
3486{
3487 wxFont fontToUse = theFont ? *theFont : GetFont();
3488
3489 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3490
3491 if (string.IsEmpty())
3492 {
3493 if (x) (*x) = 0;
3494 if (y) (*y) = 0;
3495 return;
3496 }
3497
3498#ifdef __WXGTK20__
3499 PangoContext *context = NULL;
3500 if (m_widget)
3501 context = gtk_widget_get_pango_context( m_widget );
3502
3503 if (!context)
3504 {
3505 if (x) (*x) = 0;
3506 if (y) (*y) = 0;
3507 return;
3508 }
3509
3510 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3511 PangoLayout *layout = pango_layout_new(context);
3512 pango_layout_set_font_description(layout, desc);
3513 {
3514#if wxUSE_UNICODE
3515 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
3516 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3517#else
3518 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
3519 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
3520 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3521#endif
3522 }
3523 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3524
3525 PangoRectangle rect;
3526 pango_layout_line_get_extents(line, NULL, &rect);
3527
3528 if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
3529 if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
3530 if (descent)
3531 {
3532 // Do something about metrics here
3533 (*descent) = 0;
3534 }
3535 if (externalLeading) (*externalLeading) = 0; // ??
3536
3537 g_object_unref( G_OBJECT( layout ) );
3538#else
3539 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
3540 if (x) (*x) = gdk_string_width( font, wxGTK_CONV( string ) );
3541 if (y) (*y) = font->ascent + font->descent;
3542 if (descent) (*descent) = font->descent;
3543 if (externalLeading) (*externalLeading) = 0; // ??
3544#endif
3545}
3546
3547void wxWindowGTK::SetFocus()
3548{
3549 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3550
3551 if ( m_hasFocus )
3552 {
3553 // don't do anything if we already have focus
3554 return;
3555 }
3556
3557 if (m_wxwindow)
3558 {
3559 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3560 {
3561 gtk_widget_grab_focus (m_wxwindow);
3562 }
3563 }
3564 else if (m_widget)
3565 {
3566 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3567 {
3568 if (!GTK_WIDGET_REALIZED(m_widget))
3569 {
3570 // we can't set the focus to the widget now so we remember that
3571 // it should be focused and will do it later, during the idle
3572 // time, as soon as we can
3573 wxLogTrace(TRACE_FOCUS,
3574 _T("Delaying setting focus to %s(%s)"),
3575 GetClassInfo()->GetClassName(), GetLabel().c_str());
3576
3577 g_delayedFocus = this;
3578 }
3579 else
3580 {
3581 wxLogTrace(TRACE_FOCUS,
3582 _T("Setting focus to %s(%s)"),
3583 GetClassInfo()->GetClassName(), GetLabel().c_str());
3584
3585 gtk_widget_grab_focus (m_widget);
3586 }
3587 }
3588 else if (GTK_IS_CONTAINER(m_widget))
3589 {
3590 SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );
3591 }
3592 else
3593 {
3594 wxLogTrace(TRACE_FOCUS,
3595 _T("Can't set focus to %s(%s)"),
3596 GetClassInfo()->GetClassName(), GetLabel().c_str());
3597 }
3598 }
3599}
3600
3601bool wxWindowGTK::AcceptsFocus() const
3602{
3603 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
3604}
3605
3606bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3607{
3608 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3609
3610 wxWindowGTK *oldParent = m_parent,
3611 *newParent = (wxWindowGTK *)newParentBase;
3612
3613 wxASSERT( GTK_IS_WIDGET(m_widget) );
3614
3615 if ( !wxWindowBase::Reparent(newParent) )
3616 return FALSE;
3617
3618 wxASSERT( GTK_IS_WIDGET(m_widget) );
3619
3620 /* prevent GTK from deleting the widget arbitrarily */
3621 gtk_widget_ref( m_widget );
3622
3623 if (oldParent)
3624 {
3625 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3626 }
3627
3628 wxASSERT( GTK_IS_WIDGET(m_widget) );
3629
3630 if (newParent)
3631 {
3632 /* insert GTK representation */
3633 (*(newParent->m_insertCallback))(newParent, this);
3634 }
3635
3636 /* reverse: prevent GTK from deleting the widget arbitrarily */
3637 gtk_widget_unref( m_widget );
3638
3639 return TRUE;
3640}
3641
3642void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3643{
3644 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3645
3646 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3647
3648 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3649
3650 /* add to list */
3651 AddChild( child );
3652
3653 /* insert GTK representation */
3654 (*m_insertCallback)(this, child);
3655}
3656
3657void wxWindowGTK::Raise()
3658{
3659 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3660
3661 if (!m_widget->window) return;
3662
3663 gdk_window_raise( m_widget->window );
3664}
3665
3666void wxWindowGTK::Lower()
3667{
3668 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3669
3670 if (!m_widget->window) return;
3671
3672 gdk_window_lower( m_widget->window );
3673}
3674
3675bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3676{
3677 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3678
3679 if (cursor == m_cursor)
3680 return FALSE;
3681
3682 if (g_isIdle)
3683 wxapp_install_idle_handler();
3684
3685 if (cursor == wxNullCursor)
3686 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3687 else
3688 return wxWindowBase::SetCursor( cursor );
3689}
3690
3691void wxWindowGTK::WarpPointer( int x, int y )
3692{
3693 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3694
3695 // We provide this function ourselves as it is
3696 // missing in GDK (top of this file).
3697
3698 GdkWindow *window = (GdkWindow*) NULL;
3699 if (m_wxwindow)
3700 window = GTK_PIZZA(m_wxwindow)->bin_window;
3701 else
3702 window = GetConnectWidget()->window;
3703
3704 if (window)
3705 gdk_window_warp_pointer( window, x, y );
3706}
3707
3708
3709void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3710{
3711 if (!m_widget) return;
3712 if (!m_widget->window) return;
3713
3714#ifndef __WXGTK20__
3715 if (g_isIdle)
3716 wxapp_install_idle_handler();
3717
3718 wxRect myRect(0,0,0,0);
3719 if (m_wxwindow && rect)
3720 {
3721 myRect.SetSize(wxSize( m_wxwindow->allocation.width,
3722 m_wxwindow->allocation.height));
3723 myRect.Intersect(*rect);
3724 if (!myRect.width || !myRect.height)
3725 // nothing to do, rectangle is empty
3726 return;
3727 rect = &myRect;
3728 }
3729
3730 if (eraseBackground && m_wxwindow && m_wxwindow->window)
3731 {
3732 if (rect)
3733 {
3734 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3735 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
3736 }
3737 else
3738 {
3739 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3740 m_clearRegion.Clear();
3741 m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3742 }
3743 }
3744
3745 if (rect)
3746 {
3747 if (m_wxwindow)
3748 {
3749 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3750 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
3751 }
3752 else
3753 {
3754 GdkRectangle gdk_rect;
3755 gdk_rect.x = rect->x;
3756 gdk_rect.y = rect->y;
3757 gdk_rect.width = rect->width;
3758 gdk_rect.height = rect->height;
3759 gtk_widget_draw( m_widget, &gdk_rect );
3760 }
3761 }
3762 else
3763 {
3764 if (m_wxwindow)
3765 {
3766 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3767 m_updateRegion.Clear();
3768 m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3769 }
3770 else
3771 {
3772 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
3773 }
3774 }
3775#else
3776 if (m_wxwindow)
3777 {
3778 if (rect)
3779 {
3780 GdkRectangle gdk_rect;
3781 gdk_rect.x = rect->x;
3782 gdk_rect.y = rect->y;
3783 gdk_rect.width = rect->width;
3784 gdk_rect.height = rect->height;
3785 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
3786 }
3787 else
3788 {
3789 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
3790 }
3791 }
3792#endif
3793}
3794
3795void wxWindowGTK::Update()
3796{
3797 GtkUpdate();
3798}
3799
3800void wxWindowGTK::GtkUpdate()
3801{
3802#ifdef __WXGTK20__
3803 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3804 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
3805#else
3806 if (!m_updateRegion.IsEmpty())
3807 GtkSendPaintEvents();
3808#endif
3809}
3810
3811void wxWindowGTK::GtkSendPaintEvents()
3812{
3813 if (!m_wxwindow)
3814 {
3815#ifndef __WXGTK20__
3816 m_clearRegion.Clear();
3817#endif
3818 m_updateRegion.Clear();
3819 return;
3820 }
3821
3822 // Clip to paint region in wxClientDC
3823 m_clipPaintRegion = TRUE;
3824
3825#ifndef __WXGTK20__
3826 // widget to draw on
3827 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
3828
3829 // later for GTK 2.0, too.
3830 if (GetThemeEnabled())
3831 {
3832 // find ancestor from which to steal background
3833 wxWindow *parent = GetParent();
3834 while (parent && !parent->IsTopLevel())
3835 parent = parent->GetParent();
3836 if (!parent)
3837 parent = (wxWindow*)this;
3838
3839 wxRegionIterator upd( m_updateRegion );
3840 while (upd)
3841 {
3842 GdkRectangle rect;
3843 rect.x = upd.GetX();
3844 rect.y = upd.GetY();
3845 rect.width = upd.GetWidth();
3846 rect.height = upd.GetHeight();
3847
3848 gtk_paint_flat_box( parent->m_widget->style,
3849 pizza->bin_window,
3850 GTK_STATE_NORMAL,
3851 GTK_SHADOW_NONE,
3852 &rect,
3853 parent->m_widget,
3854 (char *)"base",
3855 0, 0, -1, -1 );
3856
3857 upd ++;
3858 }
3859 }
3860 else
3861#endif
3862
3863#ifdef __WXGTK20__
3864 {
3865 wxWindowDC dc( (wxWindow*)this );
3866 dc.SetClippingRegion( m_updateRegion );
3867
3868 wxEraseEvent erase_event( GetId(), &dc );
3869 erase_event.SetEventObject( this );
3870
3871 GetEventHandler()->ProcessEvent(erase_event);
3872 }
3873#else
3874 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
3875 {
3876 wxWindowDC dc( (wxWindow*)this );
3877 if (m_clearRegion.IsEmpty())
3878 dc.SetClippingRegion( m_updateRegion );
3879 else
3880 dc.SetClippingRegion( m_clearRegion );
3881
3882 wxEraseEvent erase_event( GetId(), &dc );
3883 erase_event.SetEventObject( this );
3884
3885 if (!GetEventHandler()->ProcessEvent(erase_event))
3886 {
3887 if (!g_eraseGC)
3888 {
3889 g_eraseGC = gdk_gc_new( pizza->bin_window );
3890 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
3891 }
3892 gdk_gc_set_foreground( g_eraseGC, GetBackgroundColour().GetColor() );
3893
3894 wxRegionIterator upd( m_clearRegion );
3895 while (upd)
3896 {
3897 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
3898 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
3899 upd ++;
3900 }
3901 }
3902 m_clearRegion.Clear();
3903 }
3904#endif
3905
3906 wxNcPaintEvent nc_paint_event( GetId() );
3907 nc_paint_event.SetEventObject( this );
3908 GetEventHandler()->ProcessEvent( nc_paint_event );
3909
3910 wxPaintEvent paint_event( GetId() );
3911 paint_event.SetEventObject( this );
3912 GetEventHandler()->ProcessEvent( paint_event );
3913
3914 m_clipPaintRegion = FALSE;
3915
3916#ifndef __WXUNIVERSAL__
3917#ifndef __WXGTK20__
3918 // The following code will result in all window-less widgets
3919 // being redrawn because the wxWidgets class is allowed to
3920 // paint over the window-less widgets.
3921
3922 GList *children = pizza->children;
3923 while (children)
3924 {
3925 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
3926 children = children->next;
3927
3928 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
3929 GTK_WIDGET_DRAWABLE (child->widget))
3930 {
3931 // Get intersection of widget area and update region
3932 wxRegion region( m_updateRegion );
3933
3934 GdkEventExpose gdk_event;
3935 gdk_event.type = GDK_EXPOSE;
3936 gdk_event.window = pizza->bin_window;
3937 gdk_event.count = 0;
3938
3939 wxRegionIterator upd( m_updateRegion );
3940 while (upd)
3941 {
3942 GdkRectangle rect;
3943 rect.x = upd.GetX();
3944 rect.y = upd.GetY();
3945 rect.width = upd.GetWidth();
3946 rect.height = upd.GetHeight();
3947
3948 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
3949 {
3950 gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
3951 }
3952
3953 upd ++;
3954 }
3955 }
3956 }
3957#endif
3958#endif
3959
3960 m_updateRegion.Clear();
3961}
3962
3963void wxWindowGTK::ClearBackground()
3964{
3965 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3966
3967#ifndef __WXGTK20__
3968 if (m_wxwindow && m_wxwindow->window)
3969 {
3970 m_clearRegion.Clear();
3971 wxSize size( GetClientSize() );
3972 m_clearRegion.Union( 0,0,size.x,size.y );
3973
3974 // Better do this in idle?
3975 GtkUpdate();
3976 }
3977#endif
3978}
3979
3980#if wxUSE_TOOLTIPS
3981void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3982{
3983 wxWindowBase::DoSetToolTip(tip);
3984
3985 if (m_tooltip)
3986 m_tooltip->Apply( (wxWindow *)this );
3987}
3988
3989void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
3990{
3991 wxString tmp( tip );
3992 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );
3993}
3994#endif // wxUSE_TOOLTIPS
3995
3996void wxWindowGTK::GtkSetBackgroundColour( const wxColour &colour )
3997{
3998 GdkWindow *window = (GdkWindow*) NULL;
3999 if (m_wxwindow)
4000 window = GTK_PIZZA(m_wxwindow)->bin_window;
4001 else
4002 window = GetConnectWidget()->window;
4003
4004 wxASSERT( window );
4005
4006 // We need the pixel value e.g. for background clearing.
4007 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
4008
4009 if (m_wxwindow)
4010 {
4011 // wxMSW doesn't clear the window here, either.
4012 gdk_window_set_background( window, m_backgroundColour.GetColor() );
4013 }
4014
4015 ApplyWidgetStyle();
4016}
4017
4018bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
4019{
4020 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4021
4022 if (!wxWindowBase::SetBackgroundColour(colour))
4023 return FALSE;
4024
4025 GdkWindow *window = (GdkWindow*) NULL;
4026 if (m_wxwindow)
4027 window = GTK_PIZZA(m_wxwindow)->bin_window;
4028 else
4029 window = GetConnectWidget()->window;
4030
4031 if (!window)
4032 {
4033 // indicate that a new style has been set
4034 // but it couldn't get applied as the
4035 // widget hasn't been realized yet.
4036 m_delayedBackgroundColour = TRUE;
4037 return TRUE;
4038 }
4039 else
4040 {
4041 GtkSetBackgroundColour( colour );
4042 }
4043
4044 return TRUE;
4045}
4046
4047void wxWindowGTK::GtkSetForegroundColour( const wxColour &colour )
4048{
4049 GdkWindow *window = (GdkWindow*) NULL;
4050 if (m_wxwindow)
4051 window = GTK_PIZZA(m_wxwindow)->bin_window;
4052 else
4053 window = GetConnectWidget()->window;
4054
4055 wxASSERT( window );
4056
4057 ApplyWidgetStyle();
4058}
4059
4060bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
4061{
4062 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4063
4064 if (!wxWindowBase::SetForegroundColour(colour))
4065 {
4066 // don't leave if the GTK widget has just
4067 // been realized
4068 if (!m_delayedForegroundColour) return FALSE;
4069 }
4070
4071 GdkWindow *window = (GdkWindow*) NULL;
4072 if (m_wxwindow)
4073 window = GTK_PIZZA(m_wxwindow)->bin_window;
4074 else
4075 window = GetConnectWidget()->window;
4076
4077 if (!window)
4078 {
4079 // indicate that a new style has been set
4080 // but it couldn't get applied as the
4081 // widget hasn't been realized yet.
4082 m_delayedForegroundColour = TRUE;
4083 }
4084 else
4085 {
4086 GtkSetForegroundColour( colour );
4087 }
4088
4089 return TRUE;
4090}
4091
4092#ifdef __WXGTK20__
4093PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
4094{
4095 return gtk_widget_get_pango_context( m_widget );
4096}
4097
4098PangoContext *wxWindowGTK::GtkGetPangoX11Context()
4099{
4100 if (!m_x11Context)
4101 m_x11Context = pango_x_get_context( gdk_display );
4102
4103 return m_x11Context;
4104}
4105#endif
4106
4107GtkStyle *wxWindowGTK::GetWidgetStyle()
4108{
4109 if (m_widgetStyle)
4110 {
4111 GtkStyle *remake = gtk_style_copy( m_widgetStyle );
4112
4113 // FIXME: no more klass in 2.0
4114#ifndef __WXGTK20__
4115 remake->klass = m_widgetStyle->klass;
4116#endif
4117
4118 gtk_style_unref( m_widgetStyle );
4119 m_widgetStyle = remake;
4120 }
4121 else
4122 {
4123 GtkStyle *def = gtk_rc_get_style( m_widget );
4124
4125 if (!def)
4126 def = gtk_widget_get_default_style();
4127
4128 m_widgetStyle = gtk_style_copy( def );
4129
4130 // FIXME: no more klass in 2.0
4131#ifndef __WXGTK20__
4132 m_widgetStyle->klass = def->klass;
4133#endif
4134 }
4135
4136 return m_widgetStyle;
4137}
4138
4139void wxWindowGTK::SetWidgetStyle()
4140{
4141#if DISABLE_STYLE_IF_BROKEN_THEME
4142 if (m_widget->style->engine_data)
4143 {
4144 static bool s_warningPrinted = FALSE;
4145 if (!s_warningPrinted)
4146 {
4147 printf( "wxWidgets warning: Widget styles disabled due to buggy GTK theme.\n" );
4148 s_warningPrinted = TRUE;
4149 }
4150 m_widgetStyle = m_widget->style;
4151 return;
4152 }
4153#endif
4154
4155 GtkStyle *style = GetWidgetStyle();
4156
4157 if ( m_hasFont )
4158 {
4159#ifdef __WXGTK20__
4160 pango_font_description_free( style->font_desc );
4161 style->font_desc = pango_font_description_copy( m_font.GetNativeFontInfo()->description );
4162#else
4163 gdk_font_unref( style->font );
4164 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
4165#endif
4166 }
4167
4168 if ( m_hasFgCol )
4169 {
4170 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
4171 if (m_foregroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT))
4172 {
4173 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
4174 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
4175 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
4176 }
4177 else
4178 {
4179 // Try to restore the gtk default style. This is still a little
4180 // oversimplified for what is probably really needed here for controls
4181 // other than buttons, but is better than not being able to (re)set a
4182 // control's foreground colour to *wxBLACK -- RL
4183 GtkStyle *def = gtk_rc_get_style( m_widget );
4184
4185 if (!def)
4186 def = gtk_widget_get_default_style();
4187
4188 style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
4189 style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
4190 style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
4191 }
4192 }
4193
4194 if ( m_hasBgCol && m_backgroundColour.Ok() )
4195 {
4196 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
4197 if (m_backgroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE))
4198 {
4199 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4200 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4201 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4202 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4203 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4204 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4205 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
4206 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
4207 }
4208 else
4209 {
4210 // Try to restore the gtk default style. This is still a little
4211 // oversimplified for what is probably really needed here for controls
4212 // other than buttons, but is better than not being able to (re)set a
4213 // control's background colour to default grey and means resetting a
4214 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
4215 // behavior -- RL
4216 GtkStyle *def = gtk_rc_get_style( m_widget );
4217
4218 if (!def)
4219 def = gtk_widget_get_default_style();
4220
4221 style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
4222 style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
4223 style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
4224 style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
4225 style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
4226 style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
4227 style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
4228 style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
4229 }
4230 }
4231}
4232
4233void wxWindowGTK::ApplyWidgetStyle()
4234{
4235}
4236
4237//-----------------------------------------------------------------------------
4238// Pop-up menu stuff
4239//-----------------------------------------------------------------------------
4240
4241#if wxUSE_MENUS_NATIVE
4242
4243extern "C"
4244void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
4245{
4246 *is_waiting = FALSE;
4247}
4248
4249static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
4250{
4251 menu->SetInvokingWindow( win );
4252 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
4253 while (node)
4254 {
4255 wxMenuItem *menuitem = node->GetData();
4256 if (menuitem->IsSubMenu())
4257 {
4258 SetInvokingWindow( menuitem->GetSubMenu(), win );
4259 }
4260
4261 node = node->GetNext();
4262 }
4263}
4264
4265extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
4266 gint *x, gint *y,
4267#ifdef __WXGTK20__
4268 gboolean * WXUNUSED(whatever),
4269#endif
4270 gpointer user_data )
4271{
4272 // ensure that the menu appears entirely on screen
4273 GtkRequisition req;
4274 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4275
4276 wxSize sizeScreen = wxGetDisplaySize();
4277 wxPoint *pos = (wxPoint*)user_data;
4278
4279 gint xmax = sizeScreen.x - req.width,
4280 ymax = sizeScreen.y - req.height;
4281
4282 *x = pos->x < xmax ? pos->x : xmax;
4283 *y = pos->y < ymax ? pos->y : ymax;
4284}
4285
4286bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4287{
4288 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4289
4290 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
4291
4292 SetInvokingWindow( menu, this );
4293
4294 menu->UpdateUI();
4295
4296 wxPoint pos(ClientToScreen(wxPoint(x, y)));
4297
4298 bool is_waiting = TRUE;
4299
4300 gtk_signal_connect( GTK_OBJECT(menu->m_menu),
4301 "hide",
4302 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
4303 (gpointer)&is_waiting );
4304
4305 gtk_menu_popup(
4306 GTK_MENU(menu->m_menu),
4307 (GtkWidget *) NULL, // parent menu shell
4308 (GtkWidget *) NULL, // parent menu item
4309 wxPopupMenuPositionCallback, // function to position it
4310 &pos, // client data
4311 0 /* FIXME! */, // button used to activate it
4312#ifdef __WXGTK20__
4313 gtk_get_current_event_time()
4314#else
4315 gs_timeLastClick // the time of activation
4316#endif
4317 );
4318
4319 while (is_waiting)
4320 {
4321 gtk_main_iteration();
4322 }
4323
4324 return TRUE;
4325}
4326
4327#endif // wxUSE_MENUS_NATIVE
4328
4329#if wxUSE_DRAG_AND_DROP
4330
4331void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4332{
4333 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4334
4335 GtkWidget *dnd_widget = GetConnectWidget();
4336
4337 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
4338
4339 if (m_dropTarget) delete m_dropTarget;
4340 m_dropTarget = dropTarget;
4341
4342 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
4343}
4344
4345#endif // wxUSE_DRAG_AND_DROP
4346
4347GtkWidget* wxWindowGTK::GetConnectWidget()
4348{
4349 GtkWidget *connect_widget = m_widget;
4350 if (m_wxwindow) connect_widget = m_wxwindow;
4351
4352 return connect_widget;
4353}
4354
4355bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
4356{
4357 if (m_wxwindow)
4358 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
4359
4360 return (window == m_widget->window);
4361}
4362
4363bool wxWindowGTK::SetFont( const wxFont &font )
4364{
4365 if (!wxWindowBase::SetFont(font) || !m_widget)
4366 {
4367 return FALSE;
4368 }
4369
4370 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
4371 if ( sysbg == m_backgroundColour )
4372 {
4373 m_backgroundColour = wxNullColour;
4374 ApplyWidgetStyle();
4375 m_backgroundColour = sysbg;
4376 }
4377 else
4378 {
4379 ApplyWidgetStyle();
4380 }
4381
4382 return TRUE;
4383}
4384
4385void wxWindowGTK::DoCaptureMouse()
4386{
4387 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4388
4389 GdkWindow *window = (GdkWindow*) NULL;
4390 if (m_wxwindow)
4391 window = GTK_PIZZA(m_wxwindow)->bin_window;
4392 else
4393 window = GetConnectWidget()->window;
4394
4395 wxCHECK_RET( window, _T("CaptureMouse() failed") );
4396
4397 wxCursor* cursor = & m_cursor;
4398 if (!cursor->Ok())
4399 cursor = wxSTANDARD_CURSOR;
4400
4401 gdk_pointer_grab( window, FALSE,
4402 (GdkEventMask)
4403 (GDK_BUTTON_PRESS_MASK |
4404 GDK_BUTTON_RELEASE_MASK |
4405 GDK_POINTER_MOTION_HINT_MASK |
4406 GDK_POINTER_MOTION_MASK),
4407 (GdkWindow *) NULL,
4408 cursor->GetCursor(),
4409 (guint32)GDK_CURRENT_TIME );
4410 g_captureWindow = this;
4411 g_captureWindowHasMouse = TRUE;
4412}
4413
4414void wxWindowGTK::DoReleaseMouse()
4415{
4416 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4417
4418 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4419
4420 g_captureWindow = (wxWindowGTK*) NULL;
4421
4422 GdkWindow *window = (GdkWindow*) NULL;
4423 if (m_wxwindow)
4424 window = GTK_PIZZA(m_wxwindow)->bin_window;
4425 else
4426 window = GetConnectWidget()->window;
4427
4428 if (!window)
4429 return;
4430
4431 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4432}
4433
4434/* static */
4435wxWindow *wxWindowBase::GetCapture()
4436{
4437 return (wxWindow *)g_captureWindow;
4438}
4439
4440bool wxWindowGTK::IsRetained() const
4441{
4442 return FALSE;
4443}
4444
4445void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
4446 int range, bool refresh )
4447{
4448 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4449
4450 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4451
4452 m_hasScrolling = TRUE;
4453
4454 if (orient == wxHORIZONTAL)
4455 {
4456 float fpos = (float)pos;
4457 float frange = (float)range;
4458 float fthumb = (float)thumbVisible;
4459 if (fpos > frange-fthumb) fpos = frange-fthumb;
4460 if (fpos < 0.0) fpos = 0.0;
4461
4462 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
4463 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
4464 {
4465 SetScrollPos( orient, pos, refresh );
4466 return;
4467 }
4468
4469 m_oldHorizontalPos = fpos;
4470
4471 m_hAdjust->lower = 0.0;
4472 m_hAdjust->upper = frange;
4473 m_hAdjust->value = fpos;
4474 m_hAdjust->step_increment = 1.0;
4475 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
4476 m_hAdjust->page_size = fthumb;
4477 }
4478 else
4479 {
4480 float fpos = (float)pos;
4481 float frange = (float)range;
4482 float fthumb = (float)thumbVisible;
4483 if (fpos > frange-fthumb) fpos = frange-fthumb;
4484 if (fpos < 0.0) fpos = 0.0;
4485
4486 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4487 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4488 {
4489 SetScrollPos( orient, pos, refresh );
4490 return;
4491 }
4492
4493 m_oldVerticalPos = fpos;
4494
4495 m_vAdjust->lower = 0.0;
4496 m_vAdjust->upper = frange;
4497 m_vAdjust->value = fpos;
4498 m_vAdjust->step_increment = 1.0;
4499 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4500 m_vAdjust->page_size = fthumb;
4501 }
4502
4503 if (orient == wxHORIZONTAL)
4504 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4505 else
4506 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
4507}
4508
4509void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
4510{
4511 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4512
4513 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4514
4515 if (orient == wxHORIZONTAL)
4516 {
4517 float fpos = (float)pos;
4518 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
4519 if (fpos < 0.0) fpos = 0.0;
4520 m_oldHorizontalPos = fpos;
4521
4522 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
4523 m_hAdjust->value = fpos;
4524 }
4525 else
4526 {
4527 float fpos = (float)pos;
4528 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
4529 if (fpos < 0.0) fpos = 0.0;
4530 m_oldVerticalPos = fpos;
4531
4532 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
4533 m_vAdjust->value = fpos;
4534 }
4535
4536 if (m_wxwindow->window)
4537 {
4538 if (orient == wxHORIZONTAL)
4539 {
4540 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
4541 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4542
4543 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
4544
4545 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
4546 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4547 }
4548 else
4549 {
4550 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
4551 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4552
4553 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
4554
4555 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
4556 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4557 }
4558 }
4559}
4560
4561int wxWindowGTK::GetScrollThumb( int orient ) const
4562{
4563 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4564
4565 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4566
4567 if (orient == wxHORIZONTAL)
4568 return (int)(m_hAdjust->page_size+0.5);
4569 else
4570 return (int)(m_vAdjust->page_size+0.5);
4571}
4572
4573int wxWindowGTK::GetScrollPos( int orient ) const
4574{
4575 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4576
4577 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4578
4579 if (orient == wxHORIZONTAL)
4580 return (int)(m_hAdjust->value+0.5);
4581 else
4582 return (int)(m_vAdjust->value+0.5);
4583}
4584
4585int wxWindowGTK::GetScrollRange( int orient ) const
4586{
4587 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4588
4589 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4590
4591 if (orient == wxHORIZONTAL)
4592 return (int)(m_hAdjust->upper+0.5);
4593 else
4594 return (int)(m_vAdjust->upper+0.5);
4595}
4596
4597void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4598{
4599 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4600
4601 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4602
4603 // No scrolling requested.
4604 if ((dx == 0) && (dy == 0)) return;
4605
4606#ifndef __WXGTK20__
4607 if (!m_updateRegion.IsEmpty())
4608 {
4609 m_updateRegion.Offset( dx, dy );
4610
4611 int cw = 0;
4612 int ch = 0;
4613 GetClientSize( &cw, &ch );
4614 m_updateRegion.Intersect( 0, 0, cw, ch );
4615 }
4616
4617 if (!m_clearRegion.IsEmpty())
4618 {
4619 m_clearRegion.Offset( dx, dy );
4620
4621 int cw = 0;
4622 int ch = 0;
4623 GetClientSize( &cw, &ch );
4624 m_clearRegion.Intersect( 0, 0, cw, ch );
4625 }
4626#endif
4627
4628 m_clipPaintRegion = TRUE;
4629
4630 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
4631
4632 m_clipPaintRegion = FALSE;
4633}
4634
4635
4636// Find the wxWindow at the current mouse position, also returning the mouse
4637// position.
4638wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4639{
4640 pt = wxGetMousePosition();
4641 wxWindow* found = wxFindWindowAtPoint(pt);
4642 return found;
4643}
4644
4645// Get the current mouse position.
4646wxPoint wxGetMousePosition()
4647{
4648 /* This crashes when used within wxHelpContext,
4649 so we have to use the X-specific implementation below.
4650 gint x, y;
4651 GdkModifierType *mask;
4652 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4653
4654 return wxPoint(x, y);
4655 */
4656
4657 int x, y;
4658 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4659
4660 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4661 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4662 Window rootReturn, childReturn;
4663 int rootX, rootY, winX, winY;
4664 unsigned int maskReturn;
4665
4666 XQueryPointer (display,
4667 rootWindow,
4668 &rootReturn,
4669 &childReturn,
4670 &rootX, &rootY, &winX, &winY, &maskReturn);
4671 return wxPoint(rootX, rootY);
4672
4673}
4674
4675// ----------------------------------------------------------------------------
4676// wxDCModule
4677// ----------------------------------------------------------------------------
4678
4679class wxWinModule : public wxModule
4680{
4681public:
4682 bool OnInit();
4683 void OnExit();
4684
4685private:
4686 DECLARE_DYNAMIC_CLASS(wxWinModule)
4687};
4688
4689IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4690
4691bool wxWinModule::OnInit()
4692{
4693 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4694 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4695
4696 return TRUE;
4697}
4698
4699void wxWinModule::OnExit()
4700{
4701 if (g_eraseGC)
4702 gdk_gc_unref( g_eraseGC );
4703}
4704
4705// vi:sts=4:sw=4:et
wxWidgets (Impactor)