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