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