]> 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
applied patch 446836: removed qt headers
[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
2791 wxCursor cursor = m_cursor;
2792 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2793
2794 if (cursor.Ok())
2795 {
2796 /* I now set the cursor anew in every OnInternalIdle call
2797 as setting the cursor in a parent window also effects the
2798 windows above so that checking for the current cursor is
2799 not possible. */
2800
2801 if (m_wxwindow)
2802 {
2803 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
2804 if (window)
2805 gdk_window_set_cursor( window, cursor.GetCursor() );
2806
2807 if (!g_globalCursor.Ok())
2808 cursor = *wxSTANDARD_CURSOR;
2809
2810 window = m_widget->window;
2811 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2812 gdk_window_set_cursor( window, cursor.GetCursor() );
2813
2814 }
2815 else
2816 {
2817
2818 GdkWindow *window = m_widget->window;
2819 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2820 gdk_window_set_cursor( window, cursor.GetCursor() );
2821
2822 }
2823 }
2824
2825 UpdateWindowUI();
2826 }
2827
2828 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2829 {
2830 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2831
2832 if (width) (*width) = m_width;
2833 if (height) (*height) = m_height;
2834 }
2835
2836 void wxWindowGTK::DoSetClientSize( int width, int height )
2837 {
2838 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2839
2840 if (!m_wxwindow)
2841 {
2842 SetSize( width, height );
2843 }
2844 else
2845 {
2846 int dw = 0;
2847 int dh = 0;
2848
2849 #ifndef __WXUNIVERSAL__
2850 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2851 {
2852 /* when using GTK 1.2 we set the shadow border size to 2 */
2853 dw += 2 * 2;
2854 dh += 2 * 2;
2855 }
2856 if (HasFlag(wxSIMPLE_BORDER))
2857 {
2858 /* when using GTK 1.2 we set the simple border size to 1 */
2859 dw += 1 * 2;
2860 dh += 1 * 2;
2861 }
2862 #endif // __WXUNIVERSAL__
2863
2864 if (m_hasScrolling)
2865 {
2866 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2867
2868 GtkRequisition vscroll_req;
2869 vscroll_req.width = 2;
2870 vscroll_req.height = 2;
2871 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
2872 (scroll_window->vscrollbar, &vscroll_req );
2873
2874 GtkRequisition hscroll_req;
2875 hscroll_req.width = 2;
2876 hscroll_req.height = 2;
2877 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
2878 (scroll_window->hscrollbar, &hscroll_req );
2879
2880 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2881
2882 if (scroll_window->vscrollbar_visible)
2883 {
2884 dw += vscroll_req.width;
2885 dw += scroll_class->scrollbar_spacing;
2886 }
2887
2888 if (scroll_window->hscrollbar_visible)
2889 {
2890 dh += hscroll_req.height;
2891 dh += scroll_class->scrollbar_spacing;
2892 }
2893 }
2894
2895 SetSize( width+dw, height+dh );
2896 }
2897 }
2898
2899 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2900 {
2901 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2902
2903 if (!m_wxwindow)
2904 {
2905 if (width) (*width) = m_width;
2906 if (height) (*height) = m_height;
2907 }
2908 else
2909 {
2910 int dw = 0;
2911 int dh = 0;
2912
2913 #ifndef __WXUNIVERSAL__
2914 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2915 {
2916 /* when using GTK 1.2 we set the shadow border size to 2 */
2917 dw += 2 * 2;
2918 dh += 2 * 2;
2919 }
2920 if (HasFlag(wxSIMPLE_BORDER))
2921 {
2922 /* when using GTK 1.2 we set the simple border size to 1 */
2923 dw += 1 * 2;
2924 dh += 1 * 2;
2925 }
2926 #endif // __WXUNIVERSAL__
2927
2928 if (m_hasScrolling)
2929 {
2930 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2931
2932 GtkRequisition vscroll_req;
2933 vscroll_req.width = 2;
2934 vscroll_req.height = 2;
2935 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
2936 (scroll_window->vscrollbar, &vscroll_req );
2937
2938 GtkRequisition hscroll_req;
2939 hscroll_req.width = 2;
2940 hscroll_req.height = 2;
2941 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
2942 (scroll_window->hscrollbar, &hscroll_req );
2943
2944 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2945
2946 if (scroll_window->vscrollbar_visible)
2947 {
2948 dw += vscroll_req.width;
2949 dw += scroll_class->scrollbar_spacing;
2950 }
2951
2952 if (scroll_window->hscrollbar_visible)
2953 {
2954 dh += hscroll_req.height;
2955 dh += scroll_class->scrollbar_spacing;
2956 }
2957 }
2958
2959 if (width) (*width) = m_width - dw;
2960 if (height) (*height) = m_height - dh;
2961 }
2962
2963 /*
2964 printf( "GetClientSize, name %s ", GetName().c_str() );
2965 if (width) printf( " width = %d", (*width) );
2966 if (height) printf( " height = %d", (*height) );
2967 printf( "\n" );
2968 */
2969 }
2970
2971 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2972 {
2973 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2974
2975 int dx = 0;
2976 int dy = 0;
2977 if (m_parent && m_parent->m_wxwindow)
2978 {
2979 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2980 dx = pizza->xoffset;
2981 dy = pizza->yoffset;
2982 }
2983
2984 if (x) (*x) = m_x - dx;
2985 if (y) (*y) = m_y - dy;
2986 }
2987
2988 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
2989 {
2990 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2991
2992 if (!m_widget->window) return;
2993
2994 GdkWindow *source = (GdkWindow *) NULL;
2995 if (m_wxwindow)
2996 source = GTK_PIZZA(m_wxwindow)->bin_window;
2997 else
2998 source = m_widget->window;
2999
3000 int org_x = 0;
3001 int org_y = 0;
3002 gdk_window_get_origin( source, &org_x, &org_y );
3003
3004 if (!m_wxwindow)
3005 {
3006 if (GTK_WIDGET_NO_WINDOW (m_widget))
3007 {
3008 org_x += m_widget->allocation.x;
3009 org_y += m_widget->allocation.y;
3010 }
3011 }
3012
3013 if (x) *x += org_x;
3014 if (y) *y += org_y;
3015 }
3016
3017 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
3018 {
3019 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3020
3021 if (!m_widget->window) return;
3022
3023 GdkWindow *source = (GdkWindow *) NULL;
3024 if (m_wxwindow)
3025 source = GTK_PIZZA(m_wxwindow)->bin_window;
3026 else
3027 source = m_widget->window;
3028
3029 int org_x = 0;
3030 int org_y = 0;
3031 gdk_window_get_origin( source, &org_x, &org_y );
3032
3033 if (!m_wxwindow)
3034 {
3035 if (GTK_WIDGET_NO_WINDOW (m_widget))
3036 {
3037 org_x += m_widget->allocation.x;
3038 org_y += m_widget->allocation.y;
3039 }
3040 }
3041
3042 if (x) *x -= org_x;
3043 if (y) *y -= org_y;
3044 }
3045
3046 bool wxWindowGTK::Show( bool show )
3047 {
3048 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3049
3050 if (!wxWindowBase::Show(show))
3051 {
3052 // nothing to do
3053 return FALSE;
3054 }
3055
3056 if (show)
3057 gtk_widget_show( m_widget );
3058 else
3059 gtk_widget_hide( m_widget );
3060
3061 return TRUE;
3062 }
3063
3064 static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
3065 {
3066 win->OnParentEnable(enable);
3067
3068 // Recurse, so that children have the opportunity to Do The Right Thing
3069 // and reset colours that have been messed up by a parent's (really ancestor's)
3070 // Enable call
3071 for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
3072 node;
3073 node = node->GetNext() )
3074 {
3075 wxWindow *child = node->GetData();
3076 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3077 wxWindowNotifyEnable(child, enable);
3078 }
3079 }
3080
3081 bool wxWindowGTK::Enable( bool enable )
3082 {
3083 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3084
3085 if (!wxWindowBase::Enable(enable))
3086 {
3087 // nothing to do
3088 return FALSE;
3089 }
3090
3091 gtk_widget_set_sensitive( m_widget, enable );
3092 if ( m_wxwindow )
3093 gtk_widget_set_sensitive( m_wxwindow, enable );
3094
3095 wxWindowNotifyEnable(this, enable);
3096
3097 return TRUE;
3098 }
3099
3100 int wxWindowGTK::GetCharHeight() const
3101 {
3102 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3103
3104 wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
3105
3106 GdkFont *font = m_font.GetInternalFont( 1.0 );
3107
3108 return font->ascent + font->descent;
3109 }
3110
3111 int wxWindowGTK::GetCharWidth() const
3112 {
3113 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3114
3115 wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
3116
3117 GdkFont *font = m_font.GetInternalFont( 1.0 );
3118
3119 return gdk_string_width( font, "H" );
3120 }
3121
3122 void wxWindowGTK::GetTextExtent( const wxString& string,
3123 int *x,
3124 int *y,
3125 int *descent,
3126 int *externalLeading,
3127 const wxFont *theFont ) const
3128 {
3129 wxFont fontToUse = m_font;
3130 if (theFont) fontToUse = *theFont;
3131
3132 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3133
3134 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
3135 if (x) (*x) = gdk_string_width( font, string.mbc_str() );
3136 if (y) (*y) = font->ascent + font->descent;
3137 if (descent) (*descent) = font->descent;
3138 if (externalLeading) (*externalLeading) = 0; // ??
3139 }
3140
3141 void wxWindowGTK::SetFocus()
3142 {
3143 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3144
3145 if (m_wxwindow)
3146 {
3147 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3148 gtk_widget_grab_focus (m_wxwindow);
3149 return;
3150 }
3151
3152 if (m_widget)
3153 {
3154 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3155 {
3156 gtk_widget_grab_focus (m_widget);
3157 }
3158 else if (GTK_IS_CONTAINER(m_widget))
3159 {
3160 gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD );
3161 }
3162 else
3163 {
3164 // ?
3165 }
3166 }
3167 }
3168
3169 bool wxWindowGTK::AcceptsFocus() const
3170 {
3171 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
3172 }
3173
3174 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3175 {
3176 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3177
3178 wxWindowGTK *oldParent = m_parent,
3179 *newParent = (wxWindowGTK *)newParentBase;
3180
3181 wxASSERT( GTK_IS_WIDGET(m_widget) );
3182
3183 if ( !wxWindowBase::Reparent(newParent) )
3184 return FALSE;
3185
3186 wxASSERT( GTK_IS_WIDGET(m_widget) );
3187
3188 /* prevent GTK from deleting the widget arbitrarily */
3189 gtk_widget_ref( m_widget );
3190
3191 if (oldParent)
3192 {
3193 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3194 }
3195
3196 wxASSERT( GTK_IS_WIDGET(m_widget) );
3197
3198 if (newParent)
3199 {
3200 /* insert GTK representation */
3201 (*(newParent->m_insertCallback))(newParent, this);
3202 }
3203
3204 /* reverse: prevent GTK from deleting the widget arbitrarily */
3205 gtk_widget_unref( m_widget );
3206
3207 return TRUE;
3208 }
3209
3210 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3211 {
3212 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3213
3214 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3215
3216 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3217
3218 /* add to list */
3219 AddChild( child );
3220
3221 /* insert GTK representation */
3222 (*m_insertCallback)(this, child);
3223 }
3224
3225 void wxWindowGTK::Raise()
3226 {
3227 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3228
3229 if (!m_widget->window) return;
3230
3231 gdk_window_raise( m_widget->window );
3232 }
3233
3234 void wxWindowGTK::Lower()
3235 {
3236 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3237
3238 if (!m_widget->window) return;
3239
3240 gdk_window_lower( m_widget->window );
3241 }
3242
3243 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3244 {
3245 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3246
3247 if (cursor == m_cursor)
3248 return FALSE;
3249
3250 if (g_isIdle)
3251 wxapp_install_idle_handler();
3252
3253 if (cursor == wxNullCursor)
3254 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3255 else
3256 return wxWindowBase::SetCursor( cursor );
3257 }
3258
3259 void wxWindowGTK::WarpPointer( int x, int y )
3260 {
3261 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3262
3263 /* we provide this function ourselves as it is
3264 missing in GDK (top of this file) */
3265
3266 GdkWindow *window = (GdkWindow*) NULL;
3267 if (m_wxwindow)
3268 window = GTK_PIZZA(m_wxwindow)->bin_window;
3269 else
3270 window = GetConnectWidget()->window;
3271
3272 if (window)
3273 gdk_window_warp_pointer( window, x, y );
3274 }
3275
3276 void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3277 {
3278 if (!m_widget) return;
3279 if (!m_widget->window) return;
3280
3281 // temporarily hide the caret to avoid nasty interactions between caret
3282 // drawing and the window contents redraw
3283 #if 0 // def wxUSE_CARET -- doesn't seem to help :-(
3284 wxCaretSuspend cs((wxWindow *)this);
3285 #endif // wxUSE_CARET
3286
3287 if (eraseBackground && m_wxwindow && m_wxwindow->window)
3288 {
3289 if (rect)
3290 {
3291 gdk_window_clear_area( GTK_PIZZA(m_wxwindow)->bin_window,
3292 rect->x, rect->y,
3293 rect->width, rect->height );
3294 }
3295 else
3296 {
3297 gdk_window_clear( GTK_PIZZA(m_wxwindow)->bin_window );
3298 }
3299 }
3300
3301 /* there is no GTK equivalent of "draw only, don't clear" so we
3302 invent our own in the GtkPizza widget */
3303
3304 if (!rect)
3305 {
3306 if (m_wxwindow)
3307 {
3308
3309 /*
3310 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
3311 gboolean old_clear = pizza->clear_on_draw;
3312 gtk_pizza_set_clear( pizza, FALSE );
3313 gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
3314 gtk_pizza_set_clear( pizza, old_clear );
3315 */
3316 GdkEventExpose gdk_event;
3317 gdk_event.type = GDK_EXPOSE;
3318 gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window;
3319 gdk_event.count = 0;
3320 gdk_event.area.x = 0;
3321 gdk_event.area.y = 0;
3322 gdk_event.area.width = m_wxwindow->allocation.width;
3323 gdk_event.area.height = m_wxwindow->allocation.height;
3324 gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );
3325 }
3326 else
3327 {
3328 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
3329 }
3330 }
3331 else
3332 {
3333
3334 if (m_wxwindow)
3335 {
3336 /*
3337 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
3338 gboolean old_clear = pizza->clear_on_draw;
3339 gtk_pizza_set_clear( pizza, FALSE );
3340
3341 GdkRectangle gdk_rect;
3342 gdk_rect.x = rect->x;
3343 gdk_rect.y = rect->y;
3344 gdk_rect.width = rect->width;
3345 gdk_rect.height = rect->height;
3346 gtk_widget_draw( m_wxwindow, &gdk_rect );
3347 gtk_window_draw_callback( m_wxwindow, &gdk_rect, this );
3348
3349 gtk_pizza_set_clear( pizza, old_clear );
3350 */
3351 GdkEventExpose gdk_event;
3352 gdk_event.type = GDK_EXPOSE;
3353 gdk_event.window = GTK_PIZZA(m_wxwindow)->bin_window;
3354 gdk_event.count = 0;
3355 gdk_event.area.x = rect->x;
3356 gdk_event.area.y = rect->y;
3357 gdk_event.area.width = rect->width;
3358 gdk_event.area.height = rect->height;
3359 gtk_window_expose_callback( m_wxwindow, &gdk_event, (wxWindow *)this );
3360 }
3361 else
3362 {
3363 GdkRectangle gdk_rect;
3364 gdk_rect.x = rect->x;
3365 gdk_rect.y = rect->y;
3366 gdk_rect.width = rect->width;
3367 gdk_rect.height = rect->height;
3368 gtk_widget_draw( m_widget, &gdk_rect );
3369 }
3370 }
3371 }
3372
3373 void wxWindowGTK::Clear()
3374 {
3375 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3376
3377 if (!m_widget->window) return;
3378
3379 if (m_wxwindow && m_wxwindow->window)
3380 {
3381 // gdk_window_clear( m_wxwindow->window );
3382 }
3383 }
3384
3385 #if wxUSE_TOOLTIPS
3386 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3387 {
3388 wxWindowBase::DoSetToolTip(tip);
3389
3390 if (m_tooltip)
3391 m_tooltip->Apply( (wxWindow *)this );
3392 }
3393
3394 void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
3395 {
3396 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
3397 }
3398 #endif // wxUSE_TOOLTIPS
3399
3400 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3401 {
3402 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3403
3404 if (!wxWindowBase::SetBackgroundColour(colour))
3405 {
3406 // don't leave if the GTK widget has just
3407 // been realized
3408 if (!m_delayedBackgroundColour) return FALSE;
3409 }
3410
3411 GdkWindow *window = (GdkWindow*) NULL;
3412 if (m_wxwindow)
3413 window = GTK_PIZZA(m_wxwindow)->bin_window;
3414 else
3415 window = GetConnectWidget()->window;
3416
3417 if (!window)
3418 {
3419 // indicate that a new style has been set
3420 // but it couldn't get applied as the
3421 // widget hasn't been realized yet.
3422 m_delayedBackgroundColour = TRUE;
3423 }
3424
3425 if ((m_wxwindow) &&
3426 (m_wxwindow->window) &&
3427 (m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE)))
3428 {
3429 /* wxMSW doesn't clear the window here. I don't do that either to
3430 provide compatibility. call Clear() to do the job. */
3431
3432 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
3433 gdk_window_set_background( window, m_backgroundColour.GetColor() );
3434 }
3435
3436 ApplyWidgetStyle();
3437
3438 return TRUE;
3439 }
3440
3441 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3442 {
3443 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3444
3445 if (!wxWindowBase::SetForegroundColour(colour))
3446 {
3447 // don't leave if the GTK widget has just
3448 // been realized
3449 if (!m_delayedForegroundColour) return FALSE;
3450 }
3451
3452 GdkWindow *window = (GdkWindow*) NULL;
3453 if (m_wxwindow)
3454 window = GTK_PIZZA(m_wxwindow)->bin_window;
3455 else
3456 window = GetConnectWidget()->window;
3457
3458 if (!window)
3459 {
3460 // indicate that a new style has been set
3461 // but it couldn't get applied as the
3462 // widget hasn't been realized yet.
3463 m_delayedForegroundColour = TRUE;
3464 }
3465
3466 ApplyWidgetStyle();
3467
3468 return TRUE;
3469 }
3470
3471 GtkStyle *wxWindowGTK::GetWidgetStyle()
3472 {
3473 if (m_widgetStyle)
3474 {
3475 GtkStyle *remake = gtk_style_copy( m_widgetStyle );
3476 #ifdef __WXGTK20__
3477 /* FIXME: is this necessary? */
3478 _G_TYPE_IGC(remake, GtkObjectClass) = _G_TYPE_IGC(m_widgetStyle, GtkObjectClass);
3479 #else
3480 remake->klass = m_widgetStyle->klass;
3481 #endif
3482
3483 gtk_style_unref( m_widgetStyle );
3484 m_widgetStyle = remake;
3485 }
3486 else
3487 {
3488 GtkStyle *def = gtk_rc_get_style( m_widget );
3489
3490 if (!def)
3491 def = gtk_widget_get_default_style();
3492
3493 m_widgetStyle = gtk_style_copy( def );
3494 #ifdef __WXGTK20__
3495 /* FIXME: is this necessary? */
3496 _G_TYPE_IGC(m_widgetStyle, GtkObjectClass) = _G_TYPE_IGC(def, GtkObjectClass);
3497 #else
3498 m_widgetStyle->klass = def->klass;
3499 #endif
3500 }
3501
3502 return m_widgetStyle;
3503 }
3504
3505 void wxWindowGTK::SetWidgetStyle()
3506 {
3507 #if DISABLE_STYLE_IF_BROKEN_THEM
3508 if (m_widget->style->engine_data)
3509 {
3510 static bool s_warningPrinted = FALSE;
3511 if (!s_warningPrinted)
3512 {
3513 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
3514 s_warningPrinted = TRUE;
3515 }
3516 m_widgetStyle = m_widget->style;
3517 return;
3518 }
3519 #endif
3520
3521 GtkStyle *style = GetWidgetStyle();
3522
3523 if (m_font != wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT ))
3524 {
3525 gdk_font_unref( style->font );
3526 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
3527 }
3528
3529 if (m_foregroundColour.Ok())
3530 {
3531 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
3532 if (m_foregroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNTEXT))
3533 {
3534 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
3535 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
3536 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
3537 }
3538 else
3539 {
3540 // Try to restore the gtk default style. This is still a little
3541 // oversimplified for what is probably really needed here for controls
3542 // other than buttons, but is better than not being able to (re)set a
3543 // control's foreground colour to *wxBLACK -- RL
3544 GtkStyle *def = gtk_rc_get_style( m_widget );
3545
3546 if (!def)
3547 def = gtk_widget_get_default_style();
3548
3549 style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
3550 style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
3551 style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
3552 }
3553 }
3554
3555 if (m_backgroundColour.Ok())
3556 {
3557 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
3558 if (m_backgroundColour != wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE))
3559 {
3560 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
3561 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
3562 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
3563 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
3564 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
3565 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
3566 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
3567 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
3568 }
3569 else
3570 {
3571 // Try to restore the gtk default style. This is still a little
3572 // oversimplified for what is probably really needed here for controls
3573 // other than buttons, but is better than not being able to (re)set a
3574 // control's background colour to default grey and means resetting a
3575 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
3576 // behavior -- RL
3577 GtkStyle *def = gtk_rc_get_style( m_widget );
3578
3579 if (!def)
3580 def = gtk_widget_get_default_style();
3581
3582 style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
3583 style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
3584 style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
3585 style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
3586 style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
3587 style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
3588 style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
3589 style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
3590 }
3591 }
3592 }
3593
3594 void wxWindowGTK::ApplyWidgetStyle()
3595 {
3596 }
3597
3598 //-----------------------------------------------------------------------------
3599 // Pop-up menu stuff
3600 //-----------------------------------------------------------------------------
3601
3602 #if wxUSE_MENUS_NATIVE
3603
3604 static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
3605 {
3606 *is_waiting = FALSE;
3607 }
3608
3609 static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
3610 {
3611 menu->SetInvokingWindow( win );
3612 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
3613 while (node)
3614 {
3615 wxMenuItem *menuitem = node->GetData();
3616 if (menuitem->IsSubMenu())
3617 {
3618 SetInvokingWindow( menuitem->GetSubMenu(), win );
3619 }
3620
3621 node = node->GetNext();
3622 }
3623 }
3624
3625 static gint gs_pop_x = 0;
3626 static gint gs_pop_y = 0;
3627
3628 static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
3629 gint *x, gint *y,
3630 wxWindowGTK *win )
3631 {
3632 win->ClientToScreen( &gs_pop_x, &gs_pop_y );
3633 *x = gs_pop_x;
3634 *y = gs_pop_y;
3635 }
3636
3637 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
3638 {
3639 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3640
3641 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
3642
3643 SetInvokingWindow( menu, this );
3644
3645 menu->UpdateUI();
3646
3647 gs_pop_x = x;
3648 gs_pop_y = y;
3649
3650 bool is_waiting = TRUE;
3651
3652 gtk_signal_connect( GTK_OBJECT(menu->m_menu), "hide",
3653 GTK_SIGNAL_FUNC(gtk_pop_hide_callback), (gpointer)&is_waiting );
3654
3655 gtk_menu_popup(
3656 GTK_MENU(menu->m_menu),
3657 (GtkWidget *) NULL, // parent menu shell
3658 (GtkWidget *) NULL, // parent menu item
3659 (GtkMenuPositionFunc) pop_pos_callback,
3660 (gpointer) this, // client data
3661 0, // button used to activate it
3662 gs_timeLastClick // the time of activation
3663 );
3664
3665 while (is_waiting)
3666 {
3667 while (gtk_events_pending())
3668 gtk_main_iteration();
3669 }
3670
3671 return TRUE;
3672 }
3673
3674 #endif // wxUSE_MENUS_NATIVE
3675
3676 #if wxUSE_DRAG_AND_DROP
3677
3678 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
3679 {
3680 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3681
3682 GtkWidget *dnd_widget = GetConnectWidget();
3683
3684 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
3685
3686 if (m_dropTarget) delete m_dropTarget;
3687 m_dropTarget = dropTarget;
3688
3689 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
3690 }
3691
3692 #endif // wxUSE_DRAG_AND_DROP
3693
3694 GtkWidget* wxWindowGTK::GetConnectWidget()
3695 {
3696 GtkWidget *connect_widget = m_widget;
3697 if (m_wxwindow) connect_widget = m_wxwindow;
3698
3699 return connect_widget;
3700 }
3701
3702 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
3703 {
3704 if (m_wxwindow)
3705 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
3706
3707 return (window == m_widget->window);
3708 }
3709
3710 bool wxWindowGTK::SetFont( const wxFont &font )
3711 {
3712 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3713
3714 if (!wxWindowBase::SetFont(font))
3715 {
3716 return FALSE;
3717 }
3718
3719 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
3720 if ( sysbg == m_backgroundColour )
3721 {
3722 m_backgroundColour = wxNullColour;
3723 ApplyWidgetStyle();
3724 m_backgroundColour = sysbg;
3725 }
3726 else
3727 {
3728 ApplyWidgetStyle();
3729 }
3730
3731 return TRUE;
3732 }
3733
3734 void wxWindowGTK::CaptureMouse()
3735 {
3736 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3737
3738 GdkWindow *window = (GdkWindow*) NULL;
3739 if (m_wxwindow)
3740 window = GTK_PIZZA(m_wxwindow)->bin_window;
3741 else
3742 window = GetConnectWidget()->window;
3743
3744 wxCHECK_RET( window, _T("CaptureMouse() failed") );
3745
3746 wxCursor* cursor = & m_cursor;
3747 if (!cursor->Ok())
3748 cursor = wxSTANDARD_CURSOR;
3749
3750 gdk_pointer_grab( window, FALSE,
3751 (GdkEventMask)
3752 (GDK_BUTTON_PRESS_MASK |
3753 GDK_BUTTON_RELEASE_MASK |
3754 GDK_POINTER_MOTION_HINT_MASK |
3755 GDK_POINTER_MOTION_MASK),
3756 (GdkWindow *) NULL,
3757 cursor->GetCursor(),
3758 (guint32)GDK_CURRENT_TIME );
3759 g_captureWindow = this;
3760 g_captureWindowHasMouse = TRUE;
3761 }
3762
3763 void wxWindowGTK::ReleaseMouse()
3764 {
3765 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3766
3767 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
3768
3769 GdkWindow *window = (GdkWindow*) NULL;
3770 if (m_wxwindow)
3771 window = GTK_PIZZA(m_wxwindow)->bin_window;
3772 else
3773 window = GetConnectWidget()->window;
3774
3775 if (!window)
3776 return;
3777
3778 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
3779 g_captureWindow = (wxWindowGTK*) NULL;
3780 }
3781
3782 /* static */
3783 wxWindow *wxWindowBase::GetCapture()
3784 {
3785 return (wxWindow *)g_captureWindow;
3786 }
3787
3788 bool wxWindowGTK::IsRetained() const
3789 {
3790 return FALSE;
3791 }
3792
3793 void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
3794 int range, bool refresh )
3795 {
3796 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3797
3798 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3799
3800 m_hasScrolling = TRUE;
3801
3802 if (orient == wxHORIZONTAL)
3803 {
3804 float fpos = (float)pos;
3805 float frange = (float)range;
3806 float fthumb = (float)thumbVisible;
3807 if (fpos > frange-fthumb) fpos = frange-fthumb;
3808 if (fpos < 0.0) fpos = 0.0;
3809
3810 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
3811 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
3812 {
3813 SetScrollPos( orient, pos, refresh );
3814 return;
3815 }
3816
3817 m_oldHorizontalPos = fpos;
3818
3819 m_hAdjust->lower = 0.0;
3820 m_hAdjust->upper = frange;
3821 m_hAdjust->value = fpos;
3822 m_hAdjust->step_increment = 1.0;
3823 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
3824 m_hAdjust->page_size = fthumb;
3825 }
3826 else
3827 {
3828 float fpos = (float)pos;
3829 float frange = (float)range;
3830 float fthumb = (float)thumbVisible;
3831 if (fpos > frange-fthumb) fpos = frange-fthumb;
3832 if (fpos < 0.0) fpos = 0.0;
3833
3834 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
3835 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
3836 {
3837 SetScrollPos( orient, pos, refresh );
3838 return;
3839 }
3840
3841 m_oldVerticalPos = fpos;
3842
3843 m_vAdjust->lower = 0.0;
3844 m_vAdjust->upper = frange;
3845 m_vAdjust->value = fpos;
3846 m_vAdjust->step_increment = 1.0;
3847 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
3848 m_vAdjust->page_size = fthumb;
3849 }
3850
3851 if (orient == wxHORIZONTAL)
3852 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
3853 else
3854 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
3855 }
3856
3857 void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
3858 {
3859 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3860
3861 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3862
3863 if (orient == wxHORIZONTAL)
3864 {
3865 float fpos = (float)pos;
3866 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
3867 if (fpos < 0.0) fpos = 0.0;
3868 m_oldHorizontalPos = fpos;
3869
3870 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
3871 m_hAdjust->value = fpos;
3872 }
3873 else
3874 {
3875 float fpos = (float)pos;
3876 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
3877 if (fpos < 0.0) fpos = 0.0;
3878 m_oldVerticalPos = fpos;
3879
3880 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
3881 m_vAdjust->value = fpos;
3882 }
3883
3884 if (m_wxwindow->window)
3885 {
3886 if (orient == wxHORIZONTAL)
3887 {
3888 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
3889 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
3890
3891 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
3892
3893 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
3894 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
3895 }
3896 else
3897 {
3898 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
3899 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
3900
3901 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
3902
3903 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
3904 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
3905 }
3906 }
3907 }
3908
3909 int wxWindowGTK::GetScrollThumb( int orient ) const
3910 {
3911 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
3912
3913 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
3914
3915 if (orient == wxHORIZONTAL)
3916 return (int)(m_hAdjust->page_size+0.5);
3917 else
3918 return (int)(m_vAdjust->page_size+0.5);
3919 }
3920
3921 int wxWindowGTK::GetScrollPos( int orient ) const
3922 {
3923 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
3924
3925 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
3926
3927 if (orient == wxHORIZONTAL)
3928 return (int)(m_hAdjust->value+0.5);
3929 else
3930 return (int)(m_vAdjust->value+0.5);
3931 }
3932
3933 int wxWindowGTK::GetScrollRange( int orient ) const
3934 {
3935 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
3936
3937 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
3938
3939 if (orient == wxHORIZONTAL)
3940 return (int)(m_hAdjust->upper+0.5);
3941 else
3942 return (int)(m_vAdjust->upper+0.5);
3943 }
3944
3945 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
3946 {
3947 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3948
3949 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3950
3951 if ((dx == 0) && (dy == 0)) return;
3952
3953 m_clipPaintRegion = TRUE;
3954 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
3955 m_clipPaintRegion = FALSE;
3956
3957 /*
3958 if (m_children.GetCount() > 0)
3959 {
3960 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
3961 }
3962 else
3963 {
3964 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
3965
3966 pizza->xoffset -= dx;
3967 pizza->yoffset -= dy;
3968
3969 GdkGC *m_scrollGC = gdk_gc_new( pizza->bin_window );
3970 gdk_gc_set_exposures( m_scrollGC, TRUE );
3971
3972 int cw = 0;
3973 int ch = 0;
3974 GetClientSize( &cw, &ch );
3975 int w = cw - abs(dx);
3976 int h = ch - abs(dy);
3977
3978 if ((h < 0) || (w < 0))
3979 {
3980 Refresh();
3981 }
3982 else
3983 {
3984 int s_x = 0;
3985 int s_y = 0;
3986 if (dx < 0) s_x = -dx;
3987 if (dy < 0) s_y = -dy;
3988 int d_x = 0;
3989 int d_y = 0;
3990 if (dx > 0) d_x = dx;
3991 if (dy > 0) d_y = dy;
3992
3993 gdk_window_copy_area( pizza->bin_window, m_scrollGC, d_x, d_y,
3994 pizza->bin_window, s_x, s_y, w, h );
3995
3996 wxRect rect;
3997 if (dx < 0) rect.x = cw+dx; else rect.x = 0;
3998 if (dy < 0) rect.y = ch+dy; else rect.y = 0;
3999 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
4000 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
4001
4002 Refresh( TRUE, &rect );
4003 }
4004
4005 gdk_gc_unref( m_scrollGC );
4006 }
4007 */
4008 }
4009
4010 // Find the wxWindow at the current mouse position, also returning the mouse
4011 // position.
4012 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4013 {
4014 pt = wxGetMousePosition();
4015 wxWindow* found = wxFindWindowAtPoint(pt);
4016 return found;
4017 }
4018
4019 // Get the current mouse position.
4020 wxPoint wxGetMousePosition()
4021 {
4022 /* This crashes when used within wxHelpContext,
4023 so we have to use the X-specific implementation below.
4024 gint x, y;
4025 GdkModifierType *mask;
4026 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4027
4028 return wxPoint(x, y);
4029 */
4030
4031 int x, y;
4032 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4033 if (!windowAtPtr)
4034 return wxPoint(-999, -999);
4035
4036 Display *display = GDK_WINDOW_XDISPLAY(windowAtPtr);
4037 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4038 Window rootReturn, childReturn;
4039 int rootX, rootY, winX, winY;
4040 unsigned int maskReturn;
4041
4042 XQueryPointer (display,
4043 rootWindow,
4044 &rootReturn,
4045 &childReturn,
4046 &rootX, &rootY, &winX, &winY, &maskReturn);
4047 return wxPoint(rootX, rootY);
4048
4049 }
4050
wxWidgets (Impactor)