]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Disabling PNG, TIFF and JPEG works now.
[wxWidgets.git] / src / gtk / window.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: 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 #include "wx/defs.h"
16 #include "wx/window.h"
17 #include "wx/dc.h"
18 #include "wx/frame.h"
19 #include "wx/app.h"
20 #include "wx/layout.h"
21 #include "wx/utils.h"
22 #include "wx/dialog.h"
23 #include "wx/msgdlg.h"
24
25 #if wxUSE_DRAG_AND_DROP
26 #include "wx/dnd.h"
27 #endif
28
29 #if wxUSE_TOOLTIPS
30 #include "wx/tooltip.h"
31 #endif
32
33 #include "wx/menu.h"
34 #include "wx/statusbr.h"
35 #include "wx/intl.h"
36 #include "wx/settings.h"
37 #include "wx/log.h"
38
39 #include <math.h>
40
41 #include "gdk/gdk.h"
42 #include "gtk/gtk.h"
43 #include "gdk/gdkprivate.h"
44 #include "gdk/gdkkeysyms.h"
45 #include "wx/gtk/win_gtk.h"
46
47 #include "gdk/gdkx.h"
48
49 //-----------------------------------------------------------------------------
50 // documentation on internals
51 //-----------------------------------------------------------------------------
52
53 /*
54 I have been asked several times about writing some documentation about
55 the GTK port of wxWindows, especially its internal structures. Obviously,
56 you cannot understand wxGTK without knowing a little about the GTK, but
57 some more information about what the wxWindow, which is the base class
58 for all other window classes, does seems required as well.
59
60 I)
61
62 What does wxWindow do? It contains the common interface for the following
63 jobs of its descendants:
64
65 1) Define the rudimentary behaviour common to all window classes, such as
66 resizing, intercepting user input (so as to make it possible to use these
67 events for special purposes in a derived class), window names etc.
68
69 2) Provide the possibility to contain and manage children, if the derived
70 class is allowed to contain children, which holds true for those window
71 classes which do not display a native GTK widget. To name them, these
72 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
73 work classes are a special case and are handled a bit differently from
74 the rest. The same holds true for the wxNotebook class.
75
76 3) Provide the possibility to draw into a client area of a window. This,
77 too, only holds true for classes that do not display a native GTK widget
78 as above.
79
80 4) Provide the entire mechanism for scrolling widgets. This actual inter-
81 face for this is usually in wxScrolledWindow, but the GTK implementation
82 is in this class.
83
84 5) A multitude of helper or extra methods for special purposes, such as
85 Drag'n'Drop, managing validators etc.
86
87 6) Display a border (sunken, raised, simple or none).
88
89 Normally one might expect, that one wxWindows window would always correspond
90 to one GTK widget. Under GTK, there is no such allround widget that has all
91 the functionality. Moreover, the GTK defines a client area as a different
92 widget from the actual widget you are handling. Last but not least some
93 special classes (e.g. wxFrame) handle different categories of widgets and
94 still have the possibility to draw something in the client area.
95 It was therefore required to write a special purpose GTK widget, that would
96 represent a client area in the sense of wxWindows capable to do the jobs
97 2), 3) and 4). I have written this class and it resides in win_gtk.c of
98 this directory.
99
100 All windows must have a widget, with which they interact with other under-
101 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
102 thw wxWindow class has a member variable called m_widget which holds a
103 pointer to this widget. When the window class represents a GTK native widget,
104 this is (in most cases) the only GTK widget the class manages. E.g. the
105 wxStatitText class handles only a GtkLabel widget a pointer to which you
106 can find in m_widget (defined in wxWindow)
107
108 When the class has a client area for drawing into and for containing children
109 it has to handle the client area widget (of the type GtkPizza, defined in
110 win_gtk.c), but there could be any number of widgets, handled by a class
111 The common rule for all windows is only, that the widget that interacts with
112 the rest of GTK must be referenced in m_widget and all other widgets must be
113 children of this widget on the GTK level. The top-most widget, which also
114 represents the client area, must be in the m_wxwindow field and must be of
115 the type GtkPizza.
116
117 As I said, the window classes that display a GTK native widget only have
118 one widget, so in the case of e.g. the wxButton class m_widget holds a
119 pointer to a GtkButton widget. But windows with client areas (for drawing
120 and children) have a m_widget field that is a pointer to a GtkScrolled-
121 Window and a m_wxwindow field that is pointer to a GtkPizza and this
122 one is (in the GTK sense) a child of the GtkScrolledWindow.
123
124 If the m_wxwindow field is set, then all input to this widget is inter-
125 cepted and sent to the wxWindows class. If not, all input to the widget
126 that gets pointed to by m_widget gets intercepted and sent to the class.
127
128 II)
129
130 The design of scrolling in wxWindows is markedly different from that offered
131 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
132 clicking on a scrollbar belonging to scrolled window will inevitably move
133 the window. In wxWindows, the scrollbar will only emit an event, send this
134 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
135 which actually moves the window and its subchildren. Note that GtkPizza
136 memorizes how much it has been scrolled but that wxWindows forgets this
137 so that the two coordinates systems have to be kept in synch. This is done
138 in various places using the pizza->xoffset and pizza->yoffset values.
139
140 III)
141
142 Singularily the most broken code in GTK is the code that is supposes to
143 inform subwindows (child windows) about new positions. Very often, duplicate
144 events are sent without changes in size or position, equally often no
145 events are sent at all (All this is due to a bug in the GtkContainer code
146 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
147 GTK's own system and it simply waits for size events for toplevel windows
148 and then iterates down the respective size events to all window. This has
149 the disadvantage, that windows might get size events before the GTK widget
150 actually has the reported size. This doesn't normally pose any problem, but
151 the OpenGl drawing routines rely on correct behaviour. Therefore, I have
152 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
153 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
154 window that is used for OpenGl output really has that size (as reported by
155 GTK).
156
157 IV)
158
159 If someone at some point of time feels the immense desire to have a look at,
160 change or attempt to optimse the Refresh() logic, this person will need an
161 intimate understanding of what a "draw" and what an "expose" events are and
162 what there are used for, in particular when used in connection with GTK's
163 own windowless widgets. Beware.
164
165 V)
166
167 Cursors, too, have been a constant source of pleasure. The main difficulty
168 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
169 for the parent. To prevent this from doing too much harm, I use idle time
170 to set the cursor over and over again, starting from the toplevel windows
171 and ending with the youngest generation (speaking of parent and child windows).
172 Also don't forget that cursors (like much else) are connected to GdkWindows,
173 not GtkWidgets and that the "window" field of a GtkWidget might very well
174 point to the GdkWindow of the parent widget (-> "window less widget") and
175 that the two obviously have very different meanings.
176
177 */
178
179 //-----------------------------------------------------------------------------
180 // data
181 //-----------------------------------------------------------------------------
182
183 extern wxList wxPendingDelete;
184 extern bool g_blockEventsOnDrag;
185 extern bool g_blockEventsOnScroll;
186 extern wxCursor g_globalCursor;
187 static wxWindow *g_captureWindow = (wxWindow*) NULL;
188
189 /* extern */ wxWindow *g_focusWindow = (wxWindow*) NULL;
190
191 // if we detect that the app has got/lost the focus, we set this variable to
192 // either TRUE or FALSE and an activate event will be sent during the next
193 // OnIdle() call and it is reset to -1: this value means that we shouldn't
194 // send any activate events at all
195 static int g_sendActivateEvent = -1;
196
197 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
198 the last click here */
199 static guint32 gs_timeLastClick = 0;
200
201 //-----------------------------------------------------------------------------
202 // debug
203 //-----------------------------------------------------------------------------
204
205 #ifdef __WXDEBUG__
206
207 static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
208 GdkEvent *WXUNUSED(event),
209 const wxChar *WXUNUSED(name) )
210 {
211 /*
212 static bool s_done = FALSE;
213 if ( !s_done )
214 {
215 wxLog::AddTraceMask("focus");
216 s_done = TRUE;
217 }
218 wxLogTrace(wxT("FOCUS NOW AT: %s"), name);
219 */
220
221 return FALSE;
222 }
223
224 void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window )
225 {
226 /*
227 wxString tmp = name;
228 tmp += wxT(" FROM ");
229 tmp += window;
230
231 wxChar *s = new wxChar[tmp.Length()+1];
232
233 wxStrcpy( s, tmp );
234
235 gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
236 GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
237 */
238 }
239
240 #endif // Debug
241
242 //-----------------------------------------------------------------------------
243 // missing gdk functions
244 //-----------------------------------------------------------------------------
245
246 void
247 gdk_window_warp_pointer (GdkWindow *window,
248 gint x,
249 gint y)
250 {
251 GdkWindowPrivate *priv;
252
253 if (!window)
254 window = (GdkWindow*) &gdk_root_parent;
255
256 priv = (GdkWindowPrivate*) window;
257
258 if (!priv->destroyed)
259 {
260 XWarpPointer (priv->xdisplay,
261 None, /* not source window -> move from anywhere */
262 priv->xwindow, /* dest window */
263 0, 0, 0, 0, /* not source window -> move from anywhere */
264 x, y );
265 }
266 }
267
268 //-----------------------------------------------------------------------------
269 // idle system
270 //-----------------------------------------------------------------------------
271
272 extern void wxapp_install_idle_handler();
273 extern bool g_isIdle;
274
275 //-----------------------------------------------------------------------------
276 // local code (see below)
277 //-----------------------------------------------------------------------------
278
279 static void draw_frame( GtkWidget *widget, wxWindow *win )
280 {
281 if (!win->m_hasVMT)
282 return;
283
284 int dw = 0;
285 int dh = 0;
286
287 if (win->HasScrolling())
288 {
289 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
290 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget)->klass );
291
292 /*
293 GtkWidget *hscrollbar = scroll_window->hscrollbar;
294 GtkWidget *vscrollbar = scroll_window->vscrollbar;
295
296 we use this instead: range.slider_width = 11 + 2*2pts edge
297 */
298
299 if (scroll_window->vscrollbar_visible)
300 {
301 dw += 15; /* dw += vscrollbar->allocation.width; */
302 dw += scroll_class->scrollbar_spacing;
303 }
304
305 if (scroll_window->hscrollbar_visible)
306 {
307 dh += 15; /* dh += hscrollbar->allocation.height; */
308 dh += scroll_class->scrollbar_spacing;
309 }
310 }
311
312 int dx = 0;
313 int dy = 0;
314 if (GTK_WIDGET_NO_WINDOW (widget))
315 {
316 dx += widget->allocation.x;
317 dy += widget->allocation.y;
318 }
319
320 if (win->HasFlag(wxRAISED_BORDER))
321 {
322 gtk_draw_shadow( widget->style,
323 widget->window,
324 GTK_STATE_NORMAL,
325 GTK_SHADOW_OUT,
326 dx, dy,
327 win->m_width-dw, win->m_height-dh );
328 return;
329 }
330
331 if (win->HasFlag(wxSUNKEN_BORDER))
332 {
333 gtk_draw_shadow( widget->style,
334 widget->window,
335 GTK_STATE_NORMAL,
336 GTK_SHADOW_IN,
337 dx, dy,
338 win->m_width-dw, win->m_height-dh );
339 return;
340 }
341
342 if (win->HasFlag(wxSIMPLE_BORDER))
343 {
344 GdkGC *gc;
345 gc = gdk_gc_new( widget->window );
346 gdk_gc_set_foreground( gc, &widget->style->black );
347 gdk_draw_rectangle( widget->window, gc, FALSE,
348 dx, dy,
349 win->m_width-dw-1, win->m_height-dh-1 );
350 gdk_gc_unref( gc );
351 return;
352 }
353 }
354
355 //-----------------------------------------------------------------------------
356 // "expose_event" of m_widget
357 //-----------------------------------------------------------------------------
358
359 static void gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
360 {
361 if (gdk_event->count > 0) return;
362 draw_frame( widget, win );
363 }
364
365 //-----------------------------------------------------------------------------
366 // "draw" of m_widget
367 //-----------------------------------------------------------------------------
368
369 static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindow *win )
370 {
371 draw_frame( widget, win );
372 }
373
374 //-----------------------------------------------------------------------------
375 // key code mapping routines
376 //-----------------------------------------------------------------------------
377
378 static long map_to_unmodified_wx_keysym( KeySym keysym )
379 {
380 guint key_code = 0;
381
382 switch (keysym)
383 {
384 case GDK_Shift_L:
385 case GDK_Shift_R: key_code = WXK_SHIFT; break;
386 case GDK_Control_L:
387 case GDK_Control_R: key_code = WXK_CONTROL; break;
388 case GDK_Meta_L:
389 case GDK_Meta_R:
390 case GDK_Alt_L:
391 case GDK_Alt_R:
392 case GDK_Super_L:
393 case GDK_Super_R: key_code = WXK_ALT; break;
394 case GDK_Menu: key_code = WXK_MENU; break;
395 case GDK_Help: key_code = WXK_HELP; break;
396 case GDK_BackSpace: key_code = WXK_BACK; break;
397 case GDK_ISO_Left_Tab:
398 case GDK_Tab: key_code = WXK_TAB; break;
399 case GDK_Linefeed: key_code = WXK_RETURN; break;
400 case GDK_Clear: key_code = WXK_CLEAR; break;
401 case GDK_Return: key_code = WXK_RETURN; break;
402 case GDK_Pause: key_code = WXK_PAUSE; break;
403 case GDK_Scroll_Lock: key_code = WXK_SCROLL; break;
404 case GDK_Escape: key_code = WXK_ESCAPE; break;
405 case GDK_Delete: key_code = WXK_DELETE; break;
406 case GDK_Home: key_code = WXK_HOME; break;
407 case GDK_Left: key_code = WXK_LEFT; break;
408 case GDK_Up: key_code = WXK_UP; break;
409 case GDK_Right: key_code = WXK_RIGHT; break;
410 case GDK_Down: key_code = WXK_DOWN; break;
411 case GDK_Prior: key_code = WXK_PRIOR; break;
412 // case GDK_Page_Up: key_code = WXK_PAGEUP; break;
413 case GDK_Next: key_code = WXK_NEXT; break;
414 // case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
415 case GDK_End: key_code = WXK_END; break;
416 case GDK_Begin: key_code = WXK_HOME; break;
417 case GDK_Select: key_code = WXK_SELECT; break;
418 case GDK_Print: key_code = WXK_PRINT; break;
419 case GDK_Execute: key_code = WXK_EXECUTE; break;
420 case GDK_Insert: key_code = WXK_INSERT; break;
421 case GDK_Num_Lock: key_code = WXK_NUMLOCK; break;
422
423 case GDK_KP_0: key_code = WXK_NUMPAD0; break;
424 case GDK_KP_1: key_code = WXK_NUMPAD1; break;
425 case GDK_KP_2: key_code = WXK_NUMPAD2; break;
426 case GDK_KP_3: key_code = WXK_NUMPAD3; break;
427 case GDK_KP_4: key_code = WXK_NUMPAD4; break;
428 case GDK_KP_5: key_code = WXK_NUMPAD5; break;
429 case GDK_KP_6: key_code = WXK_NUMPAD6; break;
430 case GDK_KP_7: key_code = WXK_NUMPAD7; break;
431 case GDK_KP_8: key_code = WXK_NUMPAD8; break;
432 case GDK_KP_9: key_code = WXK_NUMPAD9; break;
433 case GDK_KP_Space: key_code = WXK_NUMPAD_SPACE; break;
434 case GDK_KP_Tab: key_code = WXK_NUMPAD_TAB; break;
435 case GDK_KP_Enter: key_code = WXK_NUMPAD_ENTER; break;
436 case GDK_KP_F1: key_code = WXK_NUMPAD_F1; break;
437 case GDK_KP_F2: key_code = WXK_NUMPAD_F2; break;
438 case GDK_KP_F3: key_code = WXK_NUMPAD_F3; break;
439 case GDK_KP_F4: key_code = WXK_NUMPAD_F4; break;
440 case GDK_KP_Home: key_code = WXK_NUMPAD_HOME; break;
441 case GDK_KP_Left: key_code = WXK_NUMPAD_LEFT; break;
442 case GDK_KP_Up: key_code = WXK_NUMPAD_UP; break;
443 case GDK_KP_Right: key_code = WXK_NUMPAD_RIGHT; break;
444 case GDK_KP_Down: key_code = WXK_NUMPAD_DOWN; break;
445 case GDK_KP_Prior: key_code = WXK_NUMPAD_PRIOR; break;
446 // case GDK_KP_Page_Up: key_code = WXK_NUMPAD_PAGEUP; break;
447 case GDK_KP_Next: key_code = WXK_NUMPAD_NEXT; break;
448 // case GDK_KP_Page_Down: key_code = WXK_NUMPAD_PAGEDOWN; break;
449 case GDK_KP_End: key_code = WXK_NUMPAD_END; break;
450 case GDK_KP_Begin: key_code = WXK_NUMPAD_BEGIN; break;
451 case GDK_KP_Insert: key_code = WXK_NUMPAD_INSERT; break;
452 case GDK_KP_Delete: key_code = WXK_NUMPAD_DELETE; break;
453 case GDK_KP_Equal: key_code = WXK_NUMPAD_EQUAL; break;
454 case GDK_KP_Multiply: key_code = WXK_NUMPAD_MULTIPLY; break;
455 case GDK_KP_Add: key_code = WXK_NUMPAD_ADD; break;
456 case GDK_KP_Separator: key_code = WXK_NUMPAD_SEPARATOR; break;
457 case GDK_KP_Subtract: key_code = WXK_NUMPAD_SUBTRACT; break;
458 case GDK_KP_Decimal: key_code = WXK_NUMPAD_DECIMAL; break;
459 case GDK_KP_Divide: key_code = WXK_NUMPAD_DIVIDE; break;
460
461 case GDK_F1: key_code = WXK_F1; break;
462 case GDK_F2: key_code = WXK_F2; break;
463 case GDK_F3: key_code = WXK_F3; break;
464 case GDK_F4: key_code = WXK_F4; break;
465 case GDK_F5: key_code = WXK_F5; break;
466 case GDK_F6: key_code = WXK_F6; break;
467 case GDK_F7: key_code = WXK_F7; break;
468 case GDK_F8: key_code = WXK_F8; break;
469 case GDK_F9: key_code = WXK_F9; break;
470 case GDK_F10: key_code = WXK_F10; break;
471 case GDK_F11: key_code = WXK_F11; break;
472 case GDK_F12: key_code = WXK_F12; break;
473 default:
474 {
475 if (keysym <= 0xFF)
476 {
477 guint upper = gdk_keyval_to_upper( (guint)keysym );
478 keysym = (upper != 0 ? upper : keysym ); /* to be MSW compatible */
479 key_code = (guint)keysym;
480 }
481 }
482 }
483
484 return (key_code);
485 }
486
487 static long map_to_wx_keysym( KeySym keysym )
488 {
489 guint key_code = 0;
490
491 switch (keysym)
492 {
493 case GDK_Menu: key_code = WXK_MENU; break;
494 case GDK_Help: key_code = WXK_HELP; break;
495 case GDK_BackSpace: key_code = WXK_BACK; break;
496 case GDK_ISO_Left_Tab:
497 case GDK_Tab: key_code = WXK_TAB; break;
498 case GDK_Linefeed: key_code = WXK_RETURN; break;
499 case GDK_Clear: key_code = WXK_CLEAR; break;
500 case GDK_Return: key_code = WXK_RETURN; break;
501 case GDK_Pause: key_code = WXK_PAUSE; break;
502 case GDK_Scroll_Lock: key_code = WXK_SCROLL; break;
503 case GDK_Escape: key_code = WXK_ESCAPE; break;
504 case GDK_Delete: key_code = WXK_DELETE; break;
505 case GDK_Home: key_code = WXK_HOME; break;
506 case GDK_Left: key_code = WXK_LEFT; break;
507 case GDK_Up: key_code = WXK_UP; break;
508 case GDK_Right: key_code = WXK_RIGHT; break;
509 case GDK_Down: key_code = WXK_DOWN; break;
510 case GDK_Prior: key_code = WXK_PRIOR; break;
511 // case GDK_Page_Up: key_code = WXK_PAGEUP; break;
512 case GDK_Next: key_code = WXK_NEXT; break;
513 // case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
514 case GDK_End: key_code = WXK_END; break;
515 case GDK_Begin: key_code = WXK_HOME; break;
516 case GDK_Select: key_code = WXK_SELECT; break;
517 case GDK_Print: key_code = WXK_PRINT; break;
518 case GDK_Execute: key_code = WXK_EXECUTE; break;
519 case GDK_Insert: key_code = WXK_INSERT; break;
520 case GDK_Num_Lock: key_code = WXK_NUMLOCK; break;
521
522 case GDK_KP_0: key_code = '0'; break;
523 case GDK_KP_1: key_code = '1'; break;
524 case GDK_KP_2: key_code = '2'; break;
525 case GDK_KP_3: key_code = '3'; break;
526 case GDK_KP_4: key_code = '4'; break;
527 case GDK_KP_5: key_code = '5'; break;
528 case GDK_KP_6: key_code = '6'; break;
529 case GDK_KP_7: key_code = '7'; break;
530 case GDK_KP_8: key_code = '8'; break;
531 case GDK_KP_9: key_code = '9'; break;
532 case GDK_KP_Space: key_code = ' '; break;
533 case GDK_KP_Tab: key_code = WXK_TAB; break; /* or '\t' ??? */
534 case GDK_KP_Enter: key_code = WXK_RETURN; break; /* or '\r' ??? */
535 case GDK_KP_F1: key_code = WXK_NUMPAD_F1; break;
536 case GDK_KP_F2: key_code = WXK_NUMPAD_F2; break;
537 case GDK_KP_F3: key_code = WXK_NUMPAD_F3; break;
538 case GDK_KP_F4: key_code = WXK_NUMPAD_F4; break;
539 case GDK_KP_Home: key_code = WXK_HOME; break;
540 case GDK_KP_Left: key_code = WXK_LEFT; break;
541 case GDK_KP_Up: key_code = WXK_UP; break;
542 case GDK_KP_Right: key_code = WXK_RIGHT; break;
543 case GDK_KP_Down: key_code = WXK_DOWN; break;
544 case GDK_KP_Prior: key_code = WXK_PRIOR; break;
545 // case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
546 case GDK_KP_Next: key_code = WXK_NEXT; break;
547 // case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
548 case GDK_KP_End: key_code = WXK_END; break;
549 case GDK_KP_Begin: key_code = WXK_HOME; break;
550 case GDK_KP_Insert: key_code = WXK_INSERT; break;
551 case GDK_KP_Delete: key_code = WXK_DELETE; break;
552 case GDK_KP_Equal: key_code = '='; break;
553 case GDK_KP_Multiply: key_code = '*'; break;
554 case GDK_KP_Add: key_code = '+'; break;
555 case GDK_KP_Separator: key_code = ','; break;
556 case GDK_KP_Subtract: key_code = '-'; break;
557 case GDK_KP_Decimal: key_code = '.'; break;
558 case GDK_KP_Divide: key_code = '/'; break;
559
560 case GDK_F1: key_code = WXK_F1; break;
561 case GDK_F2: key_code = WXK_F2; break;
562 case GDK_F3: key_code = WXK_F3; break;
563 case GDK_F4: key_code = WXK_F4; break;
564 case GDK_F5: key_code = WXK_F5; break;
565 case GDK_F6: key_code = WXK_F6; break;
566 case GDK_F7: key_code = WXK_F7; break;
567 case GDK_F8: key_code = WXK_F8; break;
568 case GDK_F9: key_code = WXK_F9; break;
569 case GDK_F10: key_code = WXK_F10; break;
570 case GDK_F11: key_code = WXK_F11; break;
571 case GDK_F12: key_code = WXK_F12; break;
572 default:
573 {
574 if (keysym <= 0xFF)
575 {
576 key_code = (guint)keysym;
577 }
578 }
579 }
580
581 return (key_code);
582 }
583
584 //-----------------------------------------------------------------------------
585 // "expose_event" of m_wxwindow
586 //-----------------------------------------------------------------------------
587
588 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
589 {
590 if (!win->m_hasVMT)
591 return;
592
593 win->GetUpdateRegion().Union( gdk_event->area.x,
594 gdk_event->area.y,
595 gdk_event->area.width,
596 gdk_event->area.height );
597
598 if (gdk_event->count > 0)
599 return;
600
601 /*
602 wxPrintf( "OnExpose from " );
603 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
604 wxPrintf( win->GetClassInfo()->GetClassName() );
605 wxPrintf( " %d %d %d %d\n", (int)gdk_event->area.x,
606 (int)gdk_event->area.y,
607 (int)gdk_event->area.width,
608 (int)gdk_event->area.height );
609 */
610
611 wxEraseEvent eevent( win->GetId() );
612 eevent.SetEventObject( win );
613 win->GetEventHandler()->ProcessEvent(eevent);
614
615 wxPaintEvent event( win->GetId() );
616 event.SetEventObject( win );
617 win->GetEventHandler()->ProcessEvent( event );
618
619 win->GetUpdateRegion().Clear();
620 }
621
622 //-----------------------------------------------------------------------------
623 // "draw" of m_wxwindow
624 //-----------------------------------------------------------------------------
625
626 static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget),
627 GdkRectangle *rect, wxWindow *win )
628 {
629 if (g_isIdle)
630 wxapp_install_idle_handler();
631
632 if (!win->m_hasVMT)
633 return;
634
635 win->GetUpdateRegion().Union( rect->x, rect->y,
636 rect->width, rect->height );
637
638 /*
639 wxPrintf( "OnDraw from " );
640 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
641 printf( win->GetClassInfo()->GetClassName() );
642 wxPrintf( " %d %d %d %d\n", (int)rect->x,
643 (int)rect->y,
644 (int)rect->width,
645 (int)rect->height );
646 */
647
648 wxEraseEvent eevent( win->GetId() );
649 eevent.SetEventObject( win );
650 win->GetEventHandler()->ProcessEvent(eevent);
651
652 wxPaintEvent event( win->GetId() );
653 event.SetEventObject( win );
654 win->GetEventHandler()->ProcessEvent( event );
655
656 win->GetUpdateRegion().Clear();
657 }
658
659 //-----------------------------------------------------------------------------
660 // "key_press_event" from any window
661 //-----------------------------------------------------------------------------
662
663 static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
664 {
665 if (g_isIdle)
666 wxapp_install_idle_handler();
667
668 if (!win->m_hasVMT) return FALSE;
669 if (g_blockEventsOnDrag) return FALSE;
670
671 /*
672 printf( "KeyDown-ScanCode is: %d.\n", gdk_event->keyval );
673 if (gdk_event->state & GDK_SHIFT_MASK)
674 printf( "ShiftDown.\n" );
675 else
676 printf( "ShiftUp.\n" );
677 if (gdk_event->state & GDK_CONTROL_MASK)
678 printf( "ControlDown.\n" );
679 else
680 printf( "ControlUp.\n" );
681 printf( "\n" );
682 */
683 int x = 0;
684 int y = 0;
685 GdkModifierType state;
686 if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
687
688 bool ret = FALSE;
689
690 long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
691 /* sending unknown key events doesn't really make sense */
692 if (key_code == 0) return FALSE;
693
694 wxKeyEvent event( wxEVT_KEY_DOWN );
695 event.SetTimestamp( gdk_event->time );
696 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
697 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
698 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
699 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
700 event.m_keyCode = key_code;
701 event.m_scanCode = gdk_event->keyval;
702 event.m_x = x;
703 event.m_y = y;
704 event.SetEventObject( win );
705 ret = win->GetEventHandler()->ProcessEvent( event );
706
707 #if wxUSE_ACCEL
708 if (!ret)
709 {
710 wxWindow *ancestor = win;
711 while (ancestor)
712 {
713 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
714 if (command != -1)
715 {
716 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
717 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
718 break;
719 }
720 if (ancestor->m_isFrame)
721 break;
722 ancestor = ancestor->GetParent();
723 }
724 }
725 #endif // wxUSE_ACCEL
726
727 /* wxMSW doesn't send char events with Alt pressed */
728 /* Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
729 will only be sent if it is not in an accelerator table. */
730 key_code = map_to_wx_keysym( gdk_event->keyval );
731
732 if ( (!ret) &&
733 (key_code != 0))
734 {
735 wxKeyEvent event2( wxEVT_CHAR );
736 event2.SetTimestamp( gdk_event->time );
737 event2.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
738 event2.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
739 event2.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
740 event2.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
741 event2.m_keyCode = key_code;
742 event2.m_scanCode = gdk_event->keyval;
743 event2.m_x = x;
744 event2.m_y = y;
745 event2.SetEventObject( win );
746 ret = win->GetEventHandler()->ProcessEvent( event2 );
747 }
748
749 /* win is a control: tab can be propagated up */
750 if ( (!ret) &&
751 ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
752 (!win->HasFlag(wxTE_PROCESS_TAB)) &&
753 (win->GetParent()) &&
754 (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
755 {
756 wxNavigationKeyEvent new_event;
757 new_event.SetEventObject( win );
758 /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
759 new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
760 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
761 new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
762 new_event.SetCurrentFocus( win );
763 ret = win->GetEventHandler()->ProcessEvent( new_event );
764 }
765
766 /* generate wxID_CANCEL if <esc> has been pressed (typically in dialogs) */
767 if ( (!ret) &&
768 (gdk_event->keyval == GDK_Escape) )
769 {
770 wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
771 new_event.SetEventObject( win );
772 ret = win->GetEventHandler()->ProcessEvent( new_event );
773 }
774
775 #if (GTK_MINOR_VERSION > 0)
776 /* Pressing F10 will activate the menu bar of the top frame. */
777 /* Doesn't work. */
778 /*
779 if ( (!ret) &&
780 (gdk_event->keyval == GDK_F10) )
781 {
782 wxWindow *ancestor = win;
783 while (ancestor)
784 {
785 if (wxIsKindOf(ancestor,wxFrame))
786 {
787 wxFrame *frame = (wxFrame*) ancestor;
788 wxMenuBar *menubar = frame->GetMenuBar();
789 if (menubar)
790 {
791 wxNode *node = menubar->GetMenus().First();
792 if (node)
793 {
794 wxMenu *firstMenu = (wxMenu*) node->Data();
795 gtk_menu_item_select( GTK_MENU_ITEM(firstMenu->m_owner) );
796 ret = TRUE;
797 break;
798 }
799 }
800 }
801 ancestor = ancestor->GetParent();
802 }
803 }
804 */
805 #endif
806
807 if (ret)
808 {
809 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
810 return TRUE;
811 }
812
813 return FALSE;
814 }
815
816 //-----------------------------------------------------------------------------
817 // "key_release_event" from any window
818 //-----------------------------------------------------------------------------
819
820 static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
821 {
822 if (g_isIdle)
823 wxapp_install_idle_handler();
824
825 if (!win->m_hasVMT) return FALSE;
826 if (g_blockEventsOnDrag) return FALSE;
827
828 /*
829 printf( "KeyUp-ScanCode is: %d.\n", gdk_event->keyval );
830 if (gdk_event->state & GDK_SHIFT_MASK)
831 printf( "ShiftDown.\n" );
832 else
833 printf( "ShiftUp.\n" );
834 if (gdk_event->state & GDK_CONTROL_MASK)
835 printf( "ControlDown.\n" );
836 else
837 printf( "ControlUp.\n" );
838 printf( "\n" );
839 */
840
841 long key_code = map_to_unmodified_wx_keysym( gdk_event->keyval );
842
843 /* sending unknown key events doesn't really make sense */
844 if (key_code == 0) return FALSE;
845
846 int x = 0;
847 int y = 0;
848 GdkModifierType state;
849 if (gdk_event->window) gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
850
851 wxKeyEvent event( wxEVT_KEY_UP );
852 event.SetTimestamp( gdk_event->time );
853 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
854 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
855 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
856 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
857 event.m_keyCode = key_code;
858 event.m_scanCode = gdk_event->keyval;
859 event.m_x = x;
860 event.m_y = y;
861 event.SetEventObject( win );
862
863 if (win->GetEventHandler()->ProcessEvent( event ))
864 {
865 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
866 return TRUE;
867 }
868
869 return FALSE;
870 }
871
872 //-----------------------------------------------------------------------------
873 // "button_press_event"
874 //-----------------------------------------------------------------------------
875
876 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
877 {
878 if (g_isIdle)
879 wxapp_install_idle_handler();
880
881 /*
882 wxPrintf( wxT("1) OnButtonPress from ") );
883 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
884 wxPrintf( win->GetClassInfo()->GetClassName() );
885 wxPrintf( wxT(".\n") );
886 */
887 if (!win->m_hasVMT) return FALSE;
888 if (g_blockEventsOnDrag) return TRUE;
889 if (g_blockEventsOnScroll) return TRUE;
890
891 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
892
893 if (win->m_wxwindow)
894 {
895 if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (win->m_wxwindow) )
896 {
897 gtk_widget_grab_focus (win->m_wxwindow);
898
899 /*
900 wxPrintf( wxT("GrabFocus from ") );
901 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
902 wxPrintf( win->GetClassInfo()->GetClassName() );
903 wxPrintf( wxT(".\n") );
904 */
905
906 }
907 }
908
909 wxEventType event_type = wxEVT_LEFT_DOWN;
910
911 if (gdk_event->button == 1)
912 {
913 switch (gdk_event->type)
914 {
915 case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
916 case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
917 default: break;
918 }
919 }
920 else if (gdk_event->button == 2)
921 {
922 switch (gdk_event->type)
923 {
924 case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
925 case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
926 default: break;
927 }
928 }
929 else if (gdk_event->button == 3)
930 {
931 switch (gdk_event->type)
932 {
933 case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
934 case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
935 default: break;
936 }
937 }
938
939 wxMouseEvent event( event_type );
940 event.SetTimestamp( gdk_event->time );
941 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
942 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
943 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
944 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
945 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
946 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
947 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
948
949 event.m_x = (long)gdk_event->x;
950 event.m_y = (long)gdk_event->y;
951
952 // Some control don't have their own X window and thus cannot get
953 // any events.
954
955 if (!g_captureWindow)
956 {
957 wxCoord x = event.m_x;
958 wxCoord y = event.m_y;
959 if (win->m_wxwindow)
960 {
961 GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
962 x += pizza->xoffset;
963 y += pizza->yoffset;
964 }
965
966 wxNode *node = win->GetChildren().First();
967 while (node)
968 {
969 wxWindow *child = (wxWindow*)node->Data();
970
971 node = node->Next();
972 if (!child->IsShown())
973 continue;
974
975 if (child->m_isStaticBox)
976 {
977 // wxStaticBox is transparent in the box itself
978 int xx1 = child->m_x;
979 int yy1 = child->m_y;
980 int xx2 = child->m_x + child->m_width;
981 int yy2 = child->m_x + child->m_height;
982
983 // left
984 if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
985 // right
986 ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
987 // top
988 ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
989 // bottom
990 ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
991 {
992 win = child;
993 event.m_x -= child->m_x;
994 event.m_y -= child->m_y;
995 break;
996 }
997
998 }
999 else
1000 {
1001 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
1002 (child->m_x <= x) &&
1003 (child->m_y <= y) &&
1004 (child->m_x+child->m_width >= x) &&
1005 (child->m_y+child->m_height >= y))
1006 {
1007 win = child;
1008 event.m_x -= child->m_x;
1009 event.m_y -= child->m_y;
1010 break;
1011 }
1012 }
1013 }
1014 }
1015
1016 event.SetEventObject( win );
1017
1018 gs_timeLastClick = gdk_event->time;
1019
1020 /*
1021 wxPrintf( wxT("2) OnButtonPress from ") );
1022 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1023 wxPrintf( win->GetClassInfo()->GetClassName() );
1024 wxPrintf( wxT(".\n") );
1025 */
1026
1027 if (win->GetEventHandler()->ProcessEvent( event ))
1028 {
1029 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
1030 return TRUE;
1031 }
1032
1033 return FALSE;
1034 }
1035
1036 //-----------------------------------------------------------------------------
1037 // "button_release_event"
1038 //-----------------------------------------------------------------------------
1039
1040 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
1041 {
1042 if (g_isIdle)
1043 wxapp_install_idle_handler();
1044
1045 if (!win->m_hasVMT) return FALSE;
1046 if (g_blockEventsOnDrag) return FALSE;
1047 if (g_blockEventsOnScroll) return FALSE;
1048
1049 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1050
1051 /*
1052 printf( "OnButtonRelease from " );
1053 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1054 printf( win->GetClassInfo()->GetClassName() );
1055 printf( ".\n" );
1056 */
1057
1058 wxEventType event_type = wxEVT_NULL;
1059
1060 switch (gdk_event->button)
1061 {
1062 case 1: event_type = wxEVT_LEFT_UP; break;
1063 case 2: event_type = wxEVT_MIDDLE_UP; break;
1064 case 3: event_type = wxEVT_RIGHT_UP; break;
1065 }
1066
1067 wxMouseEvent event( event_type );
1068 event.SetTimestamp( gdk_event->time );
1069 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1070 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1071 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1072 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1073 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1074 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1075 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
1076 event.m_x = (long)gdk_event->x;
1077 event.m_y = (long)gdk_event->y;
1078
1079 // Some control don't have their own X window and thus cannot get
1080 // any events.
1081
1082 if (!g_captureWindow)
1083 {
1084 wxCoord x = event.m_x;
1085 wxCoord y = event.m_y;
1086 if (win->m_wxwindow)
1087 {
1088 GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
1089 x += pizza->xoffset;
1090 y += pizza->yoffset;
1091 }
1092
1093 wxNode *node = win->GetChildren().First();
1094 while (node)
1095 {
1096 wxWindow *child = (wxWindow*)node->Data();
1097
1098 node = node->Next();
1099 if (!child->IsShown())
1100 continue;
1101
1102 if (child->m_isStaticBox)
1103 {
1104 // wxStaticBox is transparent in the box itself
1105 int xx1 = child->m_x;
1106 int yy1 = child->m_y;
1107 int xx2 = child->m_x + child->m_width;
1108 int yy2 = child->m_x + child->m_height;
1109
1110 // left
1111 if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
1112 // right
1113 ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
1114 // top
1115 ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
1116 // bottom
1117 ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
1118 {
1119 win = child;
1120 event.m_x -= child->m_x;
1121 event.m_y -= child->m_y;
1122 break;
1123 }
1124
1125 }
1126 else
1127 {
1128 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
1129 (child->m_x <= x) &&
1130 (child->m_y <= y) &&
1131 (child->m_x+child->m_width >= x) &&
1132 (child->m_y+child->m_height >= y))
1133 {
1134 win = child;
1135 event.m_x -= child->m_x;
1136 event.m_y -= child->m_y;
1137 break;
1138 }
1139 }
1140 }
1141 }
1142
1143 event.SetEventObject( win );
1144
1145 if (win->GetEventHandler()->ProcessEvent( event ))
1146 {
1147 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
1148 return TRUE;
1149 }
1150
1151 return FALSE;
1152 }
1153
1154 //-----------------------------------------------------------------------------
1155 // "motion_notify_event"
1156 //-----------------------------------------------------------------------------
1157
1158 static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
1159 {
1160 if (g_isIdle)
1161 wxapp_install_idle_handler();
1162
1163 if (!win->m_hasVMT) return FALSE;
1164 if (g_blockEventsOnDrag) return FALSE;
1165 if (g_blockEventsOnScroll) return FALSE;
1166
1167 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1168
1169 if (gdk_event->is_hint)
1170 {
1171 int x = 0;
1172 int y = 0;
1173 GdkModifierType state;
1174 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1175 gdk_event->x = x;
1176 gdk_event->y = y;
1177 }
1178
1179 /*
1180 printf( "OnMotion from " );
1181 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1182 printf( win->GetClassInfo()->GetClassName() );
1183 printf( ".\n" );
1184 */
1185
1186 wxMouseEvent event( wxEVT_MOTION );
1187 event.SetTimestamp( gdk_event->time );
1188 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
1189 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
1190 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
1191 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
1192 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
1193 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
1194 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
1195
1196 event.m_x = (long)gdk_event->x;
1197 event.m_y = (long)gdk_event->y;
1198
1199 // Some control don't have their own X window and thus cannot get
1200 // any events.
1201
1202 if (!g_captureWindow)
1203 {
1204 wxCoord x = event.m_x;
1205 wxCoord y = event.m_y;
1206 if (win->m_wxwindow)
1207 {
1208 GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
1209 x += pizza->xoffset;
1210 y += pizza->yoffset;
1211 }
1212
1213 wxNode *node = win->GetChildren().First();
1214 while (node)
1215 {
1216 wxWindow *child = (wxWindow*)node->Data();
1217
1218 node = node->Next();
1219 if (!child->IsShown())
1220 continue;
1221
1222 if (child->m_isStaticBox)
1223 {
1224 // wxStaticBox is transparent in the box itself
1225 int xx1 = child->m_x;
1226 int yy1 = child->m_y;
1227 int xx2 = child->m_x + child->m_width;
1228 int yy2 = child->m_x + child->m_height;
1229
1230 // left
1231 if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
1232 // right
1233 ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
1234 // top
1235 ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
1236 // bottom
1237 ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
1238 {
1239 win = child;
1240 event.m_x -= child->m_x;
1241 event.m_y -= child->m_y;
1242 break;
1243 }
1244
1245 }
1246 else
1247 {
1248 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
1249 (child->m_x <= x) &&
1250 (child->m_y <= y) &&
1251 (child->m_x+child->m_width >= x) &&
1252 (child->m_y+child->m_height >= y))
1253 {
1254 win = child;
1255 event.m_x -= child->m_x;
1256 event.m_y -= child->m_y;
1257 break;
1258 }
1259 }
1260 }
1261 }
1262
1263 event.SetEventObject( win );
1264
1265 if (win->GetEventHandler()->ProcessEvent( event ))
1266 {
1267 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
1268 return TRUE;
1269 }
1270
1271 return FALSE;
1272 }
1273
1274 //-----------------------------------------------------------------------------
1275 // "focus_in_event"
1276 //-----------------------------------------------------------------------------
1277
1278 static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
1279 {
1280 if (g_isIdle)
1281 wxapp_install_idle_handler();
1282
1283 if (!win->m_hasVMT) return FALSE;
1284 if (g_blockEventsOnDrag) return FALSE;
1285
1286 switch ( g_sendActivateEvent )
1287 {
1288 case -1:
1289 // we've got focus from outside, synthtize wxActivateEvent
1290 g_sendActivateEvent = 1;
1291 break;
1292
1293 case 0:
1294 // another our window just lost focus, it was already ours before
1295 // - don't send any wxActivateEvent
1296 g_sendActivateEvent = -1;
1297 break;
1298 }
1299
1300 g_focusWindow = win;
1301
1302 /*
1303 printf( "OnSetFocus from " );
1304 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1305 printf( win->GetClassInfo()->GetClassName() );
1306 printf( " " );
1307 printf( WXSTRINGCAST win->GetLabel() );
1308 printf( ".\n" );
1309 */
1310
1311 wxPanel *panel = wxDynamicCast(win->GetParent(), wxPanel);
1312 if (panel)
1313 {
1314 panel->SetLastFocus(win);
1315 }
1316
1317 wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
1318 event.SetEventObject( win );
1319
1320 if (win->GetEventHandler()->ProcessEvent( event ))
1321 {
1322 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
1323 return TRUE;
1324 }
1325
1326 return FALSE;
1327 }
1328
1329 //-----------------------------------------------------------------------------
1330 // "focus_out_event"
1331 //-----------------------------------------------------------------------------
1332
1333 static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
1334 {
1335 if (g_isIdle)
1336 wxapp_install_idle_handler();
1337
1338 if (!win->m_hasVMT) return FALSE;
1339 if (g_blockEventsOnDrag) return FALSE;
1340
1341 // if the focus goes out of our app alltogether, OnIdle() will send
1342 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
1343 // g_sendActivateEvent to -1
1344 g_sendActivateEvent = 0;
1345
1346 g_focusWindow = (wxWindow *)NULL;
1347
1348 /*
1349 printf( "OnKillFocus from " );
1350 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1351 printf( win->GetClassInfo()->GetClassName() );
1352 printf( ".\n" );
1353 */
1354
1355 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
1356 event.SetEventObject( win );
1357
1358 if (win->GetEventHandler()->ProcessEvent( event ))
1359 {
1360 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
1361 return TRUE;
1362 }
1363
1364 return FALSE;
1365 }
1366
1367 //-----------------------------------------------------------------------------
1368 // "enter_notify_event"
1369 //-----------------------------------------------------------------------------
1370
1371 static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
1372 {
1373 if (g_isIdle)
1374 wxapp_install_idle_handler();
1375
1376 if (!win->m_hasVMT) return FALSE;
1377 if (g_blockEventsOnDrag) return FALSE;
1378
1379 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1380
1381 wxMouseEvent event( wxEVT_ENTER_WINDOW );
1382 #if (GTK_MINOR_VERSION > 0)
1383 event.SetTimestamp( gdk_event->time );
1384 #endif
1385 event.SetEventObject( win );
1386
1387 int x = 0;
1388 int y = 0;
1389 GdkModifierType state = (GdkModifierType)0;
1390
1391 gdk_window_get_pointer( widget->window, &x, &y, &state );
1392
1393 event.m_shiftDown = (state & GDK_SHIFT_MASK);
1394 event.m_controlDown = (state & GDK_CONTROL_MASK);
1395 event.m_altDown = (state & GDK_MOD1_MASK);
1396 event.m_metaDown = (state & GDK_MOD2_MASK);
1397 event.m_leftDown = (state & GDK_BUTTON1_MASK);
1398 event.m_middleDown = (state & GDK_BUTTON2_MASK);
1399 event.m_rightDown = (state & GDK_BUTTON3_MASK);
1400
1401 event.m_x = (long)x;
1402 event.m_y = (long)y;
1403
1404 if (win->GetEventHandler()->ProcessEvent( event ))
1405 {
1406 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
1407 return TRUE;
1408 }
1409
1410 return FALSE;
1411 }
1412
1413 //-----------------------------------------------------------------------------
1414 // "leave_notify_event"
1415 //-----------------------------------------------------------------------------
1416
1417 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
1418 {
1419 if (g_isIdle)
1420 wxapp_install_idle_handler();
1421
1422 if (!win->m_hasVMT) return FALSE;
1423 if (g_blockEventsOnDrag) return FALSE;
1424
1425 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1426
1427 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1428 #if (GTK_MINOR_VERSION > 0)
1429 event.SetTimestamp( gdk_event->time );
1430 #endif
1431 event.SetEventObject( win );
1432
1433 int x = 0;
1434 int y = 0;
1435 GdkModifierType state = (GdkModifierType)0;
1436
1437 gdk_window_get_pointer( widget->window, &x, &y, &state );
1438
1439 event.m_shiftDown = (state & GDK_SHIFT_MASK);
1440 event.m_controlDown = (state & GDK_CONTROL_MASK);
1441 event.m_altDown = (state & GDK_MOD1_MASK);
1442 event.m_metaDown = (state & GDK_MOD2_MASK);
1443 event.m_leftDown = (state & GDK_BUTTON1_MASK);
1444 event.m_middleDown = (state & GDK_BUTTON2_MASK);
1445 event.m_rightDown = (state & GDK_BUTTON3_MASK);
1446
1447 event.m_x = (long)x;
1448 event.m_y = (long)y;
1449
1450 if (win->GetEventHandler()->ProcessEvent( event ))
1451 {
1452 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
1453 return TRUE;
1454 }
1455
1456 return FALSE;
1457 }
1458
1459 //-----------------------------------------------------------------------------
1460 // "value_changed" from m_vAdjust
1461 //-----------------------------------------------------------------------------
1462
1463 static void gtk_window_vscroll_callback( GtkAdjustment *adjust, wxWindow *win )
1464 {
1465 if (g_isIdle)
1466 wxapp_install_idle_handler();
1467
1468 if (g_blockEventsOnDrag) return;
1469
1470 if (!win->m_hasVMT) return;
1471
1472 float diff = adjust->value - win->m_oldVerticalPos;
1473 if (fabs(diff) < 0.2) return;
1474
1475 win->m_oldVerticalPos = adjust->value;
1476
1477 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
1478 GtkRange *range = GTK_RANGE( scrolledWindow->vscrollbar );
1479
1480 wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
1481 if (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
1482 else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD) command = wxEVT_SCROLLWIN_LINEDOWN;
1483 else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
1484 else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD) command = wxEVT_SCROLLWIN_PAGEDOWN;
1485
1486 int value = (int)(adjust->value+0.5);
1487
1488 wxScrollWinEvent event( command, value, wxVERTICAL );
1489 event.SetEventObject( win );
1490 win->GetEventHandler()->ProcessEvent( event );
1491 }
1492
1493 //-----------------------------------------------------------------------------
1494 // "value_changed" from m_hAdjust
1495 //-----------------------------------------------------------------------------
1496
1497 static void gtk_window_hscroll_callback( GtkAdjustment *adjust, wxWindow *win )
1498 {
1499 if (g_isIdle)
1500 wxapp_install_idle_handler();
1501
1502 if (g_blockEventsOnDrag) return;
1503 if (!win->m_hasVMT) return;
1504
1505 float diff = adjust->value - win->m_oldHorizontalPos;
1506 if (fabs(diff) < 0.2) return;
1507
1508 win->m_oldHorizontalPos = adjust->value;
1509
1510 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
1511 GtkRange *range = GTK_RANGE( scrolledWindow->hscrollbar );
1512
1513 wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
1514 if (range->scroll_type == GTK_SCROLL_STEP_BACKWARD) command = wxEVT_SCROLLWIN_LINEUP;
1515 else if (range->scroll_type == GTK_SCROLL_STEP_FORWARD) command = wxEVT_SCROLLWIN_LINEDOWN;
1516 else if (range->scroll_type == GTK_SCROLL_PAGE_BACKWARD) command = wxEVT_SCROLLWIN_PAGEUP;
1517 else if (range->scroll_type == GTK_SCROLL_PAGE_FORWARD) command = wxEVT_SCROLLWIN_PAGEDOWN;
1518
1519 int value = (int)(adjust->value+0.5);
1520
1521 wxScrollWinEvent event( command, value, wxHORIZONTAL );
1522 event.SetEventObject( win );
1523 win->GetEventHandler()->ProcessEvent( event );
1524 }
1525
1526 //-----------------------------------------------------------------------------
1527 // "changed" from m_vAdjust
1528 //-----------------------------------------------------------------------------
1529
1530 static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1531 {
1532 if (g_isIdle)
1533 wxapp_install_idle_handler();
1534
1535 if (g_blockEventsOnDrag) return;
1536 if (!win->m_hasVMT) return;
1537
1538 wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
1539 int value = (int)(win->m_vAdjust->value+0.5);
1540
1541 wxScrollWinEvent event( command, value, wxVERTICAL );
1542 event.SetEventObject( win );
1543 win->GetEventHandler()->ProcessEvent( event );
1544 }
1545
1546 //-----------------------------------------------------------------------------
1547 // "changed" from m_hAdjust
1548 //-----------------------------------------------------------------------------
1549
1550 static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1551 {
1552 if (g_isIdle)
1553 wxapp_install_idle_handler();
1554
1555 if (g_blockEventsOnDrag) return;
1556 if (!win->m_hasVMT) return;
1557
1558 wxEventType command = wxEVT_SCROLLWIN_THUMBTRACK;
1559 int value = (int)(win->m_hAdjust->value+0.5);
1560
1561 wxScrollWinEvent event( command, value, wxHORIZONTAL );
1562 event.SetEventObject( win );
1563 win->GetEventHandler()->ProcessEvent( event );
1564 }
1565
1566 //-----------------------------------------------------------------------------
1567 // "button_press_event" from scrollbar
1568 //-----------------------------------------------------------------------------
1569
1570 static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
1571 GdkEventButton *WXUNUSED(gdk_event),
1572 wxWindow *win )
1573 {
1574 if (g_isIdle)
1575 wxapp_install_idle_handler();
1576
1577 // don't test here as we can release the mouse while being over
1578 // a different window than the slider
1579 //
1580 // if (gdk_event->window != widget->slider) return FALSE;
1581
1582 win->SetScrolling( TRUE );
1583
1584 return FALSE;
1585 }
1586
1587 //-----------------------------------------------------------------------------
1588 // "button_release_event" from scrollbar
1589 //-----------------------------------------------------------------------------
1590
1591 static gint gtk_scrollbar_button_release_callback( GtkRange *WXUNUSED(widget),
1592 GdkEventButton *WXUNUSED(gdk_event),
1593 wxWindow *win )
1594 {
1595
1596 // don't test here as we can release the mouse while being over
1597 // a different window than the slider
1598 //
1599 // if (gdk_event->window != widget->slider) return FALSE;
1600
1601 win->SetScrolling( FALSE );
1602
1603 return FALSE;
1604 }
1605
1606 // ----------------------------------------------------------------------------
1607 // this wxWindowBase function is implemented here (in platform-specific file)
1608 // because it is static and so couldn't be made virtual
1609 // ----------------------------------------------------------------------------
1610
1611 wxWindow *wxWindowBase::FindFocus()
1612 {
1613 return g_focusWindow;
1614 }
1615
1616 //-----------------------------------------------------------------------------
1617 // "realize" from m_widget
1618 //-----------------------------------------------------------------------------
1619
1620 /* we cannot set colours and fonts before the widget has
1621 been realized, so we do this directly after realization */
1622
1623 static gint
1624 gtk_window_realized_callback( GtkWidget * WXUNUSED(widget), wxWindow *win )
1625 {
1626 if (g_isIdle)
1627 wxapp_install_idle_handler();
1628
1629 if (win->m_delayedFont)
1630 win->SetFont( win->GetFont() );
1631
1632 if (win->m_delayedBackgroundColour)
1633 win->SetBackgroundColour( win->GetBackgroundColour() );
1634
1635 if (win->m_delayedForegroundColour)
1636 win->SetForegroundColour( win->GetForegroundColour() );
1637
1638 wxWindowCreateEvent event( win );
1639 event.SetEventObject( win );
1640 win->GetEventHandler()->ProcessEvent( event );
1641
1642 return FALSE;
1643 }
1644
1645 //-----------------------------------------------------------------------------
1646 // InsertChild for wxWindow.
1647 //-----------------------------------------------------------------------------
1648
1649 /* Callback for wxWindow. This very strange beast has to be used because
1650 * C++ has no virtual methods in a constructor. We have to emulate a
1651 * virtual function here as wxNotebook requires a different way to insert
1652 * a child in it. I had opted for creating a wxNotebookPage window class
1653 * which would have made this superfluous (such in the MDI window system),
1654 * but no-one was listening to me... */
1655
1656 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
1657 {
1658 /* the window might have been scrolled already, do we
1659 have to adapt the position */
1660 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
1661 child->m_x += pizza->xoffset;
1662 child->m_y += pizza->yoffset;
1663
1664 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
1665 GTK_WIDGET(child->m_widget),
1666 child->m_x,
1667 child->m_y,
1668 child->m_width,
1669 child->m_height );
1670 }
1671
1672 //-----------------------------------------------------------------------------
1673 // global functions
1674 //-----------------------------------------------------------------------------
1675
1676 wxWindow* wxGetActiveWindow()
1677 {
1678 return g_focusWindow;
1679 }
1680
1681 //-----------------------------------------------------------------------------
1682 // wxWindow
1683 //-----------------------------------------------------------------------------
1684
1685 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
1686
1687 void wxWindow::Init()
1688 {
1689 // common init
1690 InitBase();
1691
1692 // GTK specific
1693 m_widget = (GtkWidget *) NULL;
1694 m_wxwindow = (GtkWidget *) NULL;
1695
1696 // position/size
1697 m_x = 0;
1698 m_y = 0;
1699 m_width = 0;
1700 m_height = 0;
1701
1702 m_sizeSet = FALSE;
1703 m_hasVMT = FALSE;
1704 m_needParent = TRUE;
1705 m_isBeingDeleted = FALSE;
1706
1707 m_noExpose = FALSE;
1708 m_nativeSizeEvent = FALSE;
1709
1710 m_hasScrolling = FALSE;
1711 m_isScrolling = FALSE;
1712
1713 m_hAdjust = (GtkAdjustment*) NULL;
1714 m_vAdjust = (GtkAdjustment*) NULL;
1715 m_oldHorizontalPos = 0.0;
1716 m_oldVerticalPos = 0.0;
1717
1718 m_resizing = FALSE;
1719 m_widgetStyle = (GtkStyle*) NULL;
1720
1721 m_insertCallback = (wxInsertChildFunction) NULL;
1722
1723 m_isStaticBox = FALSE;
1724 m_isRadioButton = FALSE;
1725 m_isFrame = FALSE;
1726 m_acceptsFocus = FALSE;
1727
1728 m_cursor = *wxSTANDARD_CURSOR;
1729 }
1730
1731 wxWindow::wxWindow()
1732 {
1733 Init();
1734 }
1735
1736 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
1737 const wxPoint &pos, const wxSize &size,
1738 long style, const wxString &name )
1739 {
1740 Init();
1741
1742 Create( parent, id, pos, size, style, name );
1743 }
1744
1745 bool wxWindow::Create( wxWindow *parent, wxWindowID id,
1746 const wxPoint &pos, const wxSize &size,
1747 long style, const wxString &name )
1748 {
1749 if (!PreCreation( parent, pos, size ) ||
1750 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
1751 {
1752 wxFAIL_MSG( wxT("wxWindow creation failed") );
1753 return FALSE;
1754 }
1755
1756 m_insertCallback = wxInsertChildInWindow;
1757
1758 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
1759 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
1760
1761 #ifdef __WXDEBUG__
1762 debug_focus_in( m_widget, wxT("wxWindow::m_widget"), name );
1763 #endif
1764
1765 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
1766
1767 #ifdef __WXDEBUG__
1768 debug_focus_in( scrolledWindow->hscrollbar, wxT("wxWindow::hsrcollbar"), name );
1769 debug_focus_in( scrolledWindow->vscrollbar, wxT("wxWindow::vsrcollbar"), name );
1770 #endif
1771
1772 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1773 scroll_class->scrollbar_spacing = 0;
1774
1775 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
1776
1777 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
1778 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
1779
1780 m_wxwindow = gtk_pizza_new();
1781
1782 #ifdef __WXDEBUG__
1783 debug_focus_in( m_wxwindow, wxT("wxWindow::m_wxwindow"), name );
1784 #endif
1785
1786 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
1787
1788 #if (GTK_MINOR_VERSION > 0)
1789 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
1790
1791 if (HasFlag(wxRAISED_BORDER))
1792 {
1793 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
1794 }
1795 else if (HasFlag(wxSUNKEN_BORDER))
1796 {
1797 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
1798 }
1799 else if (HasFlag(wxSIMPLE_BORDER))
1800 {
1801 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
1802 }
1803 else
1804 {
1805 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
1806 }
1807 #else // GTK_MINOR_VERSION == 0
1808 GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
1809
1810 if (HasFlag(wxRAISED_BORDER))
1811 {
1812 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
1813 }
1814 else if (HasFlag(wxSUNKEN_BORDER))
1815 {
1816 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
1817 }
1818 else
1819 {
1820 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
1821 }
1822 #endif // GTK_MINOR_VERSION
1823
1824 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
1825 m_acceptsFocus = TRUE;
1826
1827 #if (GTK_MINOR_VERSION == 0)
1828 // shut the viewport up
1829 gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1830 gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1831 #endif // GTK_MINOR_VERSION == 0
1832
1833 // I _really_ don't want scrollbars in the beginning
1834 m_vAdjust->lower = 0.0;
1835 m_vAdjust->upper = 1.0;
1836 m_vAdjust->value = 0.0;
1837 m_vAdjust->step_increment = 1.0;
1838 m_vAdjust->page_increment = 1.0;
1839 m_vAdjust->page_size = 5.0;
1840 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
1841 m_hAdjust->lower = 0.0;
1842 m_hAdjust->upper = 1.0;
1843 m_hAdjust->value = 0.0;
1844 m_hAdjust->step_increment = 1.0;
1845 m_hAdjust->page_increment = 1.0;
1846 m_hAdjust->page_size = 5.0;
1847 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
1848
1849 // these handlers block mouse events to any window during scrolling such as
1850 // motion events and prevent GTK and wxWindows from fighting over where the
1851 // slider should be
1852
1853 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
1854 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1855
1856 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
1857 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1858
1859 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
1860 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1861
1862 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
1863 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1864
1865 // these handlers get notified when screen updates are required either when
1866 // scrolling or when the window size (and therefore scrollbar configuration)
1867 // has changed
1868
1869 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
1870 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
1871 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
1872 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
1873
1874 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed",
1875 (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
1876 gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
1877 (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
1878
1879 gtk_widget_show( m_wxwindow );
1880
1881 if (m_parent)
1882 m_parent->DoAddChild( this );
1883
1884 PostCreation();
1885
1886 Show( TRUE );
1887
1888 return TRUE;
1889 }
1890
1891 wxWindow::~wxWindow()
1892 {
1893 m_isBeingDeleted = TRUE;
1894 m_hasVMT = FALSE;
1895
1896 if (m_widget)
1897 Show( FALSE );
1898
1899 DestroyChildren();
1900
1901 if (m_parent)
1902 m_parent->RemoveChild( this );
1903
1904 if (m_widgetStyle)
1905 {
1906 gtk_style_unref( m_widgetStyle );
1907 m_widgetStyle = (GtkStyle*) NULL;
1908 }
1909
1910 if (m_wxwindow)
1911 {
1912 gtk_widget_destroy( m_wxwindow );
1913 m_wxwindow = (GtkWidget*) NULL;
1914 }
1915
1916 if (m_widget)
1917 {
1918 gtk_widget_destroy( m_widget );
1919 m_widget = (GtkWidget*) NULL;
1920 }
1921 }
1922
1923 bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize &size )
1924 {
1925 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
1926
1927 /* this turns -1 into 20 so that a minimal window is
1928 visible even although -1,-1 has been given as the
1929 size of the window. the same trick is used in other
1930 ports and should make debugging easier */
1931 m_width = WidthDefault(size.x);
1932 m_height = HeightDefault(size.y);
1933
1934 m_x = (int)pos.x;
1935 m_y = (int)pos.y;
1936
1937 /* some reasonable defaults */
1938 if (!parent)
1939 {
1940 if (m_x == -1)
1941 {
1942 m_x = (gdk_screen_width () - m_width) / 2;
1943 if (m_x < 10) m_x = 10;
1944 }
1945 if (m_y == -1)
1946 {
1947 m_y = (gdk_screen_height () - m_height) / 2;
1948 if (m_y < 10) m_y = 10;
1949 }
1950 }
1951
1952 return TRUE;
1953 }
1954
1955 void wxWindow::PostCreation()
1956 {
1957 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
1958
1959 if (m_wxwindow)
1960 {
1961 if (!m_noExpose)
1962 {
1963 /* these get reported to wxWindows -> wxPaintEvent */
1964 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
1965 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
1966
1967 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
1968 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
1969 }
1970
1971 #if (GTK_MINOR_VERSION > 0)
1972 /* these are called when the "sunken" or "raised" borders are drawn */
1973 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
1974 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
1975
1976 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
1977 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
1978 #endif
1979 }
1980
1981 GtkWidget *connect_widget = GetConnectWidget();
1982
1983 ConnectWidget( connect_widget );
1984
1985 /* we cannot set colours, fonts and cursors before the widget has
1986 been realized, so we do this directly after realization */
1987 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
1988 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
1989
1990 m_hasVMT = TRUE;
1991 }
1992
1993 void wxWindow::ConnectWidget( GtkWidget *widget )
1994 {
1995 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
1996 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
1997
1998 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
1999 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2000
2001 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2002 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2003
2004 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2005 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2006
2007 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2008 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2009
2010 gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
2011 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2012
2013 gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
2014 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2015
2016 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2017 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2018
2019 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2020 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2021 }
2022
2023 bool wxWindow::Destroy()
2024 {
2025 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2026
2027 m_hasVMT = FALSE;
2028
2029 return wxWindowBase::Destroy();
2030 }
2031
2032 void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2033 {
2034 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2035 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindow::SetSize requires parent.\n") );
2036
2037 if (m_resizing) return; /* I don't like recursions */
2038 m_resizing = TRUE;
2039
2040 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
2041 {
2042 /* don't set the size for children of wxNotebook, just take the values. */
2043 m_x = x;
2044 m_y = y;
2045 m_width = width;
2046 m_height = height;
2047 }
2048 else
2049 {
2050 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2051
2052 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2053 {
2054 if (x != -1) m_x = x + pizza->xoffset;
2055 if (y != -1) m_y = y + pizza->yoffset;
2056 if (width != -1) m_width = width;
2057 if (height != -1) m_height = height;
2058 }
2059 else
2060 {
2061 m_x = x + pizza->xoffset;
2062 m_y = y + pizza->yoffset;
2063 m_width = width;
2064 m_height = height;
2065 }
2066
2067 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
2068 {
2069 if (width == -1) m_width = 80;
2070 }
2071
2072 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
2073 {
2074 if (height == -1) m_height = 26;
2075 }
2076
2077 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
2078 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
2079 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
2080 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
2081
2082 int border = 0;
2083 int bottom_border = 0;
2084
2085 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2086 {
2087 /* the default button has a border around it */
2088 border = 6;
2089 bottom_border = 5;
2090 }
2091
2092 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow),
2093 m_widget,
2094 m_x-border,
2095 m_y-border,
2096 m_width+2*border,
2097 m_height+border+bottom_border );
2098 }
2099
2100 /*
2101 wxPrintf( "OnSize sent from " );
2102 if (GetClassInfo() && GetClassInfo()->GetClassName())
2103 wxPrintf( GetClassInfo()->GetClassName() );
2104 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2105 */
2106
2107 if (!m_nativeSizeEvent)
2108 {
2109 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2110 event.SetEventObject( this );
2111 GetEventHandler()->ProcessEvent( event );
2112 }
2113
2114 m_resizing = FALSE;
2115 }
2116
2117 void wxWindow::OnInternalIdle()
2118 {
2119 if ( g_sendActivateEvent != -1 )
2120 {
2121 bool activate = g_sendActivateEvent != 0;
2122
2123 // do it only once
2124 g_sendActivateEvent = -1;
2125
2126 wxActivateEvent event(wxEVT_ACTIVATE, activate, GetId());
2127 event.SetEventObject(this);
2128
2129 (void)GetEventHandler()->ProcessEvent(event);
2130 }
2131
2132 wxCursor cursor = m_cursor;
2133 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2134
2135 if (cursor.Ok())
2136 {
2137 /* I now set the cursor anew in every OnInternalIdle call
2138 as setting the cursor in a parent window also effects the
2139 windows above so that checking for the current cursor is
2140 not possible. */
2141
2142 if (m_wxwindow)
2143 {
2144 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
2145 if (window)
2146 gdk_window_set_cursor( window, cursor.GetCursor() );
2147
2148 if (!g_globalCursor.Ok())
2149 cursor = *wxSTANDARD_CURSOR;
2150
2151 window = m_widget->window;
2152 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2153 gdk_window_set_cursor( window, cursor.GetCursor() );
2154
2155 }
2156 else
2157 {
2158
2159 GdkWindow *window = m_widget->window;
2160 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2161 gdk_window_set_cursor( window, cursor.GetCursor() );
2162
2163 }
2164 }
2165
2166 UpdateWindowUI();
2167 }
2168
2169 void wxWindow::DoGetSize( int *width, int *height ) const
2170 {
2171 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2172
2173 if (width) (*width) = m_width;
2174 if (height) (*height) = m_height;
2175 }
2176
2177 void wxWindow::DoSetClientSize( int width, int height )
2178 {
2179 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2180
2181 if (!m_wxwindow)
2182 {
2183 SetSize( width, height );
2184 }
2185 else
2186 {
2187 int dw = 0;
2188 int dh = 0;
2189
2190 #if (GTK_MINOR_VERSION == 0)
2191 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2192 {
2193 if (HasScrolling())
2194 {
2195 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2196 #if 0 // unused - if this is ok, just remove this line (VZ)
2197 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
2198 #endif // 0
2199
2200 GtkWidget *viewport = scroll_window->viewport;
2201 GtkStyleClass *viewport_class = viewport->style->klass;
2202
2203 dw += 2 * viewport_class->xthickness;
2204 dh += 2 * viewport_class->ythickness;
2205 }
2206 }
2207 #else
2208 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2209 {
2210 /* when using GTK 1.2 we set the shadow border size to 2 */
2211 dw += 2 * 2;
2212 dh += 2 * 2;
2213 }
2214 if (HasFlag(wxSIMPLE_BORDER))
2215 {
2216 /* when using GTK 1.2 we set the simple border size to 1 */
2217 dw += 1 * 2;
2218 dh += 1 * 2;
2219 }
2220 #endif
2221
2222 if (HasScrolling())
2223 {
2224 /*
2225 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2226 GtkWidget *vscrollbar = scroll_window->vscrollbar;
2227
2228 we use this instead: range.slider_width = 11 + 2*2pts edge
2229 */
2230
2231 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2232 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
2233
2234 if (scroll_window->vscrollbar_visible)
2235 {
2236 dw += 15; /* dw += vscrollbar->allocation.width; */
2237 dw += scroll_class->scrollbar_spacing;
2238 }
2239
2240 if (scroll_window->hscrollbar_visible)
2241 {
2242 dh += 15; /* dh += hscrollbar->allocation.height; */
2243 dh += scroll_class->scrollbar_spacing;
2244 }
2245 }
2246
2247 SetSize( width+dw, height+dh );
2248 }
2249 }
2250
2251 void wxWindow::DoGetClientSize( int *width, int *height ) const
2252 {
2253 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2254
2255 if (!m_wxwindow)
2256 {
2257 if (width) (*width) = m_width;
2258 if (height) (*height) = m_height;
2259 }
2260 else
2261 {
2262 int dw = 0;
2263 int dh = 0;
2264
2265 #if (GTK_MINOR_VERSION == 0)
2266 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2267 {
2268 if (HasScrolling())
2269 {
2270 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2271 #if 0 // unused - if this is ok, just remove this line (VZ)
2272 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
2273 #endif // 0
2274
2275 GtkWidget *viewport = scroll_window->viewport;
2276 GtkStyleClass *viewport_class = viewport->style->klass;
2277
2278 dw += 2 * viewport_class->xthickness;
2279 dh += 2 * viewport_class->ythickness;
2280 }
2281 }
2282 #else
2283 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2284 {
2285 /* when using GTK 1.2 we set the shadow border size to 2 */
2286 dw += 2 * 2;
2287 dh += 2 * 2;
2288 }
2289 if (HasFlag(wxSIMPLE_BORDER))
2290 {
2291 /* when using GTK 1.2 we set the simple border size to 1 */
2292 dw += 1 * 2;
2293 dh += 1 * 2;
2294 }
2295 #endif
2296 if (HasScrolling())
2297 {
2298 /*
2299 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2300 GtkWidget *vscrollbar = scroll_window->vscrollbar;
2301
2302 we use this instead: range.slider_width = 11 + 2*2pts edge
2303 */
2304
2305 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2306 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
2307
2308 if (scroll_window->vscrollbar_visible)
2309 {
2310 dw += 15; /* dw += vscrollbar->allocation.width; */
2311 dw += scroll_class->scrollbar_spacing;
2312 }
2313
2314 if (scroll_window->hscrollbar_visible)
2315 {
2316 dh += 15; /* dh += hscrollbar->allocation.height; */
2317 dh += scroll_class->scrollbar_spacing;
2318 }
2319 }
2320
2321 if (width) (*width) = m_width - dw;
2322 if (height) (*height) = m_height - dh;
2323 }
2324 }
2325
2326 void wxWindow::DoGetPosition( int *x, int *y ) const
2327 {
2328 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2329
2330 int dx = 0;
2331 int dy = 0;
2332 if (m_parent && m_parent->m_wxwindow)
2333 {
2334 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2335 dx = pizza->xoffset;
2336 dy = pizza->yoffset;
2337 }
2338
2339 if (x) (*x) = m_x - dx;
2340 if (y) (*y) = m_y - dy;
2341 }
2342
2343 void wxWindow::DoClientToScreen( int *x, int *y ) const
2344 {
2345 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2346
2347 if (!m_widget->window) return;
2348
2349 GdkWindow *source = (GdkWindow *) NULL;
2350 if (m_wxwindow)
2351 source = GTK_PIZZA(m_wxwindow)->bin_window;
2352 else
2353 source = m_widget->window;
2354
2355 int org_x = 0;
2356 int org_y = 0;
2357 gdk_window_get_origin( source, &org_x, &org_y );
2358
2359 if (!m_wxwindow)
2360 {
2361 if (GTK_WIDGET_NO_WINDOW (m_widget))
2362 {
2363 org_x += m_widget->allocation.x;
2364 org_y += m_widget->allocation.y;
2365 }
2366 }
2367
2368 if (x) *x += org_x;
2369 if (y) *y += org_y;
2370 }
2371
2372 void wxWindow::DoScreenToClient( int *x, int *y ) const
2373 {
2374 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2375
2376 if (!m_widget->window) return;
2377
2378 GdkWindow *source = (GdkWindow *) NULL;
2379 if (m_wxwindow)
2380 source = GTK_PIZZA(m_wxwindow)->bin_window;
2381 else
2382 source = m_widget->window;
2383
2384 int org_x = 0;
2385 int org_y = 0;
2386 gdk_window_get_origin( source, &org_x, &org_y );
2387
2388 if (!m_wxwindow)
2389 {
2390 if (GTK_WIDGET_NO_WINDOW (m_widget))
2391 {
2392 org_x += m_widget->allocation.x;
2393 org_y += m_widget->allocation.y;
2394 }
2395 }
2396
2397 if (x) *x -= org_x;
2398 if (y) *y -= org_y;
2399 }
2400
2401 bool wxWindow::Show( bool show )
2402 {
2403 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
2404
2405 if (!wxWindowBase::Show(show))
2406 {
2407 // nothing to do
2408 return FALSE;
2409 }
2410
2411 if (show)
2412 gtk_widget_show( m_widget );
2413 else
2414 gtk_widget_hide( m_widget );
2415
2416 return TRUE;
2417 }
2418
2419 bool wxWindow::Enable( bool enable )
2420 {
2421 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
2422
2423 if (!wxWindowBase::Enable(enable))
2424 {
2425 // nothing to do
2426 return FALSE;
2427 }
2428
2429 gtk_widget_set_sensitive( m_widget, enable );
2430 if ( m_wxwindow )
2431 gtk_widget_set_sensitive( m_wxwindow, enable );
2432
2433 return TRUE;
2434 }
2435
2436 int wxWindow::GetCharHeight() const
2437 {
2438 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
2439
2440 wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
2441
2442 GdkFont *font = m_font.GetInternalFont( 1.0 );
2443
2444 return font->ascent + font->descent;
2445 }
2446
2447 int wxWindow::GetCharWidth() const
2448 {
2449 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
2450
2451 wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
2452
2453 GdkFont *font = m_font.GetInternalFont( 1.0 );
2454
2455 return gdk_string_width( font, "H" );
2456 }
2457
2458 void wxWindow::GetTextExtent( const wxString& string,
2459 int *x,
2460 int *y,
2461 int *descent,
2462 int *externalLeading,
2463 const wxFont *theFont ) const
2464 {
2465 wxFont fontToUse = m_font;
2466 if (theFont) fontToUse = *theFont;
2467
2468 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
2469
2470 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
2471 if (x) (*x) = gdk_string_width( font, string.mbc_str() );
2472 if (y) (*y) = font->ascent + font->descent;
2473 if (descent) (*descent) = font->descent;
2474 if (externalLeading) (*externalLeading) = 0; // ??
2475 }
2476
2477 void wxWindow::SetFocus()
2478 {
2479 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2480
2481 if (m_wxwindow)
2482 {
2483 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
2484 gtk_widget_grab_focus (m_wxwindow);
2485 return;
2486 }
2487
2488 if (m_widget)
2489 {
2490 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
2491 {
2492 gtk_widget_grab_focus (m_widget);
2493 }
2494 else if (GTK_IS_CONTAINER(m_widget))
2495 {
2496 gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD );
2497 }
2498 else
2499 {
2500 // ?
2501 }
2502 }
2503 }
2504
2505 bool wxWindow::AcceptsFocus() const
2506 {
2507 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
2508 }
2509
2510 bool wxWindow::Reparent( wxWindowBase *newParentBase )
2511 {
2512 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
2513
2514 wxWindow *oldParent = m_parent,
2515 *newParent = (wxWindow *)newParentBase;
2516
2517 wxASSERT( GTK_IS_WIDGET(m_widget) );
2518
2519 if ( !wxWindowBase::Reparent(newParent) )
2520 return FALSE;
2521
2522 wxASSERT( GTK_IS_WIDGET(m_widget) );
2523
2524 /* prevent GTK from deleting the widget arbitrarily */
2525 gtk_widget_ref( m_widget );
2526
2527 if (oldParent)
2528 {
2529 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
2530 }
2531
2532 wxASSERT( GTK_IS_WIDGET(m_widget) );
2533
2534 if (newParent)
2535 {
2536 /* insert GTK representation */
2537 (*(newParent->m_insertCallback))(newParent, this);
2538 }
2539
2540 /* reverse: prevent GTK from deleting the widget arbitrarily */
2541 gtk_widget_unref( m_widget );
2542
2543 return TRUE;
2544 }
2545
2546 void wxWindow::DoAddChild(wxWindow *child)
2547 {
2548 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2549
2550 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
2551
2552 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
2553
2554 /* add to list */
2555 AddChild( child );
2556
2557 /* insert GTK representation */
2558 (*m_insertCallback)(this, child);
2559 }
2560
2561 void wxWindow::Raise()
2562 {
2563 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2564
2565 if (!m_widget->window) return;
2566
2567 gdk_window_raise( m_widget->window );
2568 }
2569
2570 void wxWindow::Lower()
2571 {
2572 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2573
2574 if (!m_widget->window) return;
2575
2576 gdk_window_lower( m_widget->window );
2577 }
2578
2579 bool wxWindow::SetCursor( const wxCursor &cursor )
2580 {
2581 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
2582
2583 return wxWindowBase::SetCursor( cursor );
2584 }
2585
2586 void wxWindow::WarpPointer( int x, int y )
2587 {
2588 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2589
2590 /* we provide this function ourselves as it is
2591 missing in GDK (top of this file) */
2592
2593 GdkWindow *window = (GdkWindow*) NULL;
2594 if (m_wxwindow)
2595 window = GTK_PIZZA(m_wxwindow)->bin_window;
2596 else
2597 window = GetConnectWidget()->window;
2598
2599 if (window)
2600 gdk_window_warp_pointer( window, x, y );
2601 }
2602
2603 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
2604 {
2605 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2606
2607 if (!m_widget->window) return;
2608
2609 if (eraseBackground && m_wxwindow && m_wxwindow->window)
2610 {
2611 if (rect)
2612 {
2613 gdk_window_clear_area( GTK_PIZZA(m_wxwindow)->bin_window,
2614 rect->x, rect->y,
2615 rect->width, rect->height );
2616 }
2617 else
2618 {
2619 gdk_window_clear( GTK_PIZZA(m_wxwindow)->bin_window );
2620 }
2621 }
2622
2623 /* there is no GTK equivalent of "draw only, don't clear" so we
2624 invent our own in the GtkPizza widget */
2625
2626 if (!rect)
2627 {
2628 if (m_wxwindow)
2629 {
2630 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2631 gboolean old_clear = pizza->clear_on_draw;
2632 gtk_pizza_set_clear( pizza, FALSE );
2633
2634 gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
2635
2636 gtk_pizza_set_clear( pizza, old_clear );
2637 }
2638 else
2639 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
2640 }
2641 else
2642 {
2643 GdkRectangle gdk_rect;
2644 gdk_rect.x = rect->x;
2645 gdk_rect.y = rect->y;
2646 gdk_rect.width = rect->width;
2647 gdk_rect.height = rect->height;
2648
2649 if (m_wxwindow)
2650 {
2651 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2652 gboolean old_clear = pizza->clear_on_draw;
2653 gtk_pizza_set_clear( pizza, FALSE );
2654
2655 gtk_widget_draw( m_wxwindow, &gdk_rect );
2656
2657 gtk_pizza_set_clear( pizza, old_clear );
2658 }
2659 else
2660 gtk_widget_draw( m_widget, &gdk_rect );
2661 }
2662 }
2663
2664 void wxWindow::Clear()
2665 {
2666 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
2667
2668 if (!m_widget->window) return;
2669
2670 if (m_wxwindow && m_wxwindow->window)
2671 {
2672 gdk_window_clear( m_wxwindow->window );
2673 }
2674 }
2675
2676 #if wxUSE_TOOLTIPS
2677 void wxWindow::DoSetToolTip( wxToolTip *tip )
2678 {
2679 wxWindowBase::DoSetToolTip(tip);
2680
2681 if (m_tooltip)
2682 m_tooltip->Apply( this );
2683 }
2684
2685 void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
2686 {
2687 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
2688 }
2689 #endif // wxUSE_TOOLTIPS
2690
2691 bool wxWindow::SetBackgroundColour( const wxColour &colour )
2692 {
2693 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
2694
2695 if (!wxWindowBase::SetBackgroundColour(colour))
2696 {
2697 // don't leave if the GTK widget has just
2698 // been realized
2699 if (!m_delayedBackgroundColour) return FALSE;
2700 }
2701
2702 GdkWindow *window = (GdkWindow*) NULL;
2703 if (m_wxwindow)
2704 window = GTK_PIZZA(m_wxwindow)->bin_window;
2705 else
2706 window = GetConnectWidget()->window;
2707
2708 if (!window)
2709 {
2710 // indicate that a new style has been set
2711 // but it couldn't get applied as the
2712 // widget hasn't been realized yet.
2713 m_delayedBackgroundColour = TRUE;
2714
2715 // pretend we have done something
2716 return TRUE;
2717 }
2718
2719 if (m_wxwindow)
2720 {
2721 /* wxMSW doesn't clear the window here. I don't do that either to
2722 provide compatibility. call Clear() to do the job. */
2723
2724 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
2725 gdk_window_set_background( window, m_backgroundColour.GetColor() );
2726 }
2727
2728 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2729 if (sysbg == m_backgroundColour)
2730 {
2731 m_backgroundColour = wxNullColour;
2732 ApplyWidgetStyle();
2733 m_backgroundColour = sysbg;
2734 }
2735 else
2736 {
2737 ApplyWidgetStyle();
2738 }
2739
2740 return TRUE;
2741 }
2742
2743 bool wxWindow::SetForegroundColour( const wxColour &colour )
2744 {
2745 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
2746
2747 if (!wxWindowBase::SetForegroundColour(colour))
2748 {
2749 // don't leave if the GTK widget has just
2750 // been realized
2751 if (!m_delayedForegroundColour) return FALSE;
2752 }
2753
2754 GdkWindow *window = (GdkWindow*) NULL;
2755 if (m_wxwindow)
2756 window = GTK_PIZZA(m_wxwindow)->bin_window;
2757 else
2758 window = GetConnectWidget()->window;
2759
2760 if (!window)
2761 {
2762 // indicate that a new style has been set
2763 // but it couldn't get applied as the
2764 // widget hasn't been realized yet.
2765 m_delayedForegroundColour = TRUE;
2766
2767 // pretend we have done something
2768 return TRUE;
2769 }
2770
2771 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2772 if ( sysbg == m_backgroundColour )
2773 {
2774 m_backgroundColour = wxNullColour;
2775 ApplyWidgetStyle();
2776 m_backgroundColour = sysbg;
2777 }
2778 else
2779 {
2780 ApplyWidgetStyle();
2781 }
2782
2783 return TRUE;
2784 }
2785
2786 GtkStyle *wxWindow::GetWidgetStyle()
2787 {
2788 if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
2789
2790 m_widgetStyle = gtk_style_copy( gtk_widget_get_style( m_widget ) );
2791
2792 return m_widgetStyle;
2793 }
2794
2795 void wxWindow::SetWidgetStyle()
2796 {
2797 GtkStyle *style = GetWidgetStyle();
2798
2799 gdk_font_unref( style->font );
2800 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
2801
2802 if (m_foregroundColour.Ok())
2803 {
2804 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
2805 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
2806 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
2807 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
2808 }
2809
2810 if (m_backgroundColour.Ok())
2811 {
2812 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
2813 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2814 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2815 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2816 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2817 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2818 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2819 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2820 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2821 }
2822 }
2823
2824 void wxWindow::ApplyWidgetStyle()
2825 {
2826 }
2827
2828 //-----------------------------------------------------------------------------
2829 // Pop-up menu stuff
2830 //-----------------------------------------------------------------------------
2831
2832 static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
2833 {
2834 *is_waiting = FALSE;
2835 }
2836
2837 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
2838 {
2839 menu->SetInvokingWindow( win );
2840 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
2841 while (node)
2842 {
2843 wxMenuItem *menuitem = node->GetData();
2844 if (menuitem->IsSubMenu())
2845 {
2846 SetInvokingWindow( menuitem->GetSubMenu(), win );
2847 }
2848
2849 node = node->GetNext();
2850 }
2851 }
2852
2853 static gint gs_pop_x = 0;
2854 static gint gs_pop_y = 0;
2855
2856 static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
2857 gint *x, gint *y,
2858 wxWindow *win )
2859 {
2860 win->ClientToScreen( &gs_pop_x, &gs_pop_y );
2861 *x = gs_pop_x;
2862 *y = gs_pop_y;
2863 }
2864
2865 bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
2866 {
2867 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
2868
2869 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
2870
2871 SetInvokingWindow( menu, this );
2872
2873 menu->UpdateUI();
2874
2875 gs_pop_x = x;
2876 gs_pop_y = y;
2877
2878 bool is_waiting = TRUE;
2879
2880 gtk_signal_connect( GTK_OBJECT(menu->m_menu), "hide",
2881 GTK_SIGNAL_FUNC(gtk_pop_hide_callback), (gpointer)&is_waiting );
2882
2883 gtk_menu_popup(
2884 GTK_MENU(menu->m_menu),
2885 (GtkWidget *) NULL, // parent menu shell
2886 (GtkWidget *) NULL, // parent menu item
2887 (GtkMenuPositionFunc) pop_pos_callback,
2888 (gpointer) this, // client data
2889 0, // button used to activate it
2890 gs_timeLastClick // the time of activation
2891 );
2892
2893 while (is_waiting)
2894 {
2895 while (gtk_events_pending())
2896 gtk_main_iteration();
2897 }
2898
2899 return TRUE;
2900 }
2901
2902 #if wxUSE_DRAG_AND_DROP
2903
2904 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
2905 {
2906 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
2907
2908 GtkWidget *dnd_widget = GetConnectWidget();
2909
2910 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
2911
2912 if (m_dropTarget) delete m_dropTarget;
2913 m_dropTarget = dropTarget;
2914
2915 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
2916 }
2917
2918 #endif // wxUSE_DRAG_AND_DROP
2919
2920 GtkWidget* wxWindow::GetConnectWidget()
2921 {
2922 GtkWidget *connect_widget = m_widget;
2923 if (m_wxwindow) connect_widget = m_wxwindow;
2924
2925 return connect_widget;
2926 }
2927
2928 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
2929 {
2930 if (m_wxwindow)
2931 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
2932
2933 return (window == m_widget->window);
2934 }
2935
2936 bool wxWindow::SetFont( const wxFont &font )
2937 {
2938 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
2939
2940 if (!wxWindowBase::SetFont(font))
2941 {
2942 return FALSE;
2943 }
2944
2945 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2946 if ( sysbg == m_backgroundColour )
2947 {
2948 m_backgroundColour = wxNullColour;
2949 ApplyWidgetStyle();
2950 m_backgroundColour = sysbg;
2951 }
2952 else
2953 {
2954 ApplyWidgetStyle();
2955 }
2956
2957 return TRUE;
2958 }
2959
2960 void wxWindow::CaptureMouse()
2961 {
2962 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
2963
2964 wxCHECK_RET( g_captureWindow == NULL, wxT("CaptureMouse called twice") );
2965
2966 GdkWindow *window = (GdkWindow*) NULL;
2967 if (m_wxwindow)
2968 window = GTK_PIZZA(m_wxwindow)->bin_window;
2969 else
2970 window = GetConnectWidget()->window;
2971
2972 if (!window) return;
2973
2974 gdk_pointer_grab( window, FALSE,
2975 (GdkEventMask)
2976 (GDK_BUTTON_PRESS_MASK |
2977 GDK_BUTTON_RELEASE_MASK |
2978 GDK_POINTER_MOTION_HINT_MASK |
2979 GDK_POINTER_MOTION_MASK),
2980 (GdkWindow *) NULL,
2981 m_cursor.GetCursor(),
2982 (guint32)GDK_CURRENT_TIME );
2983 g_captureWindow = this;
2984 }
2985
2986 void wxWindow::ReleaseMouse()
2987 {
2988 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
2989
2990 wxCHECK_RET( g_captureWindow, wxT("ReleaseMouse called twice") );
2991
2992 GdkWindow *window = (GdkWindow*) NULL;
2993 if (m_wxwindow)
2994 window = GTK_PIZZA(m_wxwindow)->bin_window;
2995 else
2996 window = GetConnectWidget()->window;
2997
2998 if (!window)
2999 return;
3000
3001 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
3002 g_captureWindow = (wxWindow*) NULL;
3003 }
3004
3005 bool wxWindow::IsRetained() const
3006 {
3007 return FALSE;
3008 }
3009
3010 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
3011 int range, bool refresh )
3012 {
3013 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3014
3015 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3016
3017 m_hasScrolling = TRUE;
3018
3019 if (orient == wxHORIZONTAL)
3020 {
3021 float fpos = (float)pos;
3022 float frange = (float)range;
3023 float fthumb = (float)thumbVisible;
3024 if (fpos > frange-fthumb) fpos = frange-fthumb;
3025 if (fpos < 0.0) fpos = 0.0;
3026
3027 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
3028 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
3029 {
3030 SetScrollPos( orient, pos, refresh );
3031 return;
3032 }
3033
3034 m_oldHorizontalPos = fpos;
3035
3036 m_hAdjust->lower = 0.0;
3037 m_hAdjust->upper = frange;
3038 m_hAdjust->value = fpos;
3039 m_hAdjust->step_increment = 1.0;
3040 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
3041 m_hAdjust->page_size = fthumb;
3042 }
3043 else
3044 {
3045 float fpos = (float)pos;
3046 float frange = (float)range;
3047 float fthumb = (float)thumbVisible;
3048 if (fpos > frange-fthumb) fpos = frange-fthumb;
3049 if (fpos < 0.0) fpos = 0.0;
3050
3051 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
3052 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
3053 {
3054 SetScrollPos( orient, pos, refresh );
3055 return;
3056 }
3057
3058 m_oldVerticalPos = fpos;
3059
3060 m_vAdjust->lower = 0.0;
3061 m_vAdjust->upper = frange;
3062 m_vAdjust->value = fpos;
3063 m_vAdjust->step_increment = 1.0;
3064 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
3065 m_vAdjust->page_size = fthumb;
3066 }
3067
3068 if (orient == wxHORIZONTAL)
3069 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
3070 else
3071 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
3072 }
3073
3074 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
3075 {
3076 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3077
3078 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3079
3080 if (orient == wxHORIZONTAL)
3081 {
3082 float fpos = (float)pos;
3083 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
3084 if (fpos < 0.0) fpos = 0.0;
3085 m_oldHorizontalPos = fpos;
3086
3087 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
3088 m_hAdjust->value = fpos;
3089 }
3090 else
3091 {
3092 float fpos = (float)pos;
3093 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
3094 if (fpos < 0.0) fpos = 0.0;
3095 m_oldVerticalPos = fpos;
3096
3097 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
3098 m_vAdjust->value = fpos;
3099 }
3100
3101 /*
3102 if (!m_isScrolling)
3103 {
3104 */
3105 if (m_wxwindow->window)
3106 {
3107 if (orient == wxHORIZONTAL)
3108 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
3109 else
3110 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
3111 }
3112 /*
3113 }
3114 */
3115 }
3116
3117 int wxWindow::GetScrollThumb( int orient ) const
3118 {
3119 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
3120
3121 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
3122
3123 if (orient == wxHORIZONTAL)
3124 return (int)(m_hAdjust->page_size+0.5);
3125 else
3126 return (int)(m_vAdjust->page_size+0.5);
3127 }
3128
3129 int wxWindow::GetScrollPos( int orient ) const
3130 {
3131 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
3132
3133 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
3134
3135 if (orient == wxHORIZONTAL)
3136 return (int)(m_hAdjust->value+0.5);
3137 else
3138 return (int)(m_vAdjust->value+0.5);
3139 }
3140
3141 int wxWindow::GetScrollRange( int orient ) const
3142 {
3143 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
3144
3145 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
3146
3147 if (orient == wxHORIZONTAL)
3148 return (int)(m_hAdjust->upper+0.5);
3149 else
3150 return (int)(m_vAdjust->upper+0.5);
3151 }
3152
3153 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
3154 {
3155 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3156
3157 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
3158
3159 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
3160
3161 /*
3162 if (!m_scrollGC)
3163 {
3164 m_scrollGC = gdk_gc_new( m_wxwindow->window );
3165 gdk_gc_set_exposures( m_scrollGC, TRUE );
3166 }
3167
3168 wxNode *node = m_children.First();
3169 while (node)
3170 {
3171 wxWindow *child = (wxWindow*) node->Data();
3172 int sx = 0;
3173 int sy = 0;
3174 child->GetSize( &sx, &sy );
3175 child->SetSize( child->m_x + dx, child->m_y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
3176 node = node->Next();
3177 }
3178
3179 int cw = 0;
3180 int ch = 0;
3181 GetClientSize( &cw, &ch );
3182 int w = cw - abs(dx);
3183 int h = ch - abs(dy);
3184
3185 if ((h < 0) || (w < 0))
3186 {
3187 Refresh();
3188 }
3189 else
3190 {
3191 int s_x = 0;
3192 int s_y = 0;
3193 if (dx < 0) s_x = -dx;
3194 if (dy < 0) s_y = -dy;
3195 int d_x = 0;
3196 int d_y = 0;
3197 if (dx > 0) d_x = dx;
3198 if (dy > 0) d_y = dy;
3199
3200 gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
3201 m_wxwindow->window, s_x, s_y, w, h );
3202
3203 wxRect rect;
3204 if (dx < 0) rect.x = cw+dx; else rect.x = 0;
3205 if (dy < 0) rect.y = ch+dy; else rect.y = 0;
3206 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
3207 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
3208
3209 Refresh( TRUE, &rect );
3210 }
3211 */
3212 }
3213
3214 void wxWindow::SetScrolling(bool scroll)
3215 {
3216 m_isScrolling = g_blockEventsOnScroll = scroll;
3217 }
wxWidgets (Impactor)