]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/window.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Various changes for simplification of focus event
[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 gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindowGTK *win )
1739 {
1740 DEBUG_MAIN_THREAD
1741
1742 if (g_isIdle)
1743 wxapp_install_idle_handler();
1744
1745 if (!win->m_hasVMT) return FALSE;
1746 if (g_blockEventsOnDrag) return FALSE;
1747
1748 // if the focus goes out of our app alltogether, OnIdle() will send
1749 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
1750 // g_sendActivateEvent to -1
1751 g_sendActivateEvent = 0;
1752
1753 wxWindowGTK *winFocus = wxFindFocusedChild(win);
1754 if ( winFocus )
1755 win = winFocus;
1756
1757 g_focusWindow = (wxWindowGTK *)NULL;
1758
1759 #if 0
1760 wxPrintf( "OnKillFocus from " );
1761 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1762 wxPrintf( win->GetClassInfo()->GetClassName() );
1763 wxPrintf( ".\n" );
1764 #endif
1765
1766 #ifdef HAVE_XIM
1767 if (win->m_ic)
1768 gdk_im_end();
1769 #endif
1770
1771 #if wxUSE_CARET
1772 // caret needs to be informed about focus change
1773 wxCaret *caret = win->GetCaret();
1774 if ( caret )
1775 {
1776 caret->OnKillFocus();
1777 }
1778 #endif // wxUSE_CARET
1779
1780 if (win->IsTopLevel())
1781 {
1782 wxActivateEvent event( wxEVT_ACTIVATE, FALSE, win->GetId() );
1783 event.SetEventObject( win );
1784
1785 // ignore return value
1786 win->GetEventHandler()->ProcessEvent( event );
1787 }
1788
1789 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
1790 event.SetEventObject( win );
1791
1792 if (win->GetEventHandler()->ProcessEvent( event ))
1793 {
1794 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
1795 return TRUE;
1796 }
1797
1798 return FALSE;
1799 }
1800
1801 //-----------------------------------------------------------------------------
1802 // "enter_notify_event"
1803 //-----------------------------------------------------------------------------
1804
1805 static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
1806 {
1807 DEBUG_MAIN_THREAD
1808
1809 if (g_isIdle)
1810 wxapp_install_idle_handler();
1811
1812 if (!win->m_hasVMT) return FALSE;
1813 if (g_blockEventsOnDrag) return FALSE;
1814
1815 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1816
1817 wxMouseEvent event( wxEVT_ENTER_WINDOW );
1818 event.SetTimestamp( gdk_event->time );
1819 event.SetEventObject( win );
1820
1821 int x = 0;
1822 int y = 0;
1823 GdkModifierType state = (GdkModifierType)0;
1824
1825 gdk_window_get_pointer( widget->window, &x, &y, &state );
1826
1827 InitMouseEvent(event, gdk_event);
1828
1829 event.m_x = x;
1830 event.m_y = y;
1831
1832 if (win->GetEventHandler()->ProcessEvent( event ))
1833 {
1834 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
1835 return TRUE;
1836 }
1837
1838 return FALSE;
1839 }
1840
1841 //-----------------------------------------------------------------------------
1842 // "leave_notify_event"
1843 //-----------------------------------------------------------------------------
1844
1845 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
1846 {
1847 DEBUG_MAIN_THREAD
1848
1849 if (g_isIdle)
1850 wxapp_install_idle_handler();
1851
1852 if (!win->m_hasVMT) return FALSE;
1853 if (g_blockEventsOnDrag) return FALSE;
1854
1855 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1856
1857 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1858 event.SetTimestamp( gdk_event->time );
1859 event.SetEventObject( win );
1860
1861 int x = 0;
1862 int y = 0;
1863 GdkModifierType state = (GdkModifierType)0;
1864
1865 gdk_window_get_pointer( widget->window, &x, &y, &state );
1866
1867 event.m_shiftDown = (state & GDK_SHIFT_MASK);
1868 event.m_controlDown = (state & GDK_CONTROL_MASK);
1869 event.m_altDown = (state & GDK_MOD1_MASK);
1870 event.m_metaDown = (state & GDK_MOD2_MASK);
1871 event.m_leftDown = (state & GDK_BUTTON1_MASK);
1872 event.m_middleDown = (state & GDK_BUTTON2_MASK);
1873 event.m_rightDown = (state & GDK_BUTTON3_MASK);
1874
1875 event.m_x = x;
1876 event.m_y = y;
1877
1878 if (win->GetEventHandler()->ProcessEvent( event ))
1879 {
1880 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
1881 return TRUE;
1882 }
1883
1884 return FALSE;
1885 }
1886
1887 //-----------------------------------------------------------------------------
1888 // "value_changed" from m_vAdjust
1889 //-----------------------------------------------------------------------------
1890
1891 static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win )
1892 {
1893 DEBUG_MAIN_THREAD
1894
1895 if (g_isIdle)
1896 wxapp_install_idle_handler();
1897
1898 if (g_blockEventsOnDrag) return;
1899
1900 if (!win->m_hasVMT) return;
1901
1902 float diff = adjust->value - win->m_oldVerticalPos;
1903 if (fabs(diff) < 0.2) return;
1904
1905 win->m_oldVerticalPos = adjust->value;
1906
1907 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
1908 GtkRange *range = GTK_RANGE( scrolledWindow->vscrollbar );
1909
1910 wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
1911 if (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
1912 else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD) command = wxEVT_SCROLLWIN_LINEDOWN;
1913 else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
1914 else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD) command = wxEVT_SCROLLWIN_PAGEDOWN;
1915
1916 int value = (int)(adjust->value+0.5);
1917
1918 wxScrollWinEvent event( command, value, wxVERTICAL );
1919 event.SetEventObject( win );
1920 win->GetEventHandler()->ProcessEvent( event );
1921 }
1922
1923 //-----------------------------------------------------------------------------
1924 // "value_changed" from m_hAdjust
1925 //-----------------------------------------------------------------------------
1926
1927 static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindowGTK *win )
1928 {
1929 DEBUG_MAIN_THREAD
1930
1931 if (g_isIdle)
1932 wxapp_install_idle_handler();
1933
1934 if (g_blockEventsOnDrag) return;
1935 if (!win->m_hasVMT) return;
1936
1937 float diff = adjust->value - win->m_oldHorizontalPos;
1938 if (fabs(diff) < 0.2) return;
1939
1940 win->m_oldHorizontalPos = adjust->value;
1941
1942 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
1943 GtkRange *range = GTK_RANGE( scrolledWindow->hscrollbar );
1944
1945 wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
1946 if (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
1947 else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD) command = wxEVT_SCROLLWIN_LINEDOWN;
1948 else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
1949 else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD) command = wxEVT_SCROLLWIN_PAGEDOWN;
1950
1951 int value = (int)(adjust->value+0.5);
1952
1953 wxScrollWinEvent event( command, value, wxHORIZONTAL );
1954 event.SetEventObject( win );
1955 win->GetEventHandler()->ProcessEvent( event );
1956 }
1957
1958 //-----------------------------------------------------------------------------
1959 // "button_press_event" from scrollbar
1960 //-----------------------------------------------------------------------------
1961
1962 static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
1963 GdkEventButton *gdk_event,
1964 wxWindowGTK *win)
1965 {
1966 DEBUG_MAIN_THREAD
1967
1968 if (g_isIdle)
1969 wxapp_install_idle_handler();
1970
1971
1972 g_blockEventsOnScroll = TRUE;
1973 win->m_isScrolling = (gdk_event->window == widget->slider);
1974
1975 return FALSE;
1976 }
1977
1978 //-----------------------------------------------------------------------------
1979 // "button_release_event" from scrollbar
1980 //-----------------------------------------------------------------------------
1981
1982 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
1983 GdkEventButton *WXUNUSED(gdk_event),
1984 wxWindowGTK *win)
1985 {
1986 DEBUG_MAIN_THREAD
1987
1988 // don't test here as we can release the mouse while being over
1989 // a different window than the slider
1990 //
1991 // if (gdk_event->window != widget->slider) return FALSE;
1992
1993 g_blockEventsOnScroll = FALSE;
1994
1995 if (win->m_isScrolling)
1996 {
1997 wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
1998 int value = -1;
1999 int dir = -1;
2000
2001 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
2002 if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
2003 {
2004 value = (int)(win->m_hAdjust->value+0.5);
2005 dir = wxHORIZONTAL;
2006 }
2007 if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
2008 {
2009 value = (int)(win->m_vAdjust->value+0.5);
2010 dir = wxVERTICAL;
2011 }
2012
2013 wxScrollWinEvent event( command, value, dir );
2014 event.SetEventObject( win );
2015 win->GetEventHandler()->ProcessEvent( event );
2016 }
2017
2018 win->m_isScrolling = FALSE;
2019
2020 return FALSE;
2021 }
2022
2023 // ----------------------------------------------------------------------------
2024 // this wxWindowBase function is implemented here (in platform-specific file)
2025 // because it is static and so couldn't be made virtual
2026 // ----------------------------------------------------------------------------
2027
2028 wxWindow *wxWindowBase::FindFocus()
2029 {
2030 // the cast is necessary when we compile in wxUniversal mode
2031 return (wxWindow *)g_focusWindow;
2032 }
2033
2034 //-----------------------------------------------------------------------------
2035 // "realize" from m_widget
2036 //-----------------------------------------------------------------------------
2037
2038 /* We cannot set colours and fonts before the widget has
2039 been realized, so we do this directly after realization. */
2040
2041 static gint
2042 gtk_window_realized_callback( GtkWidget *WXUNUSED(m_widget), wxWindow *win )
2043 {
2044 DEBUG_MAIN_THREAD
2045
2046 if (g_isIdle)
2047 wxapp_install_idle_handler();
2048
2049 if (win->m_delayedBackgroundColour)
2050 win->SetBackgroundColour( win->GetBackgroundColour() );
2051
2052 if (win->m_delayedForegroundColour)
2053 win->SetForegroundColour( win->GetForegroundColour() );
2054
2055 wxWindowCreateEvent event( win );
2056 event.SetEventObject( win );
2057 win->GetEventHandler()->ProcessEvent( event );
2058
2059 return FALSE;
2060 }
2061
2062 //-----------------------------------------------------------------------------
2063 // "size_allocate"
2064 //-----------------------------------------------------------------------------
2065
2066 static
2067 void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2068 GtkAllocation *WXUNUSED(alloc),
2069 wxWindow *win )
2070 {
2071 if (g_isIdle)
2072 wxapp_install_idle_handler();
2073
2074 if (!win->m_hasScrolling) return;
2075
2076 int client_width = 0;
2077 int client_height = 0;
2078 win->GetClientSize( &client_width, &client_height );
2079 if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2080 return;
2081
2082 win->m_oldClientWidth = client_width;
2083 win->m_oldClientHeight = client_height;
2084
2085 if (!win->m_nativeSizeEvent)
2086 {
2087 wxSizeEvent event( win->GetSize(), win->GetId() );
2088 event.SetEventObject( win );
2089 win->GetEventHandler()->ProcessEvent( event );
2090 }
2091 }
2092
2093
2094 #ifdef HAVE_XIM
2095 #define WXUNUSED_UNLESS_XIM(param) param
2096 #else
2097 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2098 #endif
2099
2100 /* Resize XIM window */
2101
2102 static
2103 void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2104 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
2105 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
2106 {
2107 if (g_isIdle)
2108 wxapp_install_idle_handler();
2109
2110 #ifdef HAVE_XIM
2111 if (!win->m_ic)
2112 return;
2113
2114 if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2115 {
2116 gint width, height;
2117
2118 gdk_window_get_size (widget->window, &width, &height);
2119 win->m_icattr->preedit_area.width = width;
2120 win->m_icattr->preedit_area.height = height;
2121 gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2122 }
2123 #endif // HAVE_XIM
2124 }
2125
2126 //-----------------------------------------------------------------------------
2127 // "realize" from m_wxwindow
2128 //-----------------------------------------------------------------------------
2129
2130 /* Initialize XIM support */
2131
2132 static gint
2133 gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
2134 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
2135 {
2136 if (g_isIdle)
2137 wxapp_install_idle_handler();
2138
2139 #ifdef HAVE_XIM
2140 if (win->m_ic) return FALSE;
2141 if (!widget) return FALSE;
2142 if (!gdk_im_ready()) return FALSE;
2143
2144 win->m_icattr = gdk_ic_attr_new();
2145 if (!win->m_icattr) return FALSE;
2146
2147 gint width, height;
2148 GdkEventMask mask;
2149 GdkColormap *colormap;
2150 GdkICAttr *attr = win->m_icattr;
2151 unsigned attrmask = GDK_IC_ALL_REQ;
2152 GdkIMStyle style;
2153 GdkIMStyle supported_style = (GdkIMStyle)
2154 (GDK_IM_PREEDIT_NONE |
2155 GDK_IM_PREEDIT_NOTHING |
2156 GDK_IM_PREEDIT_POSITION |
2157 GDK_IM_STATUS_NONE |
2158 GDK_IM_STATUS_NOTHING);
2159
2160 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2161 supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
2162
2163 attr->style = style = gdk_im_decide_style (supported_style);
2164 attr->client_window = widget->window;
2165
2166 if ((colormap = gtk_widget_get_colormap (widget)) !=
2167 gtk_widget_get_default_colormap ())
2168 {
2169 attrmask |= GDK_IC_PREEDIT_COLORMAP;
2170 attr->preedit_colormap = colormap;
2171 }
2172
2173 attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2174 attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2175 attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2176 attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2177
2178 switch (style & GDK_IM_PREEDIT_MASK)
2179 {
2180 case GDK_IM_PREEDIT_POSITION:
2181 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2182 {
2183 g_warning ("over-the-spot style requires fontset");
2184 break;
2185 }
2186
2187 gdk_window_get_size (widget->window, &width, &height);
2188
2189 attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2190 attr->spot_location.x = 0;
2191 attr->spot_location.y = height;
2192 attr->preedit_area.x = 0;
2193 attr->preedit_area.y = 0;
2194 attr->preedit_area.width = width;
2195 attr->preedit_area.height = height;
2196 attr->preedit_fontset = widget->style->font;
2197
2198 break;
2199 }
2200
2201 win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2202
2203 if (win->m_ic == NULL)
2204 g_warning ("Can't create input context.");
2205 else
2206 {
2207 mask = gdk_window_get_events (widget->window);
2208 mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2209 gdk_window_set_events (widget->window, mask);
2210
2211 if (GTK_WIDGET_HAS_FOCUS(widget))
2212 gdk_im_begin (win->m_ic, widget->window);
2213 }
2214 #endif // HAVE_XIM
2215
2216 return FALSE;
2217 }
2218
2219 //-----------------------------------------------------------------------------
2220 // InsertChild for wxWindowGTK.
2221 //-----------------------------------------------------------------------------
2222
2223 /* Callback for wxWindowGTK. This very strange beast has to be used because
2224 * C++ has no virtual methods in a constructor. We have to emulate a
2225 * virtual function here as wxNotebook requires a different way to insert
2226 * a child in it. I had opted for creating a wxNotebookPage window class
2227 * which would have made this superfluous (such in the MDI window system),
2228 * but no-one was listening to me... */
2229
2230 static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
2231 {
2232 /* the window might have been scrolled already, do we
2233 have to adapt the position */
2234 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2235 child->m_x += pizza->xoffset;
2236 child->m_y += pizza->yoffset;
2237
2238 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
2239 GTK_WIDGET(child->m_widget),
2240 child->m_x,
2241 child->m_y,
2242 child->m_width,
2243 child->m_height );
2244 }
2245
2246 //-----------------------------------------------------------------------------
2247 // global functions
2248 //-----------------------------------------------------------------------------
2249
2250 wxWindow *wxGetActiveWindow()
2251 {
2252 // the cast is necessary when we compile in wxUniversal mode
2253 return (wxWindow *)g_focusWindow;
2254 }
2255
2256 //-----------------------------------------------------------------------------
2257 // wxWindowGTK
2258 //-----------------------------------------------------------------------------
2259
2260 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2261 // method
2262 #ifdef __WXUNIVERSAL__
2263 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2264 #else // __WXGTK__
2265 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
2266 #endif // __WXUNIVERSAL__/__WXGTK__
2267
2268 void wxWindowGTK::Init()
2269 {
2270 // common init
2271 InitBase();
2272
2273 // GTK specific
2274 m_widget = (GtkWidget *) NULL;
2275 m_wxwindow = (GtkWidget *) NULL;
2276 m_focusWidget = (GtkWidget *) NULL;
2277
2278 // position/size
2279 m_x = 0;
2280 m_y = 0;
2281 m_width = 0;
2282 m_height = 0;
2283
2284 m_sizeSet = FALSE;
2285 m_hasVMT = FALSE;
2286 m_needParent = TRUE;
2287 m_isBeingDeleted = FALSE;
2288
2289 m_noExpose = FALSE;
2290 m_nativeSizeEvent = FALSE;
2291
2292 m_hasScrolling = FALSE;
2293 m_isScrolling = FALSE;
2294
2295 m_hAdjust = (GtkAdjustment*) NULL;
2296 m_vAdjust = (GtkAdjustment*) NULL;
2297 m_oldHorizontalPos = 0.0;
2298 m_oldVerticalPos = 0.0;
2299
2300 m_resizing = FALSE;
2301 m_widgetStyle = (GtkStyle*) NULL;
2302
2303 m_insertCallback = (wxInsertChildFunction) NULL;
2304
2305 m_isStaticBox = FALSE;
2306 m_isRadioButton = FALSE;
2307 m_isFrame = FALSE;
2308 m_acceptsFocus = FALSE;
2309
2310 m_clipPaintRegion = FALSE;
2311
2312 m_cursor = *wxSTANDARD_CURSOR;
2313
2314 m_delayedForegroundColour = FALSE;
2315 m_delayedBackgroundColour = FALSE;
2316
2317 #ifdef HAVE_XIM
2318 m_ic = (GdkIC*) NULL;
2319 m_icattr = (GdkICAttr*) NULL;
2320 #endif
2321 }
2322
2323 wxWindowGTK::wxWindowGTK()
2324 {
2325 Init();
2326 }
2327
2328 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2329 wxWindowID id,
2330 const wxPoint &pos,
2331 const wxSize &size,
2332 long style,
2333 const wxString &name )
2334 {
2335 Init();
2336
2337 Create( parent, id, pos, size, style, name );
2338 }
2339
2340 bool wxWindowGTK::Create( wxWindow *parent,
2341 wxWindowID id,
2342 const wxPoint &pos,
2343 const wxSize &size,
2344 long style,
2345 const wxString &name )
2346 {
2347 if (!PreCreation( parent, pos, size ) ||
2348 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2349 {
2350 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2351 return FALSE;
2352 }
2353
2354 m_insertCallback = wxInsertChildInWindow;
2355
2356 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
2357 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
2358
2359 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2360
2361 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2362 scroll_class->scrollbar_spacing = 0;
2363
2364 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2365
2366 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2367 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
2368
2369 m_wxwindow = gtk_pizza_new();
2370
2371 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2372
2373 #ifndef __WXUNIVERSAL__
2374 #if (GTK_MINOR_VERSION > 0)
2375 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2376
2377 if (HasFlag(wxRAISED_BORDER))
2378 {
2379 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
2380 }
2381 else if (HasFlag(wxSUNKEN_BORDER))
2382 {
2383 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
2384 }
2385 else if (HasFlag(wxSIMPLE_BORDER))
2386 {
2387 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
2388 }
2389 else
2390 {
2391 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
2392 }
2393 #else // GTK_MINOR_VERSION == 0
2394 GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
2395
2396 if (HasFlag(wxRAISED_BORDER))
2397 {
2398 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
2399 }
2400 else if (HasFlag(wxSUNKEN_BORDER))
2401 {
2402 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
2403 }
2404 else
2405 {
2406 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
2407 }
2408 #endif // GTK_MINOR_VERSION
2409 #endif // __WXUNIVERSAL__
2410
2411 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2412 m_acceptsFocus = TRUE;
2413
2414 #if (GTK_MINOR_VERSION == 0)
2415 // shut the viewport up
2416 gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
2417 gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
2418 #endif // GTK_MINOR_VERSION == 0
2419
2420 // I _really_ don't want scrollbars in the beginning
2421 m_vAdjust->lower = 0.0;
2422 m_vAdjust->upper = 1.0;
2423 m_vAdjust->value = 0.0;
2424 m_vAdjust->step_increment = 1.0;
2425 m_vAdjust->page_increment = 1.0;
2426 m_vAdjust->page_size = 5.0;
2427 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2428 m_hAdjust->lower = 0.0;
2429 m_hAdjust->upper = 1.0;
2430 m_hAdjust->value = 0.0;
2431 m_hAdjust->step_increment = 1.0;
2432 m_hAdjust->page_increment = 1.0;
2433 m_hAdjust->page_size = 5.0;
2434 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2435
2436 // these handlers block mouse events to any window during scrolling such as
2437 // motion events and prevent GTK and wxWindows from fighting over where the
2438 // slider should be
2439
2440 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
2441 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2442
2443 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
2444 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2445
2446 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
2447 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2448
2449 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
2450 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2451
2452 // these handlers get notified when screen updates are required either when
2453 // scrolling or when the window size (and therefore scrollbar configuration)
2454 // has changed
2455
2456 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2457 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2458 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2459 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2460
2461 gtk_widget_show( m_wxwindow );
2462
2463 if (m_parent)
2464 m_parent->DoAddChild( this );
2465
2466 m_focusWidget = m_wxwindow;
2467
2468 PostCreation();
2469
2470 Show( TRUE );
2471
2472 return TRUE;
2473 }
2474
2475 wxWindowGTK::~wxWindowGTK()
2476 {
2477 if (g_focusWindow == this)
2478 g_focusWindow = NULL;
2479
2480 m_isBeingDeleted = TRUE;
2481 m_hasVMT = FALSE;
2482
2483 if (m_widget)
2484 Show( FALSE );
2485
2486 DestroyChildren();
2487
2488 if (m_parent)
2489 m_parent->RemoveChild( this );
2490
2491 #ifdef HAVE_XIM
2492 if (m_ic)
2493 gdk_ic_destroy (m_ic);
2494 if (m_icattr)
2495 gdk_ic_attr_destroy (m_icattr);
2496 #endif
2497
2498 if (m_widgetStyle)
2499 {
2500 #if DISABLE_STYLE_IF_BROKEN_THEME
2501 // don't delete if it's a pixmap theme style
2502 if (!m_widgetStyle->engine_data)
2503 gtk_style_unref( m_widgetStyle );
2504 #endif
2505 m_widgetStyle = (GtkStyle*) NULL;
2506 }
2507
2508 if (m_wxwindow)
2509 {
2510 gtk_widget_destroy( m_wxwindow );
2511 m_wxwindow = (GtkWidget*) NULL;
2512 }
2513
2514 if (m_widget)
2515 {
2516 gtk_widget_destroy( m_widget );
2517 m_widget = (GtkWidget*) NULL;
2518 }
2519 }
2520
2521 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2522 {
2523 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
2524
2525 /* this turns -1 into 20 so that a minimal window is
2526 visible even although -1,-1 has been given as the
2527 size of the window. the same trick is used in other
2528 ports and should make debugging easier */
2529 m_width = WidthDefault(size.x);
2530 m_height = HeightDefault(size.y);
2531
2532 m_x = (int)pos.x;
2533 m_y = (int)pos.y;
2534
2535 /* some reasonable defaults */
2536 if (!parent)
2537 {
2538 if (m_x == -1)
2539 {
2540 m_x = (gdk_screen_width () - m_width) / 2;
2541 if (m_x < 10) m_x = 10;
2542 }
2543 if (m_y == -1)
2544 {
2545 m_y = (gdk_screen_height () - m_height) / 2;
2546 if (m_y < 10) m_y = 10;
2547 }
2548 }
2549
2550 return TRUE;
2551 }
2552
2553 void wxWindowGTK::PostCreation()
2554 {
2555 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2556
2557 if (m_wxwindow)
2558 {
2559 if (!m_noExpose)
2560 {
2561 // these get reported to wxWindows -> wxPaintEvent
2562
2563 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2564
2565 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2566 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2567
2568 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2569 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
2570
2571 if (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE))
2572 {
2573 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2574 GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2575 }
2576 }
2577
2578 // these are called when the "sunken" or "raised" borders are drawn */
2579 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2580 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2581
2582 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2583 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
2584 }
2585
2586 // focus handling
2587
2588 if (m_focusWidget == NULL)
2589 m_focusWidget = m_widget;
2590
2591 #if 0
2592 if (GetClassInfo() && GetClassInfo()->GetClassName())
2593 wxPrintf( GetClassInfo()->GetClassName() );
2594 wxPrintf( ".\n" );
2595 #endif
2596
2597 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2598 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2599
2600 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
2601 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2602
2603 // connect to the various key and mouse handlers
2604
2605 GtkWidget *connect_widget = GetConnectWidget();
2606
2607 ConnectWidget( connect_widget );
2608
2609 /* We cannot set colours, fonts and cursors before the widget has
2610 been realized, so we do this directly after realization */
2611 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
2612 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2613
2614 if (m_wxwindow)
2615 {
2616 // Catch native resize events
2617 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2618 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2619
2620 // Initialize XIM support
2621 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2622 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
2623
2624 // And resize XIM window
2625 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2626 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
2627 }
2628
2629 if (!GTK_IS_COMBO(m_widget))
2630 {
2631 // This is needed if we want to add our windows into native
2632 // GTK control, such as the toolbar. With this callback, the
2633 // toolbar gets to know the correct size (the one set by the
2634 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2635 // when moving to GTK 2.0.
2636 gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
2637 GTK_SIGNAL_FUNC(gtk_window_size_request_callback), (gpointer) this );
2638 }
2639
2640 m_hasVMT = TRUE;
2641 }
2642
2643 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2644 {
2645 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2646 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
2647
2648 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2649 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2650
2651 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2652 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2653
2654 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2655 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2656
2657 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2658 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2659
2660 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2661 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2662
2663 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2664 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2665 }
2666
2667 bool wxWindowGTK::Destroy()
2668 {
2669 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2670
2671 m_hasVMT = FALSE;
2672
2673 return wxWindowBase::Destroy();
2674 }
2675
2676 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2677 {
2678 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2679 }
2680
2681 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2682 {
2683 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2684 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2685
2686 /*
2687 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2688 */
2689
2690 if (m_resizing) return; /* I don't like recursions */
2691 m_resizing = TRUE;
2692
2693 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
2694 {
2695 /* don't set the size for children of wxNotebook, just take the values. */
2696 m_x = x;
2697 m_y = y;
2698 m_width = width;
2699 m_height = height;
2700 }
2701 else
2702 {
2703 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2704
2705 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2706 {
2707 if (x != -1) m_x = x + pizza->xoffset;
2708 if (y != -1) m_y = y + pizza->yoffset;
2709 if (width != -1) m_width = width;
2710 if (height != -1) m_height = height;
2711 }
2712 else
2713 {
2714 m_x = x + pizza->xoffset;
2715 m_y = y + pizza->yoffset;
2716 m_width = width;
2717 m_height = height;
2718 }
2719
2720 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
2721 {
2722 if (width == -1) m_width = 80;
2723 }
2724
2725 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
2726 {
2727 if (height == -1) m_height = 26;
2728 }
2729
2730 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
2731 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
2732 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
2733 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
2734
2735 int border = 0;
2736 int bottom_border = 0;
2737
2738 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2739 {
2740 /* the default button has a border around it */
2741 border = 6;
2742 bottom_border = 5;
2743 }
2744
2745 DoMoveWindow( m_x-border,
2746 m_y-border,
2747 m_width+2*border,
2748 m_height+border+bottom_border );
2749 }
2750
2751 if (m_hasScrolling)
2752 {
2753 /* Sometimes the client area changes size without the
2754 whole windows's size changing, but if the whole
2755 windows's size doesn't change, no wxSizeEvent will
2756 normally be sent. Here we add an extra test if
2757 the client test has been changed and this will
2758 be used then. */
2759 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2760 }
2761
2762 /*
2763 wxPrintf( "OnSize sent from " );
2764 if (GetClassInfo() && GetClassInfo()->GetClassName())
2765 wxPrintf( GetClassInfo()->GetClassName() );
2766 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2767 */
2768
2769 if (!m_nativeSizeEvent)
2770 {
2771 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2772 event.SetEventObject( this );
2773 GetEventHandler()->ProcessEvent( event );
2774 }
2775
2776 m_resizing = FALSE;
2777 }
2778
2779 void wxWindowGTK::OnInternalIdle()
2780 {
2781 if ( g_sendActivateEvent != -1 )
2782 {
2783 bool activate = g_sendActivateEvent != 0;
2784
2785 // do it only once
2786 g_sendActivateEvent = -1;
2787
2788 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
2789
2790 wxActivateEvent event(wxEVT_ACTIVATE_APP, activate, GetId());
2791 event.SetEventObject(this);
2792
2793 (void)GetEventHandler()->ProcessEvent(event);
2794 }
2795
2796 wxCursor cursor = m_cursor;
2797 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2798
2799 if (cursor.Ok())
2800 {
2801 /* I now set the cursor anew in every OnInternalIdle call
2802 as setting the cursor in a parent window also effects the
2803 windows above so that checking for the current cursor is
2804 not possible. */
2805
2806 if (m_wxwindow)
2807 {
2808 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
2809 if (window)
2810 gdk_window_set_cursor( window, cursor.GetCursor() );
2811
2812 if (!g_globalCursor.Ok())
2813 cursor = *wxSTANDARD_CURSOR;
2814
2815 window = m_widget->window;
2816 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2817 gdk_window_set_cursor( window, cursor.GetCursor() );
2818
2819 }
2820 else
2821 {
2822
2823 GdkWindow *window = m_widget->window;
2824 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2825 gdk_window_set_cursor( window, cursor.GetCursor() );
2826
2827 }
2828 }
2829
2830 UpdateWindowUI();
2831 }
2832
2833 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2834 {
2835 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2836
2837 if (width) (*width) = m_width;
2838 if (height) (*height) = m_height;
2839 }
2840
2841 void wxWindowGTK::DoSetClientSize( int width, int height )
2842 {
2843 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2844
2845 if (!m_wxwindow)
2846 {
2847 SetSize( width, height );
2848 }
2849 else
2850 {
2851 int dw = 0;
2852 int dh = 0;
2853
2854 #ifndef __WXUNIVERSAL__
2855 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2856 {
2857 /* when using GTK 1.2 we set the shadow border size to 2 */
2858 dw += 2 * 2;
2859 dh += 2 * 2;
2860 }
2861 if (HasFlag(wxSIMPLE_BORDER))
2862 {
2863 /* when using GTK 1.2 we set the simple border size to 1 */
2864 dw += 1 * 2;
2865 dh += 1 * 2;
2866 }
2867 #endif // __WXUNIVERSAL__
2868
2869 if (m_hasScrolling)
2870 {
2871 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2872
2873 GtkRequisition vscroll_req;
2874 vscroll_req.width = 2;
2875 vscroll_req.height = 2;
2876 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
2877 (scroll_window->vscrollbar, &vscroll_req );
2878
2879 GtkRequisition hscroll_req;
2880 hscroll_req.width = 2;
2881 hscroll_req.height = 2;
2882 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
2883 (scroll_window->hscrollbar, &hscroll_req );
2884
2885 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2886
2887 if (scroll_window->vscrollbar_visible)
2888 {
2889 dw += vscroll_req.width;
2890 dw += scroll_class->scrollbar_spacing;
2891 }
2892
2893 if (scroll_window->hscrollbar_visible)
2894 {
2895 dh += hscroll_req.height;
2896 dh += scroll_class->scrollbar_spacing;
2897 }
2898 }
2899
2900 SetSize( width+dw, height+dh );
2901 }
2902 }
2903
2904 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2905 {
2906 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2907
2908 if (!m_wxwindow)
2909 {
2910 if (width) (*width) = m_width;
2911 if (height) (*height) = m_height;
2912 }
2913 else
2914 {
2915 int dw = 0;
2916 int dh = 0;
2917
2918 #ifndef __WXUNIVERSAL__
2919 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2920 {
2921 /* when using GTK 1.2 we set the shadow border size to 2 */
2922 dw += 2 * 2;
2923 dh += 2 * 2;
2924 }
2925 if (HasFlag(wxSIMPLE_BORDER))
2926 {
2927 /* when using GTK 1.2 we set the simple border size to 1 */
2928 dw += 1 * 2;
2929 dh += 1 * 2;
2930 }
2931 #endif // __WXUNIVERSAL__
2932
2933 if (m_hasScrolling)
2934 {
2935 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2936
2937 GtkRequisition vscroll_req;
2938 vscroll_req.width = 2;
2939 vscroll_req.height = 2;
2940 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
2941 (scroll_window->vscrollbar, &vscroll_req );
2942
2943 GtkRequisition hscroll_req;
2944 hscroll_req.width = 2;
2945 hscroll_req.height = 2;
2946 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
2947 (scroll_window->hscrollbar, &hscroll_req );
2948
2949 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2950
2951 if (scroll_window->vscrollbar_visible)
2952 {
2953 dw += vscroll_req.width;
2954 dw += scroll_class->scrollbar_spacing;
2955 }
2956
2957 if (scroll_window->hscrollbar_visible)
2958 {
2959 dh += hscroll_req.height;
2960 dh += scroll_class->scrollbar_spacing;
2961 }
2962 }
2963
2964 if (width) (*width) = m_width - dw;
2965 if (height) (*height) = m_height - dh;
2966 }
2967
2968 /*
2969 printf( "GetClientSize, name %s ", GetName().c_str() );
2970 if (width) printf( " width = %d", (*width) );
2971 if (height) printf( " height = %d", (*height) );
2972 printf( "\n" );
2973 */
2974 }
2975
2976 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2977 {
2978 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2979
2980 int dx = 0;
2981 int dy = 0;
2982 if (m_parent && m_parent->m_wxwindow)
2983 {
2984 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2985 dx = pizza->xoffset;
2986 dy = pizza->yoffset;
2987 }
2988
2989 if (x) (*x) = m_x - dx;
2990 if (y) (*y) = m_y - dy;
2991 }
2992
2993 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2994 {
2995 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2996
2997 if (!m_widget->window) return;
2998
2999 GdkWindow *source = (GdkWindow *) NULL;
3000 if (m_wxwindow)
3001 source = GTK_PIZZA(m_wxwindow)->bin_window;
3002 else
3003 source = m_widget->window;
3004
3005 int org_x = 0;
3006 int org_y = 0;
3007 gdk_window_get_origin( source, &org_x, &org_y );
3008
3009 if (!m_wxwindow)
3010 {
3011 if (GTK_WIDGET_NO_WINDOW (m_widget))
3012 {
3013 org_x += m_widget->allocation.x;
3014 org_y += m_widget->allocation.y;
3015 }
3016 }
3017
3018 if (x) *x += org_x;
3019 if (y) *y += org_y;
3020 }
3021
3022 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
3023 {
3024 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3025
3026 if (!m_widget->window) return;
3027
3028 GdkWindow *source = (GdkWindow *) NULL;
3029 if (m_wxwindow)
3030 source = GTK_PIZZA(m_wxwindow)->bin_window;
3031 else
3032 source = m_widget->window;
3033
3034 int org_x = 0;
3035 int org_y = 0;
3036 gdk_window_get_origin( source, &org_x, &org_y );
3037
3038 if (!m_wxwindow)
3039 {
3040 if (GTK_WIDGET_NO_WINDOW (m_widget))
3041 {
3042 org_x += m_widget->allocation.x;
3043 org_y += m_widget->allocation.y;
3044 }
3045 }
3046
3047 if (x) *x -= org_x;
3048 if (y) *y -= org_y;
3049 }
3050
3051 bool wxWindowGTK::Show( bool show )
3052 {
3053 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3054
3055 if (!wxWindowBase::Show(show))
3056 {
3057 // nothing to do
3058 return FALSE;
3059 }
3060
3061 if (show)
3062 gtk_widget_show( m_widget );
3063 else
3064 gtk_widget_hide( m_widget );
3065
3066 return TRUE;
3067 }
3068
3069 static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
3070 {
3071 win->OnParentEnable(enable);
3072
3073 // Recurse, so that children have the opportunity to Do The Right Thing
3074 // and reset colours that have been messed up by a parent's (really ancestor's)
3075 // Enable call
3076 for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
3077 node;
3078 node = node->GetNext() )
3079 {
3080 wxWindow *child = node->GetData();
3081 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3082 wxWindowNotifyEnable(child, enable);
3083 }
3084 }
3085
3086 bool wxWindowGTK::Enable( bool enable )
3087 {
3088 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3089
3090 if (!wxWindowBase::Enable(enable))
3091 {
3092 // nothing to do
3093 return FALSE;
3094 }
3095
3096 gtk_widget_set_sensitive( m_widget, enable );
3097 if ( m_wxwindow )
3098 gtk_widget_set_sensitive( m_wxwindow, enable );
3099
3100 wxWindowNotifyEnable(this, enable);
3101
3102 return TRUE;
3103 }
3104
3105 int wxWindowGTK::GetCharHeight() const
3106 {
3107 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3108
3109 wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
3110
3111 GdkFont *font = m_font.GetInternalFont( 1.0 );
3112
3113 return font->ascent + font->descent;
3114 }
3115
3116 int wxWindowGTK::GetCharWidth() const
3117 {
3118 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3119
3120 wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
3121
3122 GdkFont *font = m_font.GetInternalFont( 1.0 );
3123
3124 return gdk_string_width( font, "H" );
3125 }
3126
3127 void wxWindowGTK::GetTextExtent( const wxString& string,
3128 int *x,
3129 int *y,
3130 int *descent,
3131 int *externalLeading,
3132 const wxFont *theFont ) const
3133 {
3134 wxFont fontToUse = m_font;
3135 if (theFont) fontToUse = *theFont;
3136
3137 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3138
3139 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
3140 if (x) (*x) = gdk_string_width( font, string.mbc_str() );
3141 if (y) (*y) = font->ascent + font->descent;
3142 if (descent) (*descent) = font->descent;
3143 if (externalLeading) (*externalLeading) = 0; // ??
3144 }
3145
3146 void wxWindowGTK::SetFocus()
3147 {
3148 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3149
3150 if (m_wxwindow)
3151 {
3152 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3153 gtk_widget_grab_focus (m_wxwindow);
3154 return;
3155 }
3156
3157 if (m_widget)
3158 {
3159 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3160 {
3161 gtk_widget_grab_focus (m_widget);
3162 }
3163 else if (GTK_IS_CONTAINER(m_widget))
3164 {
3165 gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD );
3166 }
3167 else
3168 {
3169 // ?
3170 }
3171 }
3172 }
3173
3174 bool wxWindowGTK::AcceptsFocus() const
3175 {
3176 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
3177 }
3178
3179 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3180 {
3181 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3182
3183 wxWindowGTK *oldParent = m_parent,
3184 *newParent = (wxWindowGTK *)newParentBase;
3185
3186 wxASSERT( GTK_IS_WIDGET(m_widget) );
3187
3188 if ( !wxWindowBase::Reparent(newParent) )
3189 return FALSE;
3190
3191 wxASSERT( GTK_IS_WIDGET(m_widget) );
3192
3193 /* prevent GTK from deleting the widget arbitrarily */
3194 gtk_widget_ref( m_widget );
3195
3196 if (oldParent)
3197 {
3198 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3199 }
3200
3201 wxASSERT( GTK_IS_WIDGET(m_widget) );
3202
3203 if (newParent)
3204 {
3205 /* insert GTK representation */
3206 (*(newParent->m_insertCallback))(newParent, this);
3207 }
3208
3209 /* reverse: prevent GTK from deleting the widget arbitrarily */
3210 gtk_widget_unref( m_widget );
3211
3212 return TRUE;
3213 }
3214
3215 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3216 {
3217 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3218
3219 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3220
3221 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3222
3223 /* add to list */
3224 AddChild( child );
3225
3226 /* insert GTK representation */
3227 (*m_insertCallback)(this, child);
3228 }
3229
3230 void wxWindowGTK::Raise()
3231 {
3232 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3233
3234 if (!m_widget->window) return;
3235
3236 gdk_window_raise( m_widget->window );
3237 }
3238
3239 void wxWindowGTK::Lower()
3240 {
3241 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3242
3243 if (!m_widget->window) return;
3244
3245 gdk_window_lower( m_widget->window );
3246 }
3247
3248 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3249 {
3250 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3251
3252 if (cursor == m_cursor)
3253 return FALSE;
3254
3255 if (g_isIdle)
3256 wxapp_install_idle_handler();
3257
3258 if (cursor == wxNullCursor)
3259 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3260 else
3261 return wxWindowBase::SetCursor( cursor );
3262 }
3263
3264 void wxWindowGTK::WarpPointer( int x, int y )
3265 {
3266 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3267
3268 /* we provide this function ourselves as it is
3269 missing in GDK (top of this file) */
3270
3271 GdkWindow *window = (GdkWindow*) NULL;
3272 if (m_wxwindow)
3273 window = GTK_PIZZA(m_wxwindow)->bin_window;
3274 else
3275 window = GetConnectWidget()->window;
3276
3277 if (window)
3278 gdk_window_warp_pointer( window, x, y );
3279 }
3280
3281 void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3282 {
3283 if (!m_widget) return;
3284 if (!m_widget->window) return;
3285
3286 // temporarily hide the caret to avoid nasty interactions between caret
3287 // drawing and the window contents redraw
3288 #if 0 // def wxUSE_CARET -- doesn't seem to help :-(
3289 wxCaretSuspend cs((wxWindow *)this);
3290 #endif // wxUSE_CARET
3291
3292 if (eraseBackground && m_wxwindow && m_wxwindow->window)
3293 {
3294 if (rect)
3295 {
3296 gdk_window_clear_area( GTK_PIZZA(m_wxwindow)->bin_window,
3297 rect->x, rect->y,
3298 rect->width, rect->height );
3299 }
3300 else
3301 {
3302 gdk_window_clear( GTK_PIZZA(m_wxwindow)->bin_window );
3303 }
3304 }
3305
3306 /* there is no GTK equivalent of "draw only, don't clear" so we
3307 invent our own in the GtkPizza widget */
3308
3309 if (!rect)
3310 {
3311 if (m_wxwindow)
3312 {
3313
3314 /*
3315 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
3316 gboolean old_clear = pizza->clear_on_draw;
3317 gtk_pizza_set_clear( pizza, FALSE );
3318 gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
3319 gtk_pizza_set_clear( pizza, old_clear );
3320 */
3321 GdkEventExpose gdk_event;
3322 gdk_event.type = GDK_EXPOSE;
3323 gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window;
3324 gdk_event.count = 0;
3325 gdk_event.area.x = 0;
3326 gdk_event.area.y = 0;
3327 gdk_event.area.width = m_wxwindow->allocation.width;
3328 gdk_event.area.height = m_wxwindow->allocation.height;
3329 gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );
3330 }
3331 else
3332 {
3333 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
3334 }
3335 }
3336 else
3337 {
3338
3339 if (m_wxwindow)
3340 {
3341 /*
3342 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
3343 gboolean old_clear = pizza->clear_on_draw;
3344 gtk_pizza_set_clear( pizza, FALSE );
3345
3346 GdkRectangle gdk_rect;
3347 gdk_rect.x = rect->x;
3348 gdk_rect.y = rect->y;
3349 gdk_rect.width = rect->width;
3350 gdk_rect.height = rect->height;
3351 gtk_widget_draw( m_wxwindow, &gdk_rect );
3352 gtk_window_draw_callback( m_wxwindow, &gdk_rect, this );
3353
3354 gtk_pizza_set_clear( pizza, old_clear );
3355 */
3356 GdkEventExpose gdk_event;
3357 gdk_event.type = GDK_EXPOSE;
3358 gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window;
3359 gdk_event.count = 0;
3360 gdk_event.area.x = rect->x;
3361 gdk_event.area.y = rect->y;
3362 gdk_event.area.width = rect->width;
3363 gdk_event.area.height = rect->height;
3364 gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );
3365 }
3366 else
3367 {
3368 GdkRectangle gdk_rect;
3369 gdk_rect.x = rect->x;
3370 gdk_rect.y = rect->y;
3371 gdk_rect.width = rect->width;
3372 gdk_rect.height = rect->height;
3373 gtk_widget_draw( m_widget, &gdk_rect );
3374 }
3375 }
3376 }
3377
3378 void wxWindowGTK::Clear()
3379 {
3380 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3381
3382 if (!m_widget->window) return;
3383
3384 if (m_wxwindow && m_wxwindow->window)
3385 {
3386 // gdk_window_clear( m_wxwindow->window );
3387 }
3388 }
3389
3390 #if wxUSE_TOOLTIPS
3391 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3392 {
3393 wxWindowBase::DoSetToolTip(tip);
3394
3395 if (m_tooltip)
3396 m_tooltip->Apply( (wxWindow *)this );
3397 }
3398
3399 void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
3400 {
3401 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
3402 }
3403 #endif // wxUSE_TOOLTIPS
3404
3405 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3406 {
3407 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3408
3409 if (!wxWindowBase::SetBackgroundColour(colour))
3410 {
3411 // don't leave if the GTK widget has just
3412 // been realized
3413 if (!m_delayedBackgroundColour) return FALSE;
3414 }
3415
3416 GdkWindow *window = (GdkWindow*) NULL;
3417 if (m_wxwindow)
3418 window = GTK_PIZZA(m_wxwindow)->bin_window;
3419 else
3420 window = GetConnectWidget()->window;
3421
3422 if (!window)
3423 {
3424 // indicate that a new style has been set
3425 // but it couldn't get applied as the
3426 // widget hasn't been realized yet.
3427 m_delayedBackgroundColour = TRUE;
3428 }
3429
3430 if ((m_wxwindow) &&
3431 (m_wxwindow->window) &&
3432 (m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE)))
3433 {
3434 /* wxMSW doesn't clear the window here. I don't do that either to
3435 provide compatibility. call Clear() to do the job. */
3436
3437 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
3438 gdk_window_set_background( window, m_backgroundColour.GetColor() );
3439 }
3440
3441 ApplyWidgetStyle();
3442
3443 return TRUE;
3444 }
3445
3446 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3447 {
3448 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3449
3450 if (!wxWindowBase::SetForegroundColour(colour))
3451 {
3452 // don't leave if the GTK widget has just
3453 // been realized
3454 if (!m_delayedForegroundColour) return FALSE;
3455 }
3456
3457 GdkWindow *window = (GdkWindow*) NULL;
3458 if (m_wxwindow)
3459 window = GTK_PIZZA(m_wxwindow)->bin_window;
3460 else
3461 window = GetConnectWidget()->window;
3462
3463 if (!window)
3464 {
3465 // indicate that a new style has been set
3466 // but it couldn't get applied as the
3467 // widget hasn't been realized yet.
3468 m_delayedForegroundColour = TRUE;
3469 }
3470
3471 ApplyWidgetStyle();
3472
3473 return TRUE;
3474 }
3475
3476 GtkStyle *wxWindowGTK::GetWidgetStyle()
3477 {
3478 if (m_widgetStyle)
3479 {
3480 GtkStyle *remake = gtk_style_copy( m_widgetStyle );
3481 #ifdef __WXGTK20__
3482 /* FIXME: is this necessary? */
3483 _G_TYPE_IGC(remake, GtkObjectClass) = _G_TYPE_IGC(m_widgetStyle, GtkObjectClass);
3484 #else
3485 remake->klass = m_widgetStyle->klass;
3486 #endif
3487
3488 gtk_style_unref( m_widgetStyle );
3489 m_widgetStyle = remake;
3490 }
3491 else
3492 {
3493 GtkStyle *def = gtk_rc_get_style( m_widget );
3494
3495 if (!def)
3496 def = gtk_widget_get_default_style();
3497
3498 m_widgetStyle = gtk_style_copy( def );
3499 #ifdef __WXGTK20__
3500 /* FIXME: is this necessary? */
3501 _G_TYPE_IGC(m_widgetStyle, GtkObjectClass) = _G_TYPE_IGC(def, GtkObjectClass);
3502 #else
3503 m_widgetStyle->klass = def->klass;
3504 #endif
3505 }
3506
3507 return m_widgetStyle;
3508 }
3509
3510 void wxWindowGTK::SetWidgetStyle()
3511 {
3512 #if DISABLE_STYLE_IF_BROKEN_THEM
3513 if (m_widget->style->engine_data)
3514 {
3515 static bool s_warningPrinted = FALSE;
3516 if (!s_warningPrinted)
3517 {
3518 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
3519 s_warningPrinted = TRUE;
3520 }
3521 m_widgetStyle = m_widget->style;
3522 return;
3523 }
3524 #endif
3525
3526 GtkStyle *style = GetWidgetStyle();
3527
3528 if (m_font != wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT ))
3529 {
3530 gdk_font_unref( style->font );
3531 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
3532 }
3533
3534 if (m_foregroundColour.Ok())
3535 {
3536 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
3537 if (m_foregroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNTEXT))
3538 {
3539 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
3540 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
3541 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
3542 }
3543 else
3544 {
3545 // Try to restore the gtk default style. This is still a little
3546 // oversimplified for what is probably really needed here for controls
3547 // other than buttons, but is better than not being able to (re)set a
3548 // control's foreground colour to *wxBLACK -- RL
3549 GtkStyle *def = gtk_rc_get_style( m_widget );
3550
3551 if (!def)
3552 def = gtk_widget_get_default_style();
3553
3554 style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
3555 style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
3556 style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
3557 }
3558 }
3559
3560 if (m_backgroundColour.Ok())
3561 {
3562 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
3563 if (m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE))
3564 {
3565 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
3566 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
3567 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
3568 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
3569 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
3570 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
3571 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
3572 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
3573 }
3574 else
3575 {
3576 // Try to restore the gtk default style. This is still a little
3577 // oversimplified for what is probably really needed here for controls
3578 // other than buttons, but is better than not being able to (re)set a
3579 // control's background colour to default grey and means resetting a
3580 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
3581 // behavior -- RL
3582 GtkStyle *def = gtk_rc_get_style( m_widget );
3583
3584 if (!def)
3585 def = gtk_widget_get_default_style();
3586
3587 style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
3588 style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
3589 style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
3590 style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
3591 style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
3592 style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
3593 style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
3594 style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
3595 }
3596 }
3597 }
3598
3599 void wxWindowGTK::ApplyWidgetStyle()
3600 {
3601 }
3602
3603 //-----------------------------------------------------------------------------
3604 // Pop-up menu stuff
3605 //-----------------------------------------------------------------------------
3606
3607 #if wxUSE_MENUS_NATIVE
3608
3609 static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
3610 {
3611 *is_waiting = FALSE;
3612 }
3613
3614 static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
3615 {
3616 menu->SetInvokingWindow( win );
3617 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
3618 while (node)
3619 {
3620 wxMenuItem *menuitem = node->GetData();
3621 if (menuitem->IsSubMenu())
3622 {
3623 SetInvokingWindow( menuitem->GetSubMenu(), win );
3624 }
3625
3626 node = node->GetNext();
3627 }
3628 }
3629
3630 static gint gs_pop_x = 0;
3631 static gint gs_pop_y = 0;
3632
3633 static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
3634 gint *x, gint *y,
3635 wxWindowGTK *win )
3636 {
3637 win->ClientToScreen( &gs_pop_x, &gs_pop_y );
3638 *x = gs_pop_x;
3639 *y = gs_pop_y;
3640 }
3641
3642 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
3643 {
3644 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3645
3646 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
3647
3648 SetInvokingWindow( menu, this );
3649
3650 menu->UpdateUI();
3651
3652 gs_pop_x = x;
3653 gs_pop_y = y;
3654
3655 bool is_waiting = TRUE;
3656
3657 gtk_signal_connect( GTK_OBJECT(menu->m_menu), "hide",
3658 GTK_SIGNAL_FUNC(gtk_pop_hide_callback), (gpointer)&is_waiting );
3659
3660 gtk_menu_popup(
3661 GTK_MENU(menu->m_menu),
3662 (GtkWidget *) NULL, // parent menu shell
3663 (GtkWidget *) NULL, // parent menu item
3664 (GtkMenuPositionFunc) pop_pos_callback,
3665 (gpointer) this, // client data
3666 0, // button used to activate it
3667 gs_timeLastClick // the time of activation
3668 );
3669
3670 while (is_waiting)
3671 {
3672 while (gtk_events_pending())
3673 gtk_main_iteration();
3674 }
3675
3676 return TRUE;
3677 }
3678
3679 #endif // wxUSE_MENUS_NATIVE
3680
3681 #if wxUSE_DRAG_AND_DROP
3682
3683 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
3684 {
3685 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3686
3687 GtkWidget *dnd_widget = GetConnectWidget();
3688
3689 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
3690
3691 if (m_dropTarget) delete m_dropTarget;
3692 m_dropTarget = dropTarget;
3693
3694 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
3695 }
3696
3697 #endif // wxUSE_DRAG_AND_DROP
3698
3699 GtkWidget* wxWindowGTK::GetConnectWidget()
3700 {
3701 GtkWidget *connect_widget = m_widget;
3702 if (m_wxwindow) connect_widget = m_wxwindow;
3703
3704 return connect_widget;
3705 }
3706
3707 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
3708 {
3709 if (m_wxwindow)
3710 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
3711
3712 return (window == m_widget->window);
3713 }
3714
3715 bool wxWindowGTK::SetFont( const wxFont &font )
3716 {
3717 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3718
3719 if (!wxWindowBase::SetFont(font))
3720 {
3721 return FALSE;
3722 }
3723
3724 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
3725 if ( sysbg == m_backgroundColour )
3726 {
3727 m_backgroundColour = wxNullColour;
3728 ApplyWidgetStyle();
3729 m_backgroundColour = sysbg;
3730 }
3731 else
3732 {
3733 ApplyWidgetStyle();
3734 }
3735
3736 return TRUE;
3737 }
3738
3739 void wxWindowGTK::CaptureMouse()
3740 {
3741 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3742
3743 GdkWindow *window = (GdkWindow*) NULL;
3744 if (m_wxwindow)
3745 window = GTK_PIZZA(m_wxwindow)->bin_window;
3746 else
3747 window = GetConnectWidget()->window;
3748
3749 wxCHECK_RET( window, _T("CaptureMouse() failed") );
3750
3751 wxCursor* cursor = & m_cursor;
3752 if (!cursor->Ok())
3753 cursor = wxSTANDARD_CURSOR;
3754
3755 gdk_pointer_grab( window, FALSE,
3756 (GdkEventMask)
3757 (GDK_BUTTON_PRESS_MASK |
3758 GDK_BUTTON_RELEASE_MASK |
3759 GDK_POINTER_MOTION_HINT_MASK |
3760 GDK_POINTER_MOTION_MASK),
3761 (GdkWindow *) NULL,
3762 cursor->GetCursor(),
3763 (guint32)GDK_CURRENT_TIME );
3764 g_captureWindow = this;
3765 g_captureWindowHasMouse = TRUE;
3766 }
3767
3768 void wxWindowGTK::ReleaseMouse()
3769 {
3770 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3771
3772 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
3773
3774 GdkWindow *window = (GdkWindow*) NULL;
3775 if (m_wxwindow)
3776 window = GTK_PIZZA(m_wxwindow)->bin_window;
3777 else
3778 window = GetConnectWidget()->window;
3779
3780 if (!window)
3781 return;
3782
3783 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
3784 g_captureWindow = (wxWindowGTK*) NULL;
3785 }
3786
3787 /* static */
3788 wxWindow *wxWindowBase::GetCapture()
3789 {
3790 return (wxWindow *)g_captureWindow;
3791 }
3792
3793 bool wxWindowGTK::IsRetained() const
3794 {
3795 return FALSE;
3796 }
3797
3798 void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
3799 int range, bool refresh )
3800 {
3801 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3802
3803 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3804
3805 m_hasScrolling = TRUE;
3806
3807 if (orient == wxHORIZONTAL)
3808 {
3809 float fpos = (float)pos;
3810 float frange = (float)range;
3811 float fthumb = (float)thumbVisible;
3812 if (fpos > frange-fthumb) fpos = frange-fthumb;
3813 if (fpos < 0.0) fpos = 0.0;
3814
3815 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
3816 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
3817 {
3818 SetScrollPos( orient, pos, refresh );
3819 return;
3820 }
3821
3822 m_oldHorizontalPos = fpos;
3823
3824 m_hAdjust->lower = 0.0;
3825 m_hAdjust->upper = frange;
3826 m_hAdjust->value = fpos;
3827 m_hAdjust->step_increment = 1.0;
3828 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
3829 m_hAdjust->page_size = fthumb;
3830 }
3831 else
3832 {
3833 float fpos = (float)pos;
3834 float frange = (float)range;
3835 float fthumb = (float)thumbVisible;
3836 if (fpos > frange-fthumb) fpos = frange-fthumb;
3837 if (fpos < 0.0) fpos = 0.0;
3838
3839 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
3840 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
3841 {
3842 SetScrollPos( orient, pos, refresh );
3843 return;
3844 }
3845
3846 m_oldVerticalPos = fpos;
3847
3848 m_vAdjust->lower = 0.0;
3849 m_vAdjust->upper = frange;
3850 m_vAdjust->value = fpos;
3851 m_vAdjust->step_increment = 1.0;
3852 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
3853 m_vAdjust->page_size = fthumb;
3854 }
3855
3856 if (orient == wxHORIZONTAL)
3857 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
3858 else
3859 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
3860 }
3861
3862 void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
3863 {
3864 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3865
3866 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3867
3868 if (orient == wxHORIZONTAL)
3869 {
3870 float fpos = (float)pos;
3871 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
3872 if (fpos < 0.0) fpos = 0.0;
3873 m_oldHorizontalPos = fpos;
3874
3875 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
3876 m_hAdjust->value = fpos;
3877 }
3878 else
3879 {
3880 float fpos = (float)pos;
3881 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
3882 if (fpos < 0.0) fpos = 0.0;
3883 m_oldVerticalPos = fpos;
3884
3885 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
3886 m_vAdjust->value = fpos;
3887 }
3888
3889 if (m_wxwindow->window)
3890 {
3891 if (orient == wxHORIZONTAL)
3892 {
3893 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
3894 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
3895
3896 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
3897
3898 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
3899 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
3900 }
3901 else
3902 {
3903 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
3904 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
3905
3906 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
3907
3908 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
3909 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
3910 }
3911 }
3912 }
3913
3914 int wxWindowGTK::GetScrollThumb( int orient ) const
3915 {
3916 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
3917
3918 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
3919
3920 if (orient == wxHORIZONTAL)
3921 return (int)(m_hAdjust->page_size+0.5);
3922 else
3923 return (int)(m_vAdjust->page_size+0.5);
3924 }
3925
3926 int wxWindowGTK::GetScrollPos( int orient ) const
3927 {
3928 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
3929
3930 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
3931
3932 if (orient == wxHORIZONTAL)
3933 return (int)(m_hAdjust->value+0.5);
3934 else
3935 return (int)(m_vAdjust->value+0.5);
3936 }
3937
3938 int wxWindowGTK::GetScrollRange( int orient ) const
3939 {
3940 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
3941
3942 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
3943
3944 if (orient == wxHORIZONTAL)
3945 return (int)(m_hAdjust->upper+0.5);
3946 else
3947 return (int)(m_vAdjust->upper+0.5);
3948 }
3949
3950 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
3951 {
3952 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3953
3954 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3955
3956 if ((dx == 0) && (dy == 0)) return;
3957
3958 m_clipPaintRegion = TRUE;
3959 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
3960 m_clipPaintRegion = FALSE;
3961
3962 /*
3963 if (m_children.GetCount() > 0)
3964 {
3965 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
3966 }
3967 else
3968 {
3969 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
3970
3971 pizza->xoffset -= dx;
3972 pizza->yoffset -= dy;
3973
3974 GdkGC *m_scrollGC = gdk_gc_new( pizza->bin_window );
3975 gdk_gc_set_exposures( m_scrollGC, TRUE );
3976
3977 int cw = 0;
3978 int ch = 0;
3979 GetClientSize( &cw, &ch );
3980 int w = cw - abs(dx);
3981 int h = ch - abs(dy);
3982
3983 if ((h < 0) || (w < 0))
3984 {
3985 Refresh();
3986 }
3987 else
3988 {
3989 int s_x = 0;
3990 int s_y = 0;
3991 if (dx < 0) s_x = -dx;
3992 if (dy < 0) s_y = -dy;
3993 int d_x = 0;
3994 int d_y = 0;
3995 if (dx > 0) d_x = dx;
3996 if (dy > 0) d_y = dy;
3997
3998 gdk_window_copy_area( pizza->bin_window, m_scrollGC, d_x, d_y,
3999 pizza->bin_window, s_x, s_y, w, h );
4000
4001 wxRect rect;
4002 if (dx < 0) rect.x = cw+dx; else rect.x = 0;
4003 if (dy < 0) rect.y = ch+dy; else rect.y = 0;
4004 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
4005 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
4006
4007 Refresh( TRUE, &rect );
4008 }
4009
4010 gdk_gc_unref( m_scrollGC );
4011 }
4012 */
4013 }
4014
4015 // Find the wxWindow at the current mouse position, also returning the mouse
4016 // position.
4017 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4018 {
4019 pt = wxGetMousePosition();
4020 wxWindow* found = wxFindWindowAtPoint(pt);
4021 return found;
4022 }
4023
4024 // Get the current mouse position.
4025 wxPoint wxGetMousePosition()
4026 {
4027 /* This crashes when used within wxHelpContext,
4028 so we have to use the X-specific implementation below.
4029 gint x, y;
4030 GdkModifierType *mask;
4031 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4032
4033 return wxPoint(x, y);
4034 */
4035
4036 int x, y;
4037 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4038 if (!windowAtPtr)
4039 return wxPoint(-999, -999);
4040
4041 Display *display = GDK_WINDOW_XDISPLAY(windowAtPtr);
4042 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4043 Window rootReturn, childReturn;
4044 int rootX, rootY, winX, winY;
4045 unsigned int maskReturn;
4046
4047 XQueryPointer (display,
4048 rootWindow,
4049 &rootReturn,
4050 &childReturn,
4051 &rootX, &rootY, &winX, &winY, &maskReturn);
4052 return wxPoint(rootX, rootY);
4053
4054 }
4055
wxWidgets (Impactor)