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