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


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