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