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