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