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