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