]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
projects / wxWidgets.git / blob
? search:


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