projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Set m_wheelDelta for wheel events
[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 // find the correct window to send the event too: it may be a different one
1707 // from the one which got it at GTK+ level because some control don't have
1708 // their own X window and thus cannot get any events.
1709 if ( !g_captureWindow )
1710 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1711
1712 gs_timeLastClick = gdk_event->time;
1713
1714 /*
1715 wxPrintf( wxT("2) OnButtonPress from ") );
1716 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1717 wxPrintf( win->GetClassInfo()->GetClassName() );
1718 wxPrintf( wxT(".\n") );
1719 */
1720
1721 #ifndef __WXGTK20__
1722 if (event_type == wxEVT_LEFT_DCLICK)
1723 {
1724 // GTK 1.2 crashes when intercepting double
1725 // click events from both wxSpinButton and
1726 // wxSpinCtrl
1727 if (GTK_IS_SPIN_BUTTON(win->m_widget))
1728 {
1729 // Just disable this event for now.
1730 return FALSE;
1731 }
1732 }
1733 #endif
1734
1735 if (win->GetEventHandler()->ProcessEvent( event ))
1736 {
1737 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
1738 return TRUE;
1739 }
1740
1741 return FALSE;
1742 }
1743
1744 //-----------------------------------------------------------------------------
1745 // "button_release_event"
1746 //-----------------------------------------------------------------------------
1747
1748 static gint gtk_window_button_release_callback( GtkWidget *widget,
1749 GdkEventButton *gdk_event,
1750 wxWindowGTK *win )
1751 {
1752 DEBUG_MAIN_THREAD
1753
1754 if (g_isIdle)
1755 wxapp_install_idle_handler();
1756
1757 if (!win->m_hasVMT) return FALSE;
1758 if (g_blockEventsOnDrag) return FALSE;
1759 if (g_blockEventsOnScroll) return FALSE;
1760
1761 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1762
1763 wxEventType event_type = wxEVT_NULL;
1764
1765 switch (gdk_event->button)
1766 {
1767 case 1:
1768 event_type = wxEVT_LEFT_UP;
1769 break;
1770
1771 case 2:
1772 event_type = wxEVT_MIDDLE_UP;
1773 break;
1774
1775 case 3:
1776 event_type = wxEVT_RIGHT_UP;
1777 break;
1778
1779 default:
1780 // unknwon button, don't process
1781 return FALSE;
1782 }
1783
1784 wxMouseEvent event( event_type );
1785 InitMouseEvent( win, event, gdk_event );
1786
1787 AdjustEventButtonState(event);
1788
1789 // same wxListBox hack as above
1790 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1791
1792 if ( event_type == wxEVT_RIGHT_UP )
1793 {
1794 // generate a "context menu" event: this is similar to wxEVT_RIGHT_UP
1795 // except that:
1796 //
1797 // (a) it's a command event and so is propagated to the parent
1798 // (b) under MSW it can be generated from kbd too
1799 // (c) it uses screen coords (because of (a))
1800 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
1801 win->GetId(),
1802 win->ClientToScreen(event.GetPosition()));
1803 (void)win->GetEventHandler()->ProcessEvent(evtCtx);
1804 }
1805
1806 if ( !g_captureWindow )
1807 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1808
1809 if (win->GetEventHandler()->ProcessEvent( event ))
1810 {
1811 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
1812 return TRUE;
1813 }
1814
1815 return FALSE;
1816 }
1817
1818 //-----------------------------------------------------------------------------
1819 // "motion_notify_event"
1820 //-----------------------------------------------------------------------------
1821
1822 static gint gtk_window_motion_notify_callback( GtkWidget *widget,
1823 GdkEventMotion *gdk_event,
1824 wxWindowGTK *win )
1825 {
1826 DEBUG_MAIN_THREAD
1827
1828 if (g_isIdle)
1829 wxapp_install_idle_handler();
1830
1831 if (!win->m_hasVMT) return FALSE;
1832 if (g_blockEventsOnDrag) return FALSE;
1833 if (g_blockEventsOnScroll) return FALSE;
1834
1835 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1836
1837 if (gdk_event->is_hint)
1838 {
1839 int x = 0;
1840 int y = 0;
1841 GdkModifierType state;
1842 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1843 gdk_event->x = x;
1844 gdk_event->y = y;
1845 }
1846
1847 /*
1848 printf( "OnMotion from " );
1849 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1850 printf( win->GetClassInfo()->GetClassName() );
1851 printf( ".\n" );
1852 */
1853
1854 wxMouseEvent event( wxEVT_MOTION );
1855 InitMouseEvent(win, event, gdk_event);
1856
1857 if ( g_captureWindow )
1858 {
1859 // synthetize a mouse enter or leave event if needed
1860 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1861 // This seems to be necessary and actually been added to
1862 // GDK itself in version 2.0.X
1863 gdk_flush();
1864
1865 bool hasMouse = winUnderMouse == gdk_event->window;
1866 if ( hasMouse != g_captureWindowHasMouse )
1867 {
1868 // the mouse changed window
1869 g_captureWindowHasMouse = hasMouse;
1870
1871 wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1872 : wxEVT_LEAVE_WINDOW);
1873 InitMouseEvent(win, event, gdk_event);
1874 event.SetEventObject(win);
1875 win->GetEventHandler()->ProcessEvent(event);
1876 }
1877 }
1878 else // no capture
1879 {
1880 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1881 }
1882
1883 if (win->GetEventHandler()->ProcessEvent( event ))
1884 {
1885 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
1886 return TRUE;
1887 }
1888
1889 return FALSE;
1890 }
1891
1892 #ifdef __WXGTK20__
1893 //-----------------------------------------------------------------------------
1894 // "mouse_wheel_event"
1895 //-----------------------------------------------------------------------------
1896
1897 static gint gtk_window_wheel_callback (GtkWidget * widget,
1898 GdkEventScroll * gdk_event,
1899 wxWindowGTK * win)
1900 {
1901 DEBUG_MAIN_THREAD
1902
1903 if (g_isIdle)
1904 wxapp_install_idle_handler();
1905
1906 wxEventType event_type = wxEVT_NULL;
1907 if (gdk_event->direction == GDK_SCROLL_UP)
1908 event_type = wxEVT_MOUSEWHEEL;
1909 else if (gdk_event->direction == GDK_SCROLL_DOWN)
1910 event_type = wxEVT_MOUSEWHEEL;
1911 else
1912 return FALSE;
1913
1914 wxMouseEvent event( event_type );
1915 // Can't use InitMouse macro because scroll events don't have button
1916 event.SetTimestamp( gdk_event->time );
1917 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1918 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1919 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1920 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1921 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1922 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1923 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
1924 event.m_linesPerAction = 3;
1925 event.m_wheelDelta = 120;
1926 if (gdk_event->direction == GDK_SCROLL_UP)
1927 event.m_wheelRotation = 120;
1928 else
1929 event.m_wheelRotation = -120;
1930
1931 wxPoint pt = win->GetClientAreaOrigin();
1932 event.m_x = (wxCoord)gdk_event->x - pt.x;
1933 event.m_y = (wxCoord)gdk_event->y - pt.y;
1934
1935 event.SetEventObject( win );
1936 event.SetId( win->GetId() );
1937 event.SetTimestamp( gdk_event->time );
1938
1939 if (win->GetEventHandler()->ProcessEvent( event ))
1940 {
1941 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "scroll_event" );
1942 return TRUE;
1943 }
1944
1945 return FALSE;
1946 }
1947 #endif
1948
1949 //-----------------------------------------------------------------------------
1950 // "focus_in_event"
1951 //-----------------------------------------------------------------------------
1952
1953 // send the wxChildFocusEvent and wxFocusEvent, common code of
1954 // gtk_window_focus_in_callback() and SetFocus()
1955 static bool DoSendFocusEvents(wxWindow *win)
1956 {
1957 // Notify the parent keeping track of focus for the kbd navigation
1958 // purposes that we got it.
1959 wxChildFocusEvent eventChildFocus(win);
1960 (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
1961
1962 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1963 eventFocus.SetEventObject(win);
1964
1965 return win->GetEventHandler()->ProcessEvent(eventFocus);
1966 }
1967
1968 static gint gtk_window_focus_in_callback( GtkWidget *widget,
1969 GdkEvent *WXUNUSED(event),
1970 wxWindow *win )
1971 {
1972 DEBUG_MAIN_THREAD
1973
1974 if (g_isIdle)
1975 wxapp_install_idle_handler();
1976
1977 #ifdef __WXGTK20__
1978 if (win->m_imData)
1979 gtk_im_context_focus_in(win->m_imData->context);
1980 #endif
1981
1982 if (!win->m_hasVMT) return FALSE;
1983 if (g_blockEventsOnDrag) return FALSE;
1984
1985 switch ( g_sendActivateEvent )
1986 {
1987 case -1:
1988 // we've got focus from outside, synthetize wxActivateEvent
1989 g_sendActivateEvent = 1;
1990 break;
1991
1992 case 0:
1993 // another our window just lost focus, it was already ours before
1994 // - don't send any wxActivateEvent
1995 g_sendActivateEvent = -1;
1996 break;
1997 }
1998
1999 g_focusWindowLast =
2000 g_focusWindow = win;
2001
2002 wxLogTrace(TRACE_FOCUS,
2003 _T("%s: focus in"), win->GetName().c_str());
2004
2005 #ifdef HAVE_XIM
2006 if (win->m_ic)
2007 gdk_im_begin(win->m_ic, win->m_wxwindow->window);
2008 #endif
2009
2010 #if wxUSE_CARET
2011 // caret needs to be informed about focus change
2012 wxCaret *caret = win->GetCaret();
2013 if ( caret )
2014 {
2015 caret->OnSetFocus();
2016 }
2017 #endif // wxUSE_CARET
2018
2019 g_activeFrameLostFocus = FALSE;
2020
2021 wxWindowGTK *active = wxGetTopLevelParent(win);
2022 if ( active != g_activeFrame )
2023 {
2024 if ( g_activeFrame )
2025 {
2026 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame);
2027 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
2028 event.SetEventObject(g_activeFrame);
2029 g_activeFrame->GetEventHandler()->ProcessEvent(event);
2030 }
2031
2032 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active);
2033 g_activeFrame = active;
2034 wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
2035 event.SetEventObject(g_activeFrame);
2036 g_activeFrame->GetEventHandler()->ProcessEvent(event);
2037
2038 // Don't send focus events in addition to activate
2039 // if (win == g_activeFrame)
2040 // return TRUE;
2041 }
2042
2043 // does the window itself think that it has the focus?
2044 if ( !win->m_hasFocus )
2045 {
2046 // not yet, notify it
2047 win->m_hasFocus = TRUE;
2048
2049 if ( DoSendFocusEvents(win) )
2050 {
2051 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
2052 return TRUE;
2053 }
2054 }
2055
2056 return FALSE;
2057 }
2058
2059 //-----------------------------------------------------------------------------
2060 // "focus_out_event"
2061 //-----------------------------------------------------------------------------
2062
2063 static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
2064 {
2065 DEBUG_MAIN_THREAD
2066
2067 if (g_isIdle)
2068 wxapp_install_idle_handler();
2069
2070 #ifdef __WXGTK20__
2071 if (win->m_imData)
2072 gtk_im_context_focus_out(win->m_imData->context);
2073 #endif
2074
2075 if (!win->m_hasVMT) return FALSE;
2076 if (g_blockEventsOnDrag) return FALSE;
2077
2078 wxLogTrace( TRACE_FOCUS,
2079 _T("%s: focus out"), win->GetName().c_str() );
2080
2081 if ( !g_activeFrameLostFocus && g_activeFrame )
2082 {
2083 // VZ: commenting this out because it does happen (although not easy
2084 // to reproduce, I only see it when using wxMiniFrame and not
2085 // always) and makes using Mahogany quite annoying
2086 #if 0
2087 wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame,
2088 wxT("unfocusing window that hasn't gained focus properly") );
2089 #endif // 0
2090
2091 g_activeFrameLostFocus = TRUE;
2092 }
2093
2094 // if the focus goes out of our app alltogether, OnIdle() will send
2095 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
2096 // g_sendActivateEvent to -1
2097 g_sendActivateEvent = 0;
2098
2099 wxWindowGTK *winFocus = wxFindFocusedChild(win);
2100 if ( winFocus )
2101 win = winFocus;
2102
2103 g_focusWindow = (wxWindowGTK *)NULL;
2104
2105 #ifdef HAVE_XIM
2106 if (win->m_ic)
2107 gdk_im_end();
2108 #endif
2109
2110 #if wxUSE_CARET
2111 // caret needs to be informed about focus change
2112 wxCaret *caret = win->GetCaret();
2113 if ( caret )
2114 {
2115 caret->OnKillFocus();
2116 }
2117 #endif // wxUSE_CARET
2118
2119 // don't send the window a kill focus event if it thinks that it doesn't
2120 // have focus already
2121 if ( win->m_hasFocus )
2122 {
2123 win->m_hasFocus = FALSE;
2124
2125 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
2126 event.SetEventObject( win );
2127
2128 if (win->GetEventHandler()->ProcessEvent( event ))
2129 {
2130 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
2131 return TRUE;
2132 }
2133 }
2134
2135 return FALSE;
2136 }
2137
2138 //-----------------------------------------------------------------------------
2139 // "enter_notify_event"
2140 //-----------------------------------------------------------------------------
2141
2142 static
2143 gint gtk_window_enter_callback( GtkWidget *widget,
2144 GdkEventCrossing *gdk_event,
2145 wxWindowGTK *win )
2146 {
2147 DEBUG_MAIN_THREAD
2148
2149 if (g_isIdle)
2150 wxapp_install_idle_handler();
2151
2152 if (!win->m_hasVMT) return FALSE;
2153 if (g_blockEventsOnDrag) return FALSE;
2154
2155 // Event was emitted after a grab
2156 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
2157
2158 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
2159
2160 int x = 0;
2161 int y = 0;
2162 GdkModifierType state = (GdkModifierType)0;
2163
2164 gdk_window_get_pointer( widget->window, &x, &y, &state );
2165
2166 wxMouseEvent event( wxEVT_ENTER_WINDOW );
2167 InitMouseEvent(win, event, gdk_event);
2168 wxPoint pt = win->GetClientAreaOrigin();
2169 event.m_x = x + pt.x;
2170 event.m_y = y + pt.y;
2171
2172 if (win->GetEventHandler()->ProcessEvent( event ))
2173 {
2174 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
2175 return TRUE;
2176 }
2177
2178 return FALSE;
2179 }
2180
2181 //-----------------------------------------------------------------------------
2182 // "leave_notify_event"
2183 //-----------------------------------------------------------------------------
2184
2185 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
2186 {
2187 DEBUG_MAIN_THREAD
2188
2189 if (g_isIdle)
2190 wxapp_install_idle_handler();
2191
2192 if (!win->m_hasVMT) return FALSE;
2193 if (g_blockEventsOnDrag) return FALSE;
2194
2195 // Event was emitted after an ungrab
2196 if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
2197
2198 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
2199
2200 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
2201 event.SetTimestamp( gdk_event->time );
2202 event.SetEventObject( win );
2203
2204 int x = 0;
2205 int y = 0;
2206 GdkModifierType state = (GdkModifierType)0;
2207
2208 gdk_window_get_pointer( widget->window, &x, &y, &state );
2209
2210 event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
2211 event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
2212 event.m_altDown = (state & GDK_MOD1_MASK) != 0;
2213 event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
2214 event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
2215 event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
2216 event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
2217
2218 wxPoint pt = win->GetClientAreaOrigin();
2219 event.m_x = x + pt.x;
2220 event.m_y = y + pt.y;
2221
2222 if (win->GetEventHandler()->ProcessEvent( event ))
2223 {
2224 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
2225 return TRUE;
2226 }
2227
2228 return FALSE;
2229 }
2230
2231 //-----------------------------------------------------------------------------
2232 // "value_changed" from m_vAdjust
2233 //-----------------------------------------------------------------------------
2234
2235 static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
2236 SCROLLBAR_CBACK_ARG
2237 wxWindowGTK *win )
2238 {
2239 DEBUG_MAIN_THREAD
2240
2241 if (g_isIdle)
2242 wxapp_install_idle_handler();
2243
2244 if (g_blockEventsOnDrag) return;
2245
2246 if (!win->m_hasVMT) return;
2247
2248 float diff = adjust->value - win->m_oldVerticalPos;
2249 if (fabs(diff) < 0.2) return;
2250
2251 win->m_oldVerticalPos = adjust->value;
2252
2253 #ifndef __WXGTK20__
2254 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
2255 #endif
2256 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
2257
2258 int value = (int)(adjust->value+0.5);
2259
2260 wxScrollWinEvent event( command, value, wxVERTICAL );
2261 event.SetEventObject( win );
2262 win->GetEventHandler()->ProcessEvent( event );
2263 }
2264
2265 //-----------------------------------------------------------------------------
2266 // "value_changed" from m_hAdjust
2267 //-----------------------------------------------------------------------------
2268
2269 static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
2270 SCROLLBAR_CBACK_ARG
2271 wxWindowGTK *win )
2272 {
2273 DEBUG_MAIN_THREAD
2274
2275 if (g_isIdle)
2276 wxapp_install_idle_handler();
2277
2278 if (g_blockEventsOnDrag) return;
2279 if (!win->m_hasVMT) return;
2280
2281 float diff = adjust->value - win->m_oldHorizontalPos;
2282 if (fabs(diff) < 0.2) return;
2283
2284 #ifndef __WXGTK20__
2285 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
2286 #endif
2287 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
2288
2289 win->m_oldHorizontalPos = adjust->value;
2290
2291 int value = (int)(adjust->value+0.5);
2292
2293 wxScrollWinEvent event( command, value, wxHORIZONTAL );
2294 event.SetEventObject( win );
2295 win->GetEventHandler()->ProcessEvent( event );
2296 }
2297
2298 //-----------------------------------------------------------------------------
2299 // "button_press_event" from scrollbar
2300 //-----------------------------------------------------------------------------
2301
2302 static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
2303 GdkEventButton *gdk_event,
2304 wxWindowGTK *win)
2305 {
2306 DEBUG_MAIN_THREAD
2307
2308 if (g_isIdle)
2309 wxapp_install_idle_handler();
2310
2311
2312 g_blockEventsOnScroll = TRUE;
2313
2314 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2315 #ifndef __WXGTK20__
2316 win->m_isScrolling = (gdk_event->window == widget->slider);
2317 #endif
2318
2319 return FALSE;
2320 }
2321
2322 //-----------------------------------------------------------------------------
2323 // "button_release_event" from scrollbar
2324 //-----------------------------------------------------------------------------
2325
2326 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
2327 GdkEventButton *WXUNUSED(gdk_event),
2328 wxWindowGTK *win)
2329 {
2330 DEBUG_MAIN_THREAD
2331
2332 // don't test here as we can release the mouse while being over
2333 // a different window than the slider
2334 //
2335 // if (gdk_event->window != widget->slider) return FALSE;
2336
2337 g_blockEventsOnScroll = FALSE;
2338
2339 if (win->m_isScrolling)
2340 {
2341 wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
2342 int value = -1;
2343 int dir = -1;
2344
2345 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
2346 if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
2347 {
2348 value = (int)(win->m_hAdjust->value+0.5);
2349 dir = wxHORIZONTAL;
2350 }
2351 if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
2352 {
2353 value = (int)(win->m_vAdjust->value+0.5);
2354 dir = wxVERTICAL;
2355 }
2356
2357 wxScrollWinEvent event( command, value, dir );
2358 event.SetEventObject( win );
2359 win->GetEventHandler()->ProcessEvent( event );
2360 }
2361
2362 win->m_isScrolling = FALSE;
2363
2364 return FALSE;
2365 }
2366
2367 // ----------------------------------------------------------------------------
2368 // this wxWindowBase function is implemented here (in platform-specific file)
2369 // because it is static and so couldn't be made virtual
2370 // ----------------------------------------------------------------------------
2371
2372 wxWindow *wxWindowBase::FindFocus()
2373 {
2374 // the cast is necessary when we compile in wxUniversal mode
2375 return (wxWindow *)g_focusWindow;
2376 }
2377
2378
2379 //-----------------------------------------------------------------------------
2380 // "realize" from m_widget
2381 //-----------------------------------------------------------------------------
2382
2383 /* We cannot set colours and fonts before the widget has
2384 been realized, so we do this directly after realization. */
2385
2386 static gint
2387 gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
2388 {
2389 DEBUG_MAIN_THREAD
2390
2391 if (g_isIdle)
2392 wxapp_install_idle_handler();
2393
2394 #ifdef __WXGTK20__
2395 if (win->m_imData)
2396 {
2397 GtkPizza *pizza = GTK_PIZZA( m_widget );
2398 gtk_im_context_set_client_window( win->m_imData->context,
2399 pizza->bin_window );
2400 }
2401 #endif
2402
2403 wxWindowCreateEvent event( win );
2404 event.SetEventObject( win );
2405 win->GetEventHandler()->ProcessEvent( event );
2406
2407 return FALSE;
2408 }
2409
2410 //-----------------------------------------------------------------------------
2411 // "size_allocate"
2412 //-----------------------------------------------------------------------------
2413
2414 static
2415 void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2416 GtkAllocation *WXUNUSED(alloc),
2417 wxWindow *win )
2418 {
2419 if (g_isIdle)
2420 wxapp_install_idle_handler();
2421
2422 if (!win->m_hasScrolling) return;
2423
2424 int client_width = 0;
2425 int client_height = 0;
2426 win->GetClientSize( &client_width, &client_height );
2427 if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2428 return;
2429
2430 win->m_oldClientWidth = client_width;
2431 win->m_oldClientHeight = client_height;
2432
2433 if (!win->m_nativeSizeEvent)
2434 {
2435 wxSizeEvent event( win->GetSize(), win->GetId() );
2436 event.SetEventObject( win );
2437 win->GetEventHandler()->ProcessEvent( event );
2438 }
2439 }
2440
2441
2442 #ifdef HAVE_XIM
2443 #define WXUNUSED_UNLESS_XIM(param) param
2444 #else
2445 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2446 #endif
2447
2448 /* Resize XIM window */
2449
2450 static
2451 void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2452 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
2453 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
2454 {
2455 if (g_isIdle)
2456 wxapp_install_idle_handler();
2457
2458 #ifdef HAVE_XIM
2459 if (!win->m_ic)
2460 return;
2461
2462 if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2463 {
2464 gint width, height;
2465
2466 gdk_window_get_size (widget->window, &width, &height);
2467 win->m_icattr->preedit_area.width = width;
2468 win->m_icattr->preedit_area.height = height;
2469 gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2470 }
2471 #endif // HAVE_XIM
2472 }
2473
2474 //-----------------------------------------------------------------------------
2475 // "realize" from m_wxwindow
2476 //-----------------------------------------------------------------------------
2477
2478 /* Initialize XIM support */
2479
2480 static gint
2481 gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
2482 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
2483 {
2484 if (g_isIdle)
2485 wxapp_install_idle_handler();
2486
2487 #ifdef HAVE_XIM
2488 if (win->m_ic) return FALSE;
2489 if (!widget) return FALSE;
2490 if (!gdk_im_ready()) return FALSE;
2491
2492 win->m_icattr = gdk_ic_attr_new();
2493 if (!win->m_icattr) return FALSE;
2494
2495 gint width, height;
2496 GdkEventMask mask;
2497 GdkColormap *colormap;
2498 GdkICAttr *attr = win->m_icattr;
2499 unsigned attrmask = GDK_IC_ALL_REQ;
2500 GdkIMStyle style;
2501 GdkIMStyle supported_style = (GdkIMStyle)
2502 (GDK_IM_PREEDIT_NONE |
2503 GDK_IM_PREEDIT_NOTHING |
2504 GDK_IM_PREEDIT_POSITION |
2505 GDK_IM_STATUS_NONE |
2506 GDK_IM_STATUS_NOTHING);
2507
2508 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2509 supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
2510
2511 attr->style = style = gdk_im_decide_style (supported_style);
2512 attr->client_window = widget->window;
2513
2514 if ((colormap = gtk_widget_get_colormap (widget)) !=
2515 gtk_widget_get_default_colormap ())
2516 {
2517 attrmask |= GDK_IC_PREEDIT_COLORMAP;
2518 attr->preedit_colormap = colormap;
2519 }
2520
2521 attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2522 attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2523 attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2524 attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2525
2526 switch (style & GDK_IM_PREEDIT_MASK)
2527 {
2528 case GDK_IM_PREEDIT_POSITION:
2529 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2530 {
2531 g_warning ("over-the-spot style requires fontset");
2532 break;
2533 }
2534
2535 gdk_window_get_size (widget->window, &width, &height);
2536
2537 attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2538 attr->spot_location.x = 0;
2539 attr->spot_location.y = height;
2540 attr->preedit_area.x = 0;
2541 attr->preedit_area.y = 0;
2542 attr->preedit_area.width = width;
2543 attr->preedit_area.height = height;
2544 attr->preedit_fontset = widget->style->font;
2545
2546 break;
2547 }
2548
2549 win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2550
2551 if (win->m_ic == NULL)
2552 g_warning ("Can't create input context.");
2553 else
2554 {
2555 mask = gdk_window_get_events (widget->window);
2556 mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2557 gdk_window_set_events (widget->window, mask);
2558
2559 if (GTK_WIDGET_HAS_FOCUS(widget))
2560 gdk_im_begin (win->m_ic, widget->window);
2561 }
2562 #endif // HAVE_XIM
2563
2564 return FALSE;
2565 }
2566
2567 //-----------------------------------------------------------------------------
2568 // InsertChild for wxWindowGTK.
2569 //-----------------------------------------------------------------------------
2570
2571 /* Callback for wxWindowGTK. This very strange beast has to be used because
2572 * C++ has no virtual methods in a constructor. We have to emulate a
2573 * virtual function here as wxNotebook requires a different way to insert
2574 * a child in it. I had opted for creating a wxNotebookPage window class
2575 * which would have made this superfluous (such in the MDI window system),
2576 * but no-one was listening to me... */
2577
2578 static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
2579 {
2580 /* the window might have been scrolled already, do we
2581 have to adapt the position */
2582 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2583 child->m_x += pizza->xoffset;
2584 child->m_y += pizza->yoffset;
2585
2586 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
2587 GTK_WIDGET(child->m_widget),
2588 child->m_x,
2589 child->m_y,
2590 child->m_width,
2591 child->m_height );
2592 }
2593
2594 //-----------------------------------------------------------------------------
2595 // global functions
2596 //-----------------------------------------------------------------------------
2597
2598 wxWindow *wxGetActiveWindow()
2599 {
2600 return wxWindow::FindFocus();
2601 }
2602
2603 //-----------------------------------------------------------------------------
2604 // wxWindowGTK
2605 //-----------------------------------------------------------------------------
2606
2607 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2608 // method
2609 #ifdef __WXUNIVERSAL__
2610 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2611 #else // __WXGTK__
2612 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
2613 #endif // __WXUNIVERSAL__/__WXGTK__
2614
2615 void wxWindowGTK::Init()
2616 {
2617 // GTK specific
2618 m_widget = (GtkWidget *) NULL;
2619 m_wxwindow = (GtkWidget *) NULL;
2620 m_focusWidget = (GtkWidget *) NULL;
2621
2622 // position/size
2623 m_x = 0;
2624 m_y = 0;
2625 m_width = 0;
2626 m_height = 0;
2627
2628 m_sizeSet = FALSE;
2629 m_hasVMT = FALSE;
2630 m_needParent = TRUE;
2631 m_isBeingDeleted = FALSE;
2632
2633 m_noExpose = FALSE;
2634 m_nativeSizeEvent = FALSE;
2635
2636 m_hasScrolling = FALSE;
2637 m_isScrolling = FALSE;
2638
2639 m_hAdjust = (GtkAdjustment*) NULL;
2640 m_vAdjust = (GtkAdjustment*) NULL;
2641 m_oldHorizontalPos =
2642 m_oldVerticalPos = 0.0;
2643 m_oldClientWidth =
2644 m_oldClientHeight = 0;
2645
2646 m_resizing = FALSE;
2647
2648 m_insertCallback = (wxInsertChildFunction) NULL;
2649
2650 m_acceptsFocus = FALSE;
2651 m_hasFocus = FALSE;
2652
2653 m_clipPaintRegion = FALSE;
2654
2655 m_cursor = *wxSTANDARD_CURSOR;
2656
2657 #ifdef __WXGTK20__
2658 m_imData = NULL;
2659 m_x11Context = NULL;
2660 m_dirtyTabOrder = false;
2661 #else
2662 #ifdef HAVE_XIM
2663 m_ic = (GdkIC*) NULL;
2664 m_icattr = (GdkICAttr*) NULL;
2665 #endif
2666 #endif
2667 }
2668
2669 wxWindowGTK::wxWindowGTK()
2670 {
2671 Init();
2672 }
2673
2674 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2675 wxWindowID id,
2676 const wxPoint &pos,
2677 const wxSize &size,
2678 long style,
2679 const wxString &name )
2680 {
2681 Init();
2682
2683 Create( parent, id, pos, size, style, name );
2684 }
2685
2686 bool wxWindowGTK::Create( wxWindow *parent,
2687 wxWindowID id,
2688 const wxPoint &pos,
2689 const wxSize &size,
2690 long style,
2691 const wxString &name )
2692 {
2693 if (!PreCreation( parent, pos, size ) ||
2694 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2695 {
2696 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2697 return FALSE;
2698 }
2699
2700 m_insertCallback = wxInsertChildInWindow;
2701
2702 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
2703 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
2704
2705 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2706
2707 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2708 scroll_class->scrollbar_spacing = 0;
2709
2710 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2711
2712 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2713 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
2714
2715 m_wxwindow = gtk_pizza_new();
2716
2717 #ifndef __WXUNIVERSAL__
2718 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2719
2720 if (HasFlag(wxRAISED_BORDER))
2721 {
2722 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
2723 }
2724 else if (HasFlag(wxSUNKEN_BORDER))
2725 {
2726 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
2727 }
2728 else if (HasFlag(wxSIMPLE_BORDER))
2729 {
2730 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
2731 }
2732 else
2733 {
2734 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
2735 }
2736 #endif // __WXUNIVERSAL__
2737
2738 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2739
2740 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2741 m_acceptsFocus = TRUE;
2742
2743 // I _really_ don't want scrollbars in the beginning
2744 m_vAdjust->lower = 0.0;
2745 m_vAdjust->upper = 1.0;
2746 m_vAdjust->value = 0.0;
2747 m_vAdjust->step_increment = 1.0;
2748 m_vAdjust->page_increment = 1.0;
2749 m_vAdjust->page_size = 5.0;
2750 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2751 m_hAdjust->lower = 0.0;
2752 m_hAdjust->upper = 1.0;
2753 m_hAdjust->value = 0.0;
2754 m_hAdjust->step_increment = 1.0;
2755 m_hAdjust->page_increment = 1.0;
2756 m_hAdjust->page_size = 5.0;
2757 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2758
2759 // these handlers block mouse events to any window during scrolling such as
2760 // motion events and prevent GTK and wxWidgets from fighting over where the
2761 // slider should be
2762
2763 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
2764 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2765
2766 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
2767 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2768
2769 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
2770 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2771
2772 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
2773 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2774
2775 // these handlers get notified when screen updates are required either when
2776 // scrolling or when the window size (and therefore scrollbar configuration)
2777 // has changed
2778
2779 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2780 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2781 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2782 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2783
2784 gtk_widget_show( m_wxwindow );
2785
2786 if (m_parent)
2787 m_parent->DoAddChild( this );
2788
2789 m_focusWidget = m_wxwindow;
2790
2791 PostCreation();
2792
2793 return TRUE;
2794 }
2795
2796 wxWindowGTK::~wxWindowGTK()
2797 {
2798 SendDestroyEvent();
2799
2800 if (g_focusWindow == this)
2801 g_focusWindow = NULL;
2802
2803 if (g_activeFrame == this)
2804 g_activeFrame = NULL;
2805
2806 if ( g_delayedFocus == this )
2807 g_delayedFocus = NULL;
2808
2809 m_isBeingDeleted = TRUE;
2810 m_hasVMT = FALSE;
2811
2812 if (m_widget)
2813 Show( FALSE );
2814
2815 DestroyChildren();
2816
2817 #ifdef HAVE_XIM
2818 if (m_ic)
2819 gdk_ic_destroy (m_ic);
2820 if (m_icattr)
2821 gdk_ic_attr_destroy (m_icattr);
2822 #endif
2823
2824 if (m_wxwindow)
2825 {
2826 gtk_widget_destroy( m_wxwindow );
2827 m_wxwindow = (GtkWidget*) NULL;
2828 }
2829
2830 if (m_widget)
2831 {
2832 gtk_widget_destroy( m_widget );
2833 m_widget = (GtkWidget*) NULL;
2834 }
2835
2836 #ifdef __WXGTK20__
2837 delete m_imData;
2838 #endif
2839 }
2840
2841 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2842 {
2843 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
2844
2845 // Use either the given size, or the default if -1 is given.
2846 // See wxWindowBase for these functions.
2847 m_width = WidthDefault(size.x) ;
2848 m_height = HeightDefault(size.y);
2849
2850 m_x = (int)pos.x;
2851 m_y = (int)pos.y;
2852
2853 return TRUE;
2854 }
2855
2856 void wxWindowGTK::PostCreation()
2857 {
2858 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2859
2860 if (m_wxwindow)
2861 {
2862 if (!m_noExpose)
2863 {
2864 // these get reported to wxWidgets -> wxPaintEvent
2865
2866 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2867
2868 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2869 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2870
2871 #ifndef __WXGTK20__
2872 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2873 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
2874
2875 if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
2876 {
2877 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2878 GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2879 }
2880 #else
2881 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), !HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
2882 #endif
2883 }
2884
2885 #ifdef __WXGTK20__
2886 // Create input method handler
2887 m_imData = new wxGtkIMData;
2888
2889 // Cannot handle drawing preedited text yet
2890 gtk_im_context_set_use_preedit( m_imData->context, FALSE );
2891
2892 g_signal_connect (G_OBJECT (m_imData->context), "commit",
2893 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2894 #endif
2895
2896 // these are called when the "sunken" or "raised" borders are drawn
2897 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2898 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2899
2900 #ifndef __WXGTK20__
2901 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2902 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
2903 #endif
2904 }
2905
2906 // focus handling
2907
2908 if (m_focusWidget == NULL)
2909 m_focusWidget = m_widget;
2910
2911 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2912 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2913
2914 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
2915 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2916
2917 // connect to the various key and mouse handlers
2918
2919 GtkWidget *connect_widget = GetConnectWidget();
2920
2921 ConnectWidget( connect_widget );
2922
2923 /* We cannot set colours, fonts and cursors before the widget has
2924 been realized, so we do this directly after realization */
2925 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
2926 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2927
2928 if (m_wxwindow)
2929 {
2930 // Catch native resize events
2931 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2932 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2933
2934 // Initialize XIM support
2935 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2936 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
2937
2938 // And resize XIM window
2939 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2940 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
2941 }
2942
2943 if ( !GTK_IS_COMBO(m_widget))
2944 {
2945 // This is needed if we want to add our windows into native
2946 // GTK control, such as the toolbar. With this callback, the
2947 // toolbar gets to know the correct size (the one set by the
2948 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2949 // when moving to GTK 2.0.
2950 gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
2951 GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback),
2952 (gpointer) this );
2953 }
2954
2955 m_hasVMT = TRUE;
2956
2957 // unless the window was created initially hidden (i.e. Hide() had been
2958 // called before Create()), we should show it at GTK+ level as well
2959 if ( IsShown() )
2960 gtk_widget_show( m_widget );
2961 }
2962
2963 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2964 {
2965 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2966 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
2967
2968 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2969 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2970
2971 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2972 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2973
2974 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2975 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2976
2977 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2978 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2979
2980 #ifdef __WXGTK20__
2981 gtk_signal_connect( GTK_OBJECT(widget), "scroll_event",
2982 GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this );
2983 #endif
2984
2985 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2986 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2987
2988 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2989 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2990 }
2991
2992 bool wxWindowGTK::Destroy()
2993 {
2994 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2995
2996 m_hasVMT = FALSE;
2997
2998 return wxWindowBase::Destroy();
2999 }
3000
3001 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
3002 {
3003 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
3004 }
3005
3006 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
3007 {
3008 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3009 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
3010
3011 /*
3012 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
3013 */
3014
3015 if (m_resizing) return; /* I don't like recursions */
3016 m_resizing = TRUE;
3017
3018 int currentX, currentY;
3019 GetPosition(&currentX, &currentY);
3020 if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
3021 x = currentX;
3022 if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
3023 y = currentY;
3024 AdjustForParentClientOrigin(x, y, sizeFlags);
3025
3026 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
3027 {
3028 /* don't set the size for children of wxNotebook, just take the values. */
3029 m_x = x;
3030 m_y = y;
3031 m_width = width;
3032 m_height = height;
3033 }
3034 else
3035 {
3036 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
3037 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
3038 {
3039 if (x != -1) m_x = x + pizza->xoffset;
3040 if (y != -1) m_y = y + pizza->yoffset;
3041 }
3042 else
3043 {
3044 m_x = x + pizza->xoffset;
3045 m_y = y + pizza->yoffset;
3046 }
3047
3048 // calculate the best size if we should auto size the window
3049 if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
3050 ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
3051 {
3052 const wxSize sizeBest = GetBestSize();
3053 if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
3054 width = sizeBest.x;
3055 if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
3056 height = sizeBest.y;
3057 }
3058
3059 if (width != -1)
3060 m_width = width;
3061 if (height != -1)
3062 m_height = height;
3063
3064 int minWidth = GetMinWidth(),
3065 minHeight = GetMinHeight(),
3066 maxWidth = GetMaxWidth(),
3067 maxHeight = GetMaxHeight();
3068
3069 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
3070 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
3071 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
3072 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
3073
3074 int border = 0;
3075 int bottom_border = 0;
3076
3077 #ifndef __WXGTK20__
3078 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
3079 {
3080 /* the default button has a border around it */
3081 border = 6;
3082 bottom_border = 5;
3083 }
3084 #endif
3085
3086 DoMoveWindow( m_x-border,
3087 m_y-border,
3088 m_width+2*border,
3089 m_height+border+bottom_border );
3090 }
3091
3092 if (m_hasScrolling)
3093 {
3094 /* Sometimes the client area changes size without the
3095 whole windows's size changing, but if the whole
3096 windows's size doesn't change, no wxSizeEvent will
3097 normally be sent. Here we add an extra test if
3098 the client test has been changed and this will
3099 be used then. */
3100 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
3101 }
3102
3103 /*
3104 wxPrintf( "OnSize sent from " );
3105 if (GetClassInfo() && GetClassInfo()->GetClassName())
3106 wxPrintf( GetClassInfo()->GetClassName() );
3107 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3108 */
3109
3110 if (!m_nativeSizeEvent)
3111 {
3112 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
3113 event.SetEventObject( this );
3114 GetEventHandler()->ProcessEvent( event );
3115 }
3116
3117 m_resizing = FALSE;
3118 }
3119
3120 void wxWindowGTK::OnInternalIdle()
3121 {
3122 #ifdef __WXGTK20__
3123 if ( m_dirtyTabOrder )
3124 RealizeTabOrder();
3125 #endif
3126
3127 // Update invalidated regions.
3128 GtkUpdate();
3129
3130 // Synthetize activate events.
3131 if ( g_sendActivateEvent != -1 )
3132 {
3133 bool activate = g_sendActivateEvent != 0;
3134
3135 // do it only once
3136 g_sendActivateEvent = -1;
3137
3138 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
3139 }
3140
3141 if ( g_activeFrameLostFocus )
3142 {
3143 if ( g_activeFrame )
3144 {
3145 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
3146 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
3147 event.SetEventObject(g_activeFrame);
3148 g_activeFrame->GetEventHandler()->ProcessEvent(event);
3149 g_activeFrame = NULL;
3150 }
3151 g_activeFrameLostFocus = FALSE;
3152 }
3153
3154 wxCursor cursor = m_cursor;
3155 if (g_globalCursor.Ok()) cursor = g_globalCursor;
3156
3157 if (cursor.Ok())
3158 {
3159 /* I now set the cursor anew in every OnInternalIdle call
3160 as setting the cursor in a parent window also effects the
3161 windows above so that checking for the current cursor is
3162 not possible. */
3163
3164 if (m_wxwindow)
3165 {
3166 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
3167 if (window)
3168 gdk_window_set_cursor( window, cursor.GetCursor() );
3169
3170 if (!g_globalCursor.Ok())
3171 cursor = *wxSTANDARD_CURSOR;
3172
3173 window = m_widget->window;
3174 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
3175 gdk_window_set_cursor( window, cursor.GetCursor() );
3176
3177 }
3178 else
3179 {
3180
3181 GdkWindow *window = m_widget->window;
3182 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
3183 gdk_window_set_cursor( window, cursor.GetCursor() );
3184
3185 }
3186 }
3187
3188 if (wxUpdateUIEvent::CanUpdate(this))
3189 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
3190 }
3191
3192 void wxWindowGTK::DoGetSize( int *width, int *height ) const
3193 {
3194 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3195
3196 if (width) (*width) = m_width;
3197 if (height) (*height) = m_height;
3198 }
3199
3200 void wxWindowGTK::DoSetClientSize( int width, int height )
3201 {
3202 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3203
3204 if (!m_wxwindow)
3205 {
3206 SetSize( width, height );
3207 }
3208 else
3209 {
3210 int dw = 0;
3211 int dh = 0;
3212
3213 #ifndef __WXUNIVERSAL__
3214 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3215 {
3216 /* when using GTK 1.2 we set the shadow border size to 2 */
3217 dw += 2 * 2;
3218 dh += 2 * 2;
3219 }
3220 if (HasFlag(wxSIMPLE_BORDER))
3221 {
3222 /* when using GTK 1.2 we set the simple border size to 1 */
3223 dw += 1 * 2;
3224 dh += 1 * 2;
3225 }
3226 #endif // __WXUNIVERSAL__
3227
3228 if (m_hasScrolling)
3229 {
3230 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3231
3232 GtkRequisition vscroll_req;
3233 vscroll_req.width = 2;
3234 vscroll_req.height = 2;
3235 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3236 (scroll_window->vscrollbar, &vscroll_req );
3237
3238 GtkRequisition hscroll_req;
3239 hscroll_req.width = 2;
3240 hscroll_req.height = 2;
3241 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3242 (scroll_window->hscrollbar, &hscroll_req );
3243
3244 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3245
3246 if (scroll_window->vscrollbar_visible)
3247 {
3248 dw += vscroll_req.width;
3249 dw += scroll_class->scrollbar_spacing;
3250 }
3251
3252 if (scroll_window->hscrollbar_visible)
3253 {
3254 dh += hscroll_req.height;
3255 dh += scroll_class->scrollbar_spacing;
3256 }
3257 }
3258
3259 SetSize( width+dw, height+dh );
3260 }
3261 }
3262
3263 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
3264 {
3265 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3266
3267 if (!m_wxwindow)
3268 {
3269 if (width) (*width) = m_width;
3270 if (height) (*height) = m_height;
3271 }
3272 else
3273 {
3274 int dw = 0;
3275 int dh = 0;
3276
3277 #ifndef __WXUNIVERSAL__
3278 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3279 {
3280 /* when using GTK 1.2 we set the shadow border size to 2 */
3281 dw += 2 * 2;
3282 dh += 2 * 2;
3283 }
3284 if (HasFlag(wxSIMPLE_BORDER))
3285 {
3286 /* when using GTK 1.2 we set the simple border size to 1 */
3287 dw += 1 * 2;
3288 dh += 1 * 2;
3289 }
3290 #endif // __WXUNIVERSAL__
3291
3292 if (m_hasScrolling)
3293 {
3294 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
3295
3296 GtkRequisition vscroll_req;
3297 vscroll_req.width = 2;
3298 vscroll_req.height = 2;
3299 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
3300 (scroll_window->vscrollbar, &vscroll_req );
3301
3302 GtkRequisition hscroll_req;
3303 hscroll_req.width = 2;
3304 hscroll_req.height = 2;
3305 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
3306 (scroll_window->hscrollbar, &hscroll_req );
3307
3308 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
3309
3310 if (scroll_window->vscrollbar_visible)
3311 {
3312 dw += vscroll_req.width;
3313 dw += scroll_class->scrollbar_spacing;
3314 }
3315
3316 if (scroll_window->hscrollbar_visible)
3317 {
3318 dh += hscroll_req.height;
3319 dh += scroll_class->scrollbar_spacing;
3320 }
3321 }
3322
3323 if (width) (*width) = m_width - dw;
3324 if (height) (*height) = m_height - dh;
3325 }
3326
3327 /*
3328 printf( "GetClientSize, name %s ", GetName().c_str() );
3329 if (width) printf( " width = %d", (*width) );
3330 if (height) printf( " height = %d", (*height) );
3331 printf( "\n" );
3332 */
3333 }
3334
3335 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
3336 {
3337 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3338
3339 int dx = 0;
3340 int dy = 0;
3341 if (m_parent && m_parent->m_wxwindow)
3342 {
3343 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
3344 dx = pizza->xoffset;
3345 dy = pizza->yoffset;
3346 }
3347
3348 if (x) (*x) = m_x - dx;
3349 if (y) (*y) = m_y - dy;
3350 }
3351
3352 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
3353 {
3354 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3355
3356 if (!m_widget->window) return;
3357
3358 GdkWindow *source = (GdkWindow *) NULL;
3359 if (m_wxwindow)
3360 source = GTK_PIZZA(m_wxwindow)->bin_window;
3361 else
3362 source = m_widget->window;
3363
3364 int org_x = 0;
3365 int org_y = 0;
3366 gdk_window_get_origin( source, &org_x, &org_y );
3367
3368 if (!m_wxwindow)
3369 {
3370 if (GTK_WIDGET_NO_WINDOW (m_widget))
3371 {
3372 org_x += m_widget->allocation.x;
3373 org_y += m_widget->allocation.y;
3374 }
3375 }
3376
3377 if (x) *x += org_x;
3378 if (y) *y += org_y;
3379 }
3380
3381 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
3382 {
3383 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3384
3385 if (!m_widget->window) return;
3386
3387 GdkWindow *source = (GdkWindow *) NULL;
3388 if (m_wxwindow)
3389 source = GTK_PIZZA(m_wxwindow)->bin_window;
3390 else
3391 source = m_widget->window;
3392
3393 int org_x = 0;
3394 int org_y = 0;
3395 gdk_window_get_origin( source, &org_x, &org_y );
3396
3397 if (!m_wxwindow)
3398 {
3399 if (GTK_WIDGET_NO_WINDOW (m_widget))
3400 {
3401 org_x += m_widget->allocation.x;
3402 org_y += m_widget->allocation.y;
3403 }
3404 }
3405
3406 if (x) *x -= org_x;
3407 if (y) *y -= org_y;
3408 }
3409
3410 bool wxWindowGTK::Show( bool show )
3411 {
3412 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3413
3414 if (!wxWindowBase::Show(show))
3415 {
3416 // nothing to do
3417 return FALSE;
3418 }
3419
3420 if (show)
3421 gtk_widget_show( m_widget );
3422 else
3423 gtk_widget_hide( m_widget );
3424
3425 wxShowEvent eventShow(GetId(), show);
3426 eventShow.m_eventObject = this;
3427
3428 GetEventHandler()->ProcessEvent(eventShow);
3429
3430 return TRUE;
3431 }
3432
3433 static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
3434 {
3435 win->OnParentEnable(enable);
3436
3437 // Recurse, so that children have the opportunity to Do The Right Thing
3438 // and reset colours that have been messed up by a parent's (really ancestor's)
3439 // Enable call
3440 for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
3441 node;
3442 node = node->GetNext() )
3443 {
3444 wxWindow *child = node->GetData();
3445 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3446 wxWindowNotifyEnable(child, enable);
3447 }
3448 }
3449
3450 bool wxWindowGTK::Enable( bool enable )
3451 {
3452 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3453
3454 if (!wxWindowBase::Enable(enable))
3455 {
3456 // nothing to do
3457 return FALSE;
3458 }
3459
3460 gtk_widget_set_sensitive( m_widget, enable );
3461 if ( m_wxwindow )
3462 gtk_widget_set_sensitive( m_wxwindow, enable );
3463
3464 wxWindowNotifyEnable(this, enable);
3465
3466 return TRUE;
3467 }
3468
3469 int wxWindowGTK::GetCharHeight() const
3470 {
3471 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3472
3473 wxFont font = GetFont();
3474 wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
3475
3476 #ifdef __WXGTK20__
3477 PangoContext *context = NULL;
3478 if (m_widget)
3479 context = gtk_widget_get_pango_context( m_widget );
3480
3481 if (!context)
3482 return 0;
3483
3484 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3485 PangoLayout *layout = pango_layout_new(context);
3486 pango_layout_set_font_description(layout, desc);
3487 pango_layout_set_text(layout, "H", 1);
3488 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3489
3490 PangoRectangle rect;
3491 pango_layout_line_get_extents(line, NULL, &rect);
3492
3493 g_object_unref( G_OBJECT( layout ) );
3494
3495 return (int) PANGO_PIXELS(rect.height);
3496 #else
3497 GdkFont *gfont = font.GetInternalFont( 1.0 );
3498
3499 return gfont->ascent + gfont->descent;
3500 #endif
3501 }
3502
3503 int wxWindowGTK::GetCharWidth() const
3504 {
3505 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3506
3507 wxFont font = GetFont();
3508 wxCHECK_MSG( font.Ok(), 8, wxT("invalid font") );
3509
3510 #ifdef __WXGTK20__
3511 PangoContext *context = NULL;
3512 if (m_widget)
3513 context = gtk_widget_get_pango_context( m_widget );
3514
3515 if (!context)
3516 return 0;
3517
3518 PangoFontDescription *desc = font.GetNativeFontInfo()->description;
3519 PangoLayout *layout = pango_layout_new(context);
3520 pango_layout_set_font_description(layout, desc);
3521 pango_layout_set_text(layout, "g", 1);
3522 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3523
3524 PangoRectangle rect;
3525 pango_layout_line_get_extents(line, NULL, &rect);
3526
3527 g_object_unref( G_OBJECT( layout ) );
3528
3529 return (int) PANGO_PIXELS(rect.width);
3530 #else
3531 GdkFont *gfont = font.GetInternalFont( 1.0 );
3532
3533 return gdk_string_width( gfont, "g" );
3534 #endif
3535 }
3536
3537 void wxWindowGTK::GetTextExtent( const wxString& string,
3538 int *x,
3539 int *y,
3540 int *descent,
3541 int *externalLeading,
3542 const wxFont *theFont ) const
3543 {
3544 wxFont fontToUse = theFont ? *theFont : GetFont();
3545
3546 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3547
3548 if (string.IsEmpty())
3549 {
3550 if (x) (*x) = 0;
3551 if (y) (*y) = 0;
3552 return;
3553 }
3554
3555 #ifdef __WXGTK20__
3556 PangoContext *context = NULL;
3557 if (m_widget)
3558 context = gtk_widget_get_pango_context( m_widget );
3559
3560 if (!context)
3561 {
3562 if (x) (*x) = 0;
3563 if (y) (*y) = 0;
3564 return;
3565 }
3566
3567 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3568 PangoLayout *layout = pango_layout_new(context);
3569 pango_layout_set_font_description(layout, desc);
3570 {
3571 #if wxUSE_UNICODE
3572 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
3573 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3574 #else
3575 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
3576 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
3577 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3578 #endif
3579 }
3580
3581 PangoRectangle rect;
3582 pango_layout_get_extents(layout, NULL, &rect);
3583
3584 if (x) (*x) = (wxCoord) PANGO_PIXELS(rect.width);
3585 if (y) (*y) = (wxCoord) PANGO_PIXELS(rect.height);
3586 if (descent)
3587 {
3588 PangoLayoutIter *iter = pango_layout_get_iter(layout);
3589 int baseline = pango_layout_iter_get_baseline(iter);
3590 pango_layout_iter_free(iter);
3591 *descent = *y - PANGO_PIXELS(baseline);
3592 }
3593 if (externalLeading) (*externalLeading) = 0; // ??
3594
3595 g_object_unref( G_OBJECT( layout ) );
3596 #else
3597 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
3598 if (x) (*x) = gdk_string_width( font, wxGTK_CONV( string ) );
3599 if (y) (*y) = font->ascent + font->descent;
3600 if (descent) (*descent) = font->descent;
3601 if (externalLeading) (*externalLeading) = 0; // ??
3602 #endif
3603 }
3604
3605 void wxWindowGTK::SetFocus()
3606 {
3607 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3608
3609 if ( m_hasFocus )
3610 {
3611 // don't do anything if we already have focus
3612 return;
3613 }
3614
3615 if (m_wxwindow)
3616 {
3617 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3618 {
3619 gtk_widget_grab_focus (m_wxwindow);
3620 }
3621 }
3622 else if (m_widget)
3623 {
3624 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3625 {
3626 if (!GTK_WIDGET_REALIZED(m_widget))
3627 {
3628 // we can't set the focus to the widget now so we remember that
3629 // it should be focused and will do it later, during the idle
3630 // time, as soon as we can
3631 wxLogTrace(TRACE_FOCUS,
3632 _T("Delaying setting focus to %s(%s)"),
3633 GetClassInfo()->GetClassName(), GetLabel().c_str());
3634
3635 g_delayedFocus = this;
3636 }
3637 else
3638 {
3639 wxLogTrace(TRACE_FOCUS,
3640 _T("Setting focus to %s(%s)"),
3641 GetClassInfo()->GetClassName(), GetLabel().c_str());
3642
3643 gtk_widget_grab_focus (m_widget);
3644 }
3645 }
3646 else if (GTK_IS_CONTAINER(m_widget))
3647 {
3648 SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );
3649 }
3650 else
3651 {
3652 wxLogTrace(TRACE_FOCUS,
3653 _T("Can't set focus to %s(%s)"),
3654 GetClassInfo()->GetClassName(), GetLabel().c_str());
3655 }
3656 }
3657 }
3658
3659 bool wxWindowGTK::AcceptsFocus() const
3660 {
3661 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
3662 }
3663
3664 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3665 {
3666 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3667
3668 wxWindowGTK *oldParent = m_parent,
3669 *newParent = (wxWindowGTK *)newParentBase;
3670
3671 wxASSERT( GTK_IS_WIDGET(m_widget) );
3672
3673 if ( !wxWindowBase::Reparent(newParent) )
3674 return FALSE;
3675
3676 wxASSERT( GTK_IS_WIDGET(m_widget) );
3677
3678 /* prevent GTK from deleting the widget arbitrarily */
3679 gtk_widget_ref( m_widget );
3680
3681 if (oldParent)
3682 {
3683 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3684 }
3685
3686 wxASSERT( GTK_IS_WIDGET(m_widget) );
3687
3688 if (newParent)
3689 {
3690 /* insert GTK representation */
3691 (*(newParent->m_insertCallback))(newParent, this);
3692 }
3693
3694 /* reverse: prevent GTK from deleting the widget arbitrarily */
3695 gtk_widget_unref( m_widget );
3696
3697 return TRUE;
3698 }
3699
3700 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3701 {
3702 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3703
3704 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3705
3706 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3707
3708 /* add to list */
3709 AddChild( child );
3710
3711 /* insert GTK representation */
3712 (*m_insertCallback)(this, child);
3713 }
3714
3715 #ifdef __WXGTK20__
3716
3717 void wxWindowGTK::AddChild(wxWindowBase *child)
3718 {
3719 wxWindowBase::AddChild(child);
3720 m_dirtyTabOrder = true;
3721 if (g_isIdle)
3722 wxapp_install_idle_handler();
3723 }
3724
3725 void wxWindowGTK::RemoveChild(wxWindowBase *child)
3726 {
3727 wxWindowBase::RemoveChild(child);
3728 m_dirtyTabOrder = true;
3729 if (g_isIdle)
3730 wxapp_install_idle_handler();
3731 }
3732
3733 void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move)
3734 {
3735 wxWindowBase::DoMoveInTabOrder(win, move);
3736 m_dirtyTabOrder = true;
3737 if (g_isIdle)
3738 wxapp_install_idle_handler();
3739 }
3740
3741 void wxWindowGTK::RealizeTabOrder()
3742 {
3743 if (m_wxwindow)
3744 {
3745 if (m_children.size() > 0)
3746 {
3747 GList *chain = NULL;
3748
3749 for (wxWindowList::const_iterator i = m_children.begin();
3750 i != m_children.end(); ++i)
3751 {
3752 chain = g_list_prepend(chain, (*i)->m_widget);
3753 }
3754
3755 chain = g_list_reverse(chain);
3756
3757 gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain);
3758 g_list_free(chain);
3759 }
3760 else
3761 {
3762 gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow));
3763 }
3764 }
3765
3766 m_dirtyTabOrder = false;
3767 }
3768
3769 #endif // __WXGTK20__
3770
3771 void wxWindowGTK::Raise()
3772 {
3773 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3774
3775 if (!m_widget->window) return;
3776
3777 gdk_window_raise( m_widget->window );
3778 }
3779
3780 void wxWindowGTK::Lower()
3781 {
3782 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3783
3784 if (!m_widget->window) return;
3785
3786 gdk_window_lower( m_widget->window );
3787 }
3788
3789 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3790 {
3791 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3792
3793 if (cursor == m_cursor)
3794 return FALSE;
3795
3796 if (g_isIdle)
3797 wxapp_install_idle_handler();
3798
3799 if (cursor == wxNullCursor)
3800 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3801 else
3802 return wxWindowBase::SetCursor( cursor );
3803 }
3804
3805 void wxWindowGTK::WarpPointer( int x, int y )
3806 {
3807 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3808
3809 // We provide this function ourselves as it is
3810 // missing in GDK (top of this file).
3811
3812 GdkWindow *window = (GdkWindow*) NULL;
3813 if (m_wxwindow)
3814 window = GTK_PIZZA(m_wxwindow)->bin_window;
3815 else
3816 window = GetConnectWidget()->window;
3817
3818 if (window)
3819 gdk_window_warp_pointer( window, x, y );
3820 }
3821
3822
3823 void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3824 {
3825 if (!m_widget) return;
3826 if (!m_widget->window) return;
3827
3828 #ifndef __WXGTK20__
3829 if (g_isIdle)
3830 wxapp_install_idle_handler();
3831
3832 wxRect myRect(0,0,0,0);
3833 if (m_wxwindow && rect)
3834 {
3835 myRect.SetSize(wxSize( m_wxwindow->allocation.width,
3836 m_wxwindow->allocation.height));
3837 myRect.Intersect(*rect);
3838 if (!myRect.width || !myRect.height)
3839 // nothing to do, rectangle is empty
3840 return;
3841 rect = &myRect;
3842 }
3843
3844 if (eraseBackground && m_wxwindow && m_wxwindow->window)
3845 {
3846 if (rect)
3847 {
3848 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3849 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
3850 }
3851 else
3852 {
3853 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3854 m_clearRegion.Clear();
3855 m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3856 }
3857 }
3858
3859 if (rect)
3860 {
3861 if (m_wxwindow)
3862 {
3863 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3864 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
3865 }
3866 else
3867 {
3868 GdkRectangle gdk_rect;
3869 gdk_rect.x = rect->x;
3870 gdk_rect.y = rect->y;
3871 gdk_rect.width = rect->width;
3872 gdk_rect.height = rect->height;
3873 gtk_widget_draw( m_widget, &gdk_rect );
3874 }
3875 }
3876 else
3877 {
3878 if (m_wxwindow)
3879 {
3880 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3881 m_updateRegion.Clear();
3882 m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3883 }
3884 else
3885 {
3886 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
3887 }
3888 }
3889 #else
3890 if (m_wxwindow)
3891 {
3892 if (rect)
3893 {
3894 GdkRectangle gdk_rect;
3895 gdk_rect.x = rect->x;
3896 gdk_rect.y = rect->y;
3897 gdk_rect.width = rect->width;
3898 gdk_rect.height = rect->height;
3899 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
3900 }
3901 else
3902 {
3903 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
3904 }
3905 }
3906 #endif
3907 }
3908
3909 void wxWindowGTK::Update()
3910 {
3911 GtkUpdate();
3912 }
3913
3914 void wxWindowGTK::GtkUpdate()
3915 {
3916 #ifdef __WXGTK20__
3917 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3918 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
3919 #else
3920 if (!m_updateRegion.IsEmpty())
3921 GtkSendPaintEvents();
3922 #endif
3923 }
3924
3925 void wxWindowGTK::GtkSendPaintEvents()
3926 {
3927 if (!m_wxwindow)
3928 {
3929 #ifndef __WXGTK20__
3930 m_clearRegion.Clear();
3931 #endif
3932 m_updateRegion.Clear();
3933 return;
3934 }
3935
3936 // Clip to paint region in wxClientDC
3937 m_clipPaintRegion = TRUE;
3938
3939 // widget to draw on
3940 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
3941
3942 if (GetThemeEnabled())
3943 {
3944 // find ancestor from which to steal background
3945 wxWindow *parent = GetParent();
3946 while (parent && !parent->IsTopLevel())
3947 parent = parent->GetParent();
3948 if (!parent)
3949 parent = (wxWindow*)this;
3950
3951 wxRegionIterator upd( m_updateRegion );
3952 while (upd)
3953 {
3954 GdkRectangle rect;
3955 rect.x = upd.GetX();
3956 rect.y = upd.GetY();
3957 rect.width = upd.GetWidth();
3958 rect.height = upd.GetHeight();
3959
3960 gtk_paint_flat_box( parent->m_widget->style,
3961 pizza->bin_window,
3962 (GtkStateType)GTK_WIDGET_STATE(m_wxwindow),
3963 GTK_SHADOW_NONE,
3964 &rect,
3965 parent->m_widget,
3966 (char *)"base",
3967 0, 0, -1, -1 );
3968
3969 upd ++;
3970 }
3971 }
3972 else
3973
3974 #ifdef __WXGTK20__
3975 {
3976 wxWindowDC dc( (wxWindow*)this );
3977 dc.SetClippingRegion( m_updateRegion );
3978
3979 wxEraseEvent erase_event( GetId(), &dc );
3980 erase_event.SetEventObject( this );
3981
3982 GetEventHandler()->ProcessEvent(erase_event);
3983 }
3984 #else
3985 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
3986 {
3987 wxWindowDC dc( (wxWindow*)this );
3988 if (m_clearRegion.IsEmpty())
3989 dc.SetClippingRegion( m_updateRegion );
3990 else
3991 dc.SetClippingRegion( m_clearRegion );
3992
3993 wxEraseEvent erase_event( GetId(), &dc );
3994 erase_event.SetEventObject( this );
3995
3996 if (!GetEventHandler()->ProcessEvent(erase_event))
3997 {
3998 if (!g_eraseGC)
3999 {
4000 g_eraseGC = gdk_gc_new( pizza->bin_window );
4001 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4002 }
4003 gdk_gc_set_foreground( g_eraseGC, GetBackgroundColour().GetColor() );
4004
4005 wxRegionIterator upd( m_clearRegion );
4006 while (upd)
4007 {
4008 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
4009 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
4010 upd ++;
4011 }
4012 }
4013 m_clearRegion.Clear();
4014 }
4015 #endif
4016
4017 wxNcPaintEvent nc_paint_event( GetId() );
4018 nc_paint_event.SetEventObject( this );
4019 GetEventHandler()->ProcessEvent( nc_paint_event );
4020
4021 wxPaintEvent paint_event( GetId() );
4022 paint_event.SetEventObject( this );
4023 GetEventHandler()->ProcessEvent( paint_event );
4024
4025 m_clipPaintRegion = FALSE;
4026
4027 #ifndef __WXUNIVERSAL__
4028 #ifndef __WXGTK20__
4029 // The following code will result in all window-less widgets
4030 // being redrawn because the wxWidgets class is allowed to
4031 // paint over the window-less widgets.
4032
4033 GList *children = pizza->children;
4034 while (children)
4035 {
4036 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
4037 children = children->next;
4038
4039 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
4040 GTK_WIDGET_DRAWABLE (child->widget))
4041 {
4042 // Get intersection of widget area and update region
4043 wxRegion region( m_updateRegion );
4044
4045 GdkEventExpose gdk_event;
4046 gdk_event.type = GDK_EXPOSE;
4047 gdk_event.window = pizza->bin_window;
4048 gdk_event.count = 0;
4049
4050 wxRegionIterator upd( m_updateRegion );
4051 while (upd)
4052 {
4053 GdkRectangle rect;
4054 rect.x = upd.GetX();
4055 rect.y = upd.GetY();
4056 rect.width = upd.GetWidth();
4057 rect.height = upd.GetHeight();
4058
4059 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
4060 {
4061 gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
4062 }
4063
4064 upd ++;
4065 }
4066 }
4067 }
4068 #endif
4069 #endif
4070
4071 m_updateRegion.Clear();
4072 }
4073
4074 void wxWindowGTK::ClearBackground()
4075 {
4076 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4077
4078 #ifndef __WXGTK20__
4079 if (m_wxwindow && m_wxwindow->window)
4080 {
4081 m_clearRegion.Clear();
4082 wxSize size( GetClientSize() );
4083 m_clearRegion.Union( 0,0,size.x,size.y );
4084
4085 // Better do this in idle?
4086 GtkUpdate();
4087 }
4088 #endif
4089 }
4090
4091 #if wxUSE_TOOLTIPS
4092 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
4093 {
4094 wxWindowBase::DoSetToolTip(tip);
4095
4096 if (m_tooltip)
4097 m_tooltip->Apply( (wxWindow *)this );
4098 }
4099
4100 void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
4101 {
4102 wxString tmp( tip );
4103 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxGTK_CONV(tmp), (gchar*) NULL );
4104 }
4105 #endif // wxUSE_TOOLTIPS
4106
4107 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
4108 {
4109 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4110
4111 if (!wxWindowBase::SetBackgroundColour(colour))
4112 return false;
4113
4114 if (colour.Ok())
4115 {
4116 // We need the pixel value e.g. for background clearing.
4117 m_backgroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
4118 }
4119
4120 // apply style change (forceStyle=true so that new style is applied
4121 // even if the bg colour changed from valid to wxNullColour):
4122 ApplyWidgetStyle(true);
4123
4124 return true;
4125 }
4126
4127 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
4128 {
4129 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4130
4131 if (!wxWindowBase::SetForegroundColour(colour))
4132 {
4133 return false;
4134 }
4135
4136 if (colour.Ok())
4137 {
4138 // We need the pixel value e.g. for background clearing.
4139 m_foregroundColour.CalcPixel(gtk_widget_get_colormap(m_widget));
4140 }
4141
4142 // apply style change (forceStyle=true so that new style is applied
4143 // even if the bg colour changed from valid to wxNullColour):
4144 ApplyWidgetStyle(true);
4145
4146 return true;
4147 }
4148
4149 #ifdef __WXGTK20__
4150 PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
4151 {
4152 return gtk_widget_get_pango_context( m_widget );
4153 }
4154
4155 PangoContext *wxWindowGTK::GtkGetPangoX11Context()
4156 {
4157 if (!m_x11Context)
4158 m_x11Context = pango_x_get_context( gdk_display );
4159
4160 return m_x11Context;
4161 }
4162 #endif
4163
4164 GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle)
4165 {
4166 // do we need to apply any changes at all?
4167 if ( !forceStyle &&
4168 !m_font.Ok() &&
4169 !m_foregroundColour.Ok() && !m_backgroundColour.Ok() )
4170 {
4171 return NULL;
4172 }
4173
4174 GtkRcStyle *style = gtk_rc_style_new();
4175
4176 if ( m_font.Ok() )
4177 {
4178 #ifdef __WXGTK20__
4179 style->font_desc =
4180 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
4181 #else
4182 wxString xfontname = m_font.GetNativeFontInfo()->GetXFontName();
4183 style->fontset_name = g_strdup(xfontname.c_str());
4184 #endif
4185 }
4186
4187 if ( m_foregroundColour.Ok() )
4188 {
4189 GdkColor *fg = m_foregroundColour.GetColor();
4190
4191 style->fg[GTK_STATE_NORMAL] = *fg;
4192 style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG;
4193
4194 style->fg[GTK_STATE_PRELIGHT] = *fg;
4195 style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG;
4196
4197 style->fg[GTK_STATE_ACTIVE] = *fg;
4198 style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG;
4199 }
4200
4201 if ( m_backgroundColour.Ok() )
4202 {
4203 GdkColor *bg = m_backgroundColour.GetColor();
4204
4205 style->bg[GTK_STATE_NORMAL] = *bg;
4206 style->base[GTK_STATE_NORMAL] = *bg;
4207 style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags)
4208 (style->color_flags[GTK_STATE_NORMAL] | GTK_RC_BG | GTK_RC_BASE);
4209
4210 style->bg[GTK_STATE_PRELIGHT] = *bg;
4211 style->base[GTK_STATE_PRELIGHT] = *bg;
4212 style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags)
4213 (style->color_flags[GTK_STATE_PRELIGHT] | GTK_RC_BG | GTK_RC_BASE);
4214
4215 style->bg[GTK_STATE_ACTIVE] = *bg;
4216 style->base[GTK_STATE_ACTIVE] = *bg;
4217 style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags)
4218 (style->color_flags[GTK_STATE_ACTIVE] | GTK_RC_BG | GTK_RC_BASE);
4219
4220 style->bg[GTK_STATE_INSENSITIVE] = *bg;
4221 style->base[GTK_STATE_INSENSITIVE] = *bg;
4222 style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags)
4223 (style->color_flags[GTK_STATE_INSENSITIVE] | GTK_RC_BG | GTK_RC_BASE);
4224 }
4225
4226 return style;
4227 }
4228
4229 void wxWindowGTK::ApplyWidgetStyle(bool forceStyle)
4230 {
4231 GtkRcStyle *style = CreateWidgetStyle(forceStyle);
4232 if ( style )
4233 {
4234 DoApplyWidgetStyle(style);
4235 gtk_rc_style_unref(style);
4236 }
4237 }
4238
4239 void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style)
4240 {
4241 if (m_wxwindow)
4242 // should we also do m_widget in this case?
4243 gtk_widget_modify_style(m_wxwindow, style);
4244 else
4245 gtk_widget_modify_style(m_widget, style);
4246 }
4247
4248
4249 //-----------------------------------------------------------------------------
4250 // Pop-up menu stuff
4251 //-----------------------------------------------------------------------------
4252
4253 #if wxUSE_MENUS_NATIVE
4254
4255 extern "C"
4256 void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
4257 {
4258 *is_waiting = FALSE;
4259 }
4260
4261 static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
4262 {
4263 menu->SetInvokingWindow( win );
4264 wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst();
4265 while (node)
4266 {
4267 wxMenuItem *menuitem = node->GetData();
4268 if (menuitem->IsSubMenu())
4269 {
4270 SetInvokingWindow( menuitem->GetSubMenu(), win );
4271 }
4272
4273 node = node->GetNext();
4274 }
4275 }
4276
4277 extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
4278 gint *x, gint *y,
4279 #ifdef __WXGTK20__
4280 gboolean * WXUNUSED(whatever),
4281 #endif
4282 gpointer user_data )
4283 {
4284 // ensure that the menu appears entirely on screen
4285 GtkRequisition req;
4286 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4287
4288 wxSize sizeScreen = wxGetDisplaySize();
4289 wxPoint *pos = (wxPoint*)user_data;
4290
4291 gint xmax = sizeScreen.x - req.width,
4292 ymax = sizeScreen.y - req.height;
4293
4294 *x = pos->x < xmax ? pos->x : xmax;
4295 *y = pos->y < ymax ? pos->y : ymax;
4296 }
4297
4298 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
4299 {
4300 wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
4301
4302 wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") );
4303
4304 SetInvokingWindow( menu, this );
4305
4306 menu->UpdateUI();
4307
4308 bool is_waiting = true;
4309
4310 gtk_signal_connect( GTK_OBJECT(menu->m_menu),
4311 "hide",
4312 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
4313 (gpointer)&is_waiting );
4314
4315 wxPoint pos;
4316 gpointer userdata;
4317 GtkMenuPositionFunc posfunc;
4318 if ( x == -1 && y == -1 )
4319 {
4320 // use GTK's default positioning algorithm
4321 userdata = NULL;
4322 posfunc = NULL;
4323 }
4324 else
4325 {
4326 pos = ClientToScreen(wxPoint(x, y));
4327 userdata = &pos;
4328 posfunc = wxPopupMenuPositionCallback;
4329 }
4330
4331 gtk_menu_popup(
4332 GTK_MENU(menu->m_menu),
4333 (GtkWidget *) NULL, // parent menu shell
4334 (GtkWidget *) NULL, // parent menu item
4335 posfunc, // function to position it
4336 userdata, // client data
4337 0, // button used to activate it
4338 #ifdef __WXGTK20__
4339 gtk_get_current_event_time()
4340 #else
4341 gs_timeLastClick // the time of activation
4342 #endif
4343 );
4344
4345 while (is_waiting)
4346 {
4347 gtk_main_iteration();
4348 }
4349
4350 return true;
4351 }
4352
4353 #endif // wxUSE_MENUS_NATIVE
4354
4355 #if wxUSE_DRAG_AND_DROP
4356
4357 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
4358 {
4359 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4360
4361 GtkWidget *dnd_widget = GetConnectWidget();
4362
4363 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
4364
4365 if (m_dropTarget) delete m_dropTarget;
4366 m_dropTarget = dropTarget;
4367
4368 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
4369 }
4370
4371 #endif // wxUSE_DRAG_AND_DROP
4372
4373 GtkWidget* wxWindowGTK::GetConnectWidget()
4374 {
4375 GtkWidget *connect_widget = m_widget;
4376 if (m_wxwindow) connect_widget = m_wxwindow;
4377
4378 return connect_widget;
4379 }
4380
4381 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
4382 {
4383 if (m_wxwindow)
4384 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
4385
4386 return (window == m_widget->window);
4387 }
4388
4389 bool wxWindowGTK::SetFont( const wxFont &font )
4390 {
4391 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
4392
4393 if (!wxWindowBase::SetFont(font))
4394 return false;
4395
4396 // apply style change (forceStyle=true so that new style is applied
4397 // even if the font changed from valid to wxNullFont):
4398 ApplyWidgetStyle(true);
4399
4400 return true;
4401 }
4402
4403 void wxWindowGTK::DoCaptureMouse()
4404 {
4405 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4406
4407 GdkWindow *window = (GdkWindow*) NULL;
4408 if (m_wxwindow)
4409 window = GTK_PIZZA(m_wxwindow)->bin_window;
4410 else
4411 window = GetConnectWidget()->window;
4412
4413 wxCHECK_RET( window, _T("CaptureMouse() failed") );
4414
4415 wxCursor* cursor = & m_cursor;
4416 if (!cursor->Ok())
4417 cursor = wxSTANDARD_CURSOR;
4418
4419 gdk_pointer_grab( window, FALSE,
4420 (GdkEventMask)
4421 (GDK_BUTTON_PRESS_MASK |
4422 GDK_BUTTON_RELEASE_MASK |
4423 GDK_POINTER_MOTION_HINT_MASK |
4424 GDK_POINTER_MOTION_MASK),
4425 (GdkWindow *) NULL,
4426 cursor->GetCursor(),
4427 (guint32)GDK_CURRENT_TIME );
4428 g_captureWindow = this;
4429 g_captureWindowHasMouse = TRUE;
4430 }
4431
4432 void wxWindowGTK::DoReleaseMouse()
4433 {
4434 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4435
4436 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
4437
4438 g_captureWindow = (wxWindowGTK*) NULL;
4439
4440 GdkWindow *window = (GdkWindow*) NULL;
4441 if (m_wxwindow)
4442 window = GTK_PIZZA(m_wxwindow)->bin_window;
4443 else
4444 window = GetConnectWidget()->window;
4445
4446 if (!window)
4447 return;
4448
4449 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4450 }
4451
4452 /* static */
4453 wxWindow *wxWindowBase::GetCapture()
4454 {
4455 return (wxWindow *)g_captureWindow;
4456 }
4457
4458 bool wxWindowGTK::IsRetained() const
4459 {
4460 return FALSE;
4461 }
4462
4463 void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
4464 int range, bool refresh )
4465 {
4466 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4467
4468 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4469
4470 m_hasScrolling = TRUE;
4471
4472 if (orient == wxHORIZONTAL)
4473 {
4474 float fpos = (float)pos;
4475 float frange = (float)range;
4476 float fthumb = (float)thumbVisible;
4477 if (fpos > frange-fthumb) fpos = frange-fthumb;
4478 if (fpos < 0.0) fpos = 0.0;
4479
4480 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
4481 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
4482 {
4483 SetScrollPos( orient, pos, refresh );
4484 return;
4485 }
4486
4487 m_oldHorizontalPos = fpos;
4488
4489 m_hAdjust->lower = 0.0;
4490 m_hAdjust->upper = frange;
4491 m_hAdjust->value = fpos;
4492 m_hAdjust->step_increment = 1.0;
4493 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
4494 m_hAdjust->page_size = fthumb;
4495 }
4496 else
4497 {
4498 float fpos = (float)pos;
4499 float frange = (float)range;
4500 float fthumb = (float)thumbVisible;
4501 if (fpos > frange-fthumb) fpos = frange-fthumb;
4502 if (fpos < 0.0) fpos = 0.0;
4503
4504 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4505 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4506 {
4507 SetScrollPos( orient, pos, refresh );
4508 return;
4509 }
4510
4511 m_oldVerticalPos = fpos;
4512
4513 m_vAdjust->lower = 0.0;
4514 m_vAdjust->upper = frange;
4515 m_vAdjust->value = fpos;
4516 m_vAdjust->step_increment = 1.0;
4517 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4518 m_vAdjust->page_size = fthumb;
4519 }
4520
4521 if (orient == wxHORIZONTAL)
4522 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4523 else
4524 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
4525 }
4526
4527 void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
4528 {
4529 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4530
4531 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4532
4533 if (orient == wxHORIZONTAL)
4534 {
4535 float fpos = (float)pos;
4536 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
4537 if (fpos < 0.0) fpos = 0.0;
4538 m_oldHorizontalPos = fpos;
4539
4540 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
4541 m_hAdjust->value = fpos;
4542 }
4543 else
4544 {
4545 float fpos = (float)pos;
4546 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
4547 if (fpos < 0.0) fpos = 0.0;
4548 m_oldVerticalPos = fpos;
4549
4550 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
4551 m_vAdjust->value = fpos;
4552 }
4553
4554 if (m_wxwindow->window)
4555 {
4556 if (orient == wxHORIZONTAL)
4557 {
4558 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
4559 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4560
4561 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
4562
4563 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
4564 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4565 }
4566 else
4567 {
4568 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
4569 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4570
4571 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
4572
4573 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
4574 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4575 }
4576 }
4577 }
4578
4579 int wxWindowGTK::GetScrollThumb( int orient ) const
4580 {
4581 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4582
4583 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4584
4585 if (orient == wxHORIZONTAL)
4586 return (int)(m_hAdjust->page_size+0.5);
4587 else
4588 return (int)(m_vAdjust->page_size+0.5);
4589 }
4590
4591 int wxWindowGTK::GetScrollPos( int orient ) const
4592 {
4593 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4594
4595 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4596
4597 if (orient == wxHORIZONTAL)
4598 return (int)(m_hAdjust->value+0.5);
4599 else
4600 return (int)(m_vAdjust->value+0.5);
4601 }
4602
4603 int wxWindowGTK::GetScrollRange( int orient ) const
4604 {
4605 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4606
4607 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4608
4609 if (orient == wxHORIZONTAL)
4610 return (int)(m_hAdjust->upper+0.5);
4611 else
4612 return (int)(m_vAdjust->upper+0.5);
4613 }
4614
4615 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4616 {
4617 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4618
4619 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4620
4621 // No scrolling requested.
4622 if ((dx == 0) && (dy == 0)) return;
4623
4624 #ifndef __WXGTK20__
4625 if (!m_updateRegion.IsEmpty())
4626 {
4627 m_updateRegion.Offset( dx, dy );
4628
4629 int cw = 0;
4630 int ch = 0;
4631 GetClientSize( &cw, &ch );
4632 m_updateRegion.Intersect( 0, 0, cw, ch );
4633 }
4634
4635 if (!m_clearRegion.IsEmpty())
4636 {
4637 m_clearRegion.Offset( dx, dy );
4638
4639 int cw = 0;
4640 int ch = 0;
4641 GetClientSize( &cw, &ch );
4642 m_clearRegion.Intersect( 0, 0, cw, ch );
4643 }
4644 #endif
4645
4646 m_clipPaintRegion = TRUE;
4647
4648 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
4649
4650 m_clipPaintRegion = FALSE;
4651 }
4652
4653
4654 // Find the wxWindow at the current mouse position, also returning the mouse
4655 // position.
4656 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4657 {
4658 pt = wxGetMousePosition();
4659 wxWindow* found = wxFindWindowAtPoint(pt);
4660 return found;
4661 }
4662
4663 // Get the current mouse position.
4664 wxPoint wxGetMousePosition()
4665 {
4666 /* This crashes when used within wxHelpContext,
4667 so we have to use the X-specific implementation below.
4668 gint x, y;
4669 GdkModifierType *mask;
4670 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4671
4672 return wxPoint(x, y);
4673 */
4674
4675 int x, y;
4676 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4677
4678 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
4679 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4680 Window rootReturn, childReturn;
4681 int rootX, rootY, winX, winY;
4682 unsigned int maskReturn;
4683
4684 XQueryPointer (display,
4685 rootWindow,
4686 &rootReturn,
4687 &childReturn,
4688 &rootX, &rootY, &winX, &winY, &maskReturn);
4689 return wxPoint(rootX, rootY);
4690
4691 }
4692
4693 // ----------------------------------------------------------------------------
4694 // wxDCModule
4695 // ----------------------------------------------------------------------------
4696
4697 class wxWinModule : public wxModule
4698 {
4699 public:
4700 bool OnInit();
4701 void OnExit();
4702
4703 private:
4704 DECLARE_DYNAMIC_CLASS(wxWinModule)
4705 };
4706
4707 IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4708
4709 bool wxWinModule::OnInit()
4710 {
4711 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4712 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4713
4714 return TRUE;
4715 }
4716
4717 void wxWinModule::OnExit()
4718 {
4719 if (g_eraseGC)
4720 gdk_gc_unref( g_eraseGC );
4721 }
4722
4723 // vi:sts=4:sw=4:et
wxWidgets (Impactor)