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