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