1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
12 #pragma implementation "window.h"
16 #include "wx/window.h"
20 #include "wx/layout.h"
22 #include "wx/dialog.h"
23 #include "wx/msgdlg.h"
25 #if wxUSE_DRAG_AND_DROP
30 #include "wx/tooltip.h"
34 #include "wx/statusbr.h"
36 #include "wx/settings.h"
43 #include "gdk/gdkprivate.h"
44 #include "gdk/gdkkeysyms.h"
45 #include "wx/gtk/win_gtk.h"
49 //-----------------------------------------------------------------------------
50 // documentation on internals
51 //-----------------------------------------------------------------------------
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.
60 What does wxWindow do? It contains the common interface for the following
61 jobs of its descendants:
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.
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.
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
78 4) Provide the entire mechanism for scrolling widgets. This actual inter-
79 face for this is usually in wxScrolledWindow, but the GTK implementation
82 5) A multitude of helper or extra methods for special purposes, such as
83 Drag'n'Drop, managing validators etc.
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
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)
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
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.
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.
126 //-----------------------------------------------------------------------------
128 //-----------------------------------------------------------------------------
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 static wxWindow
*g_focusWindow
= (wxWindow
*) NULL
;
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;
141 //-----------------------------------------------------------------------------
143 //-----------------------------------------------------------------------------
147 static gint
gtk_debug_focus_in_callback( GtkWidget
*WXUNUSED(widget
),
148 GdkEvent
*WXUNUSED(event
),
152 static bool s_done = FALSE;
155 wxLog::AddTraceMask("focus");
158 wxLogTrace(_T("FOCUS NOW AT: %s"), name);
164 void debug_focus_in( GtkWidget
* widget
, const wxChar
* name
, const wxChar
*window
)
170 wxChar
*s
= new wxChar
[tmp
.Length()+1];
174 gtk_signal_connect( GTK_OBJECT(widget
), "focus_in_event",
175 GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback
), (gpointer
)s
);
180 //-----------------------------------------------------------------------------
181 // missing gdk functions
182 //-----------------------------------------------------------------------------
185 gdk_window_warp_pointer (GdkWindow
*window
,
189 GdkWindowPrivate
*priv
;
192 window
= (GdkWindow
*) &gdk_root_parent
;
194 priv
= (GdkWindowPrivate
*) window
;
196 if (!priv
->destroyed
)
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 */
206 //-----------------------------------------------------------------------------
208 //-----------------------------------------------------------------------------
210 extern void wxapp_install_idle_handler();
211 extern bool g_isIdle
;
213 //-----------------------------------------------------------------------------
214 // key event conversion routines
215 //-----------------------------------------------------------------------------
217 #if (GTK_MINOR_VERSION == 0)
218 /* these functions are copied verbatim from GTK 1.2 */
220 gdkx_XConvertCase (KeySym symbol
,
224 register KeySym sym
= symbol
;
226 g_return_if_fail (lower
!= NULL
);
227 g_return_if_fail (upper
!= NULL
);
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
);
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
);
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
);
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
)
304 else if (sym
== 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
);
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
);
325 #endif /* CYRILLIC */
327 #if defined (GDK_Greek_ALPHAaccent) && defined (GDK_Greek_finalsmallsigma)
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
);
347 gdk_keyval_to_upper (guint keyval
)
351 KeySym lower_val
= 0;
352 KeySym upper_val
= 0;
354 gdkx_XConvertCase (keyval
, &lower_val
, &upper_val
);
361 static long map_to_unmodified_wx_keysym( KeySym keysym
)
368 case GDK_Shift_R
: key_code
= WXK_SHIFT
; break;
370 case GDK_Control_R
: key_code
= WXK_CONTROL
; break;
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;
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;
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;
460 guint upper
= gdk_keyval_to_upper( keysym
);
461 keysym
= (upper
!= 0 ? upper
: keysym
); /* to be MSW compatible */
470 static long map_to_wx_keysym( KeySym keysym
)
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;
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;
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;
567 //-----------------------------------------------------------------------------
568 // local code (see below)
569 //-----------------------------------------------------------------------------
571 #if (GTK_MINOR_VERSION > 0)
573 static void draw_frame( GtkWidget
*widget
, wxWindow
*win
)
581 if (win
->HasScrolling())
583 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(widget
);
584 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget
)->klass
);
587 GtkWidget *hscrollbar = scroll_window->hscrollbar;
588 GtkWidget *vscrollbar = scroll_window->vscrollbar;
590 we use this instead: range.slider_width = 11 + 2*2pts edge
593 if (scroll_window
->vscrollbar_visible
)
595 dw
+= 15; /* dw += vscrollbar->allocation.width; */
596 dw
+= scroll_class
->scrollbar_spacing
;
599 if (scroll_window
->hscrollbar_visible
)
601 dh
+= 15; /* dh += hscrollbar->allocation.height; */
602 dh
+= scroll_class
->scrollbar_spacing
;
608 if (GTK_WIDGET_NO_WINDOW (widget
))
610 dx
+= widget
->allocation
.x
;
611 dy
+= widget
->allocation
.y
;
614 if (win
->HasFlag(wxRAISED_BORDER
))
616 gtk_draw_shadow( widget
->style
,
621 win
->m_width
-dw
, win
->m_height
-dh
);
625 if (win
->HasFlag(wxSUNKEN_BORDER
))
627 gtk_draw_shadow( widget
->style
,
632 win
->m_width
-dw
, win
->m_height
-dh
);
637 //-----------------------------------------------------------------------------
638 // "expose_event" of m_widget
639 //-----------------------------------------------------------------------------
641 static void gtk_window_own_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindow
*win
)
643 if (gdk_event
->count
> 0) return;
644 draw_frame( widget
, win
);
647 //-----------------------------------------------------------------------------
648 // "draw" of m_wxwindow
649 //-----------------------------------------------------------------------------
651 static void gtk_window_own_draw_callback( GtkWidget
*widget
, GdkRectangle
*WXUNUSED(rect
), wxWindow
*win
)
653 draw_frame( widget
, win
);
656 #endif // GTK_MINOR_VERSION > 0
658 //-----------------------------------------------------------------------------
659 // "expose_event" of m_wxwindow
660 //-----------------------------------------------------------------------------
662 static void gtk_window_expose_callback( GtkWidget
*WXUNUSED(widget
), GdkEventExpose
*gdk_event
, wxWindow
*win
)
667 if (gdk_event
->window
!= win
->m_wxwindow
->window
)
670 win
->GetUpdateRegion().Union( gdk_event
->area
.x
,
672 gdk_event
->area
.width
,
673 gdk_event
->area
.height
);
675 if (gdk_event
->count
> 0)
678 wxPaintEvent
event( win
->GetId() );
679 event
.SetEventObject( win
);
680 win
->GetEventHandler()->ProcessEvent( event
);
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 );
692 win
->GetUpdateRegion().Clear();
695 //-----------------------------------------------------------------------------
696 // "draw" of m_wxwindow
697 //-----------------------------------------------------------------------------
699 static void gtk_window_draw_callback( GtkWidget
*WXUNUSED(widget
), GdkRectangle
*rect
, wxWindow
*win
)
702 wxapp_install_idle_handler();
707 win
->GetUpdateRegion().Union( rect
->x
, rect
->y
,
708 rect
->width
, rect
->height
);
710 wxPaintEvent
event( win
->GetId() );
711 event
.SetEventObject( win
);
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,
723 win
->GetEventHandler()->ProcessEvent( event
);
725 win
->GetUpdateRegion().Clear();
728 //-----------------------------------------------------------------------------
729 // "key_press_event" from any window
730 //-----------------------------------------------------------------------------
732 static gint
gtk_window_key_press_callback( GtkWidget
*widget
, GdkEventKey
*gdk_event
, wxWindow
*win
)
735 wxapp_install_idle_handler();
737 if (!win
->m_hasVMT
) return FALSE
;
738 if (g_blockEventsOnDrag
) return FALSE
;
741 printf( "KeyDown-ScanCode is: %d.\n", gdk_event->keyval );
742 if (gdk_event->state & GDK_SHIFT_MASK)
743 printf( "ShiftDown.\n" );
745 printf( "ShiftUp.\n" );
746 if (gdk_event->state & GDK_CONTROL_MASK)
747 printf( "ControlDown.\n" );
749 printf( "ControlUp.\n" );
754 GdkModifierType state
;
755 if (gdk_event
->window
) gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
757 long key_code
= map_to_unmodified_wx_keysym( gdk_event
->keyval
);
759 /* sending unknown key events doesn't really make sense */
760 if (key_code
== 0) return FALSE
;
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
;
774 event
.SetEventObject( win
);
775 ret
= win
->GetEventHandler()->ProcessEvent( event
);
777 key_code
= map_to_wx_keysym( gdk_event
->keyval
);
782 wxWindow
*ancestor
= win
;
785 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
788 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
789 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
792 ancestor
= ancestor
->GetParent();
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
)
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
;
811 event2
.SetEventObject( win
);
812 ret
= (ret
|| win
->GetEventHandler()->ProcessEvent( event2
));
816 /* win is a control: tab can be propagated up */
818 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
819 (win
->HasFlag(wxTE_PROCESS_TAB
) == 0))
821 wxNavigationKeyEvent new_event
;
822 /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
823 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
824 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
825 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
826 new_event
.SetCurrentFocus( win
);
827 ret
= win
->GetEventHandler()->ProcessEvent( new_event
);
830 /* generate wxID_CANCEL if <esc> has been pressed (typically in dialogs) */
832 (gdk_event
->keyval
== GDK_Escape
) )
834 wxCommandEvent
new_event(wxEVT_COMMAND_BUTTON_CLICKED
,wxID_CANCEL
);
835 new_event
.SetEventObject( win
);
836 ret
= win
->GetEventHandler()->ProcessEvent( new_event
);
839 #if (GTK_MINOR_VERSION > 0)
840 /* pressing F10 will activate the menu bar of the top frame */
842 (gdk_event
->keyval
== GDK_F10
) )
844 wxWindow
*ancestor
= win
;
847 if (wxIsKindOf(ancestor
,wxFrame
))
849 wxFrame
*frame
= (wxFrame
*) ancestor
;
850 wxMenuBar
*menubar
= frame
->GetMenuBar();
853 wxNode
*node
= menubar
->GetMenus().First();
856 // doesn't work correctly
857 // wxMenu *firstMenu = (wxMenu*) node->Data();
858 // gtk_menu_item_select( GTK_MENU_ITEM(firstMenu->m_owner) );
864 ancestor
= ancestor
->GetParent();
870 Damn, I forgot why this didn't work, but it didn't work.
872 // win is a panel: up can be propagated to the panel
873 if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
874 (gdk_event->keyval == GDK_Up))
876 win->m_parent->SetFocus();
880 // win is a panel: left/right can be propagated to the panel
881 if ((!ret) && (win->m_wxwindow) &&
882 ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) ||
883 (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
885 wxNavigationKeyEvent new_event;
886 new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
887 new_event.SetCurrentFocus( win );
888 ret = win->GetEventHandler()->ProcessEvent( new_event );
894 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_press_event" );
901 //-----------------------------------------------------------------------------
902 // "key_release_event" from any window
903 //-----------------------------------------------------------------------------
905 static gint
gtk_window_key_release_callback( GtkWidget
*widget
, GdkEventKey
*gdk_event
, wxWindow
*win
)
908 wxapp_install_idle_handler();
910 if (!win
->m_hasVMT
) return FALSE
;
911 if (g_blockEventsOnDrag
) return FALSE
;
914 printf( "KeyUp-ScanCode is: %d.\n", gdk_event->keyval );
915 if (gdk_event->state & GDK_SHIFT_MASK)
916 printf( "ShiftDown.\n" );
918 printf( "ShiftUp.\n" );
919 if (gdk_event->state & GDK_CONTROL_MASK)
920 printf( "ControlDown.\n" );
922 printf( "ControlUp.\n" );
926 long key_code
= map_to_unmodified_wx_keysym( gdk_event
->keyval
);
928 /* sending unknown key events doesn't really make sense */
929 if (key_code
== 0) return FALSE
;
933 GdkModifierType state
;
934 if (gdk_event
->window
) gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
936 wxKeyEvent
event( wxEVT_KEY_UP
);
937 event
.SetTimestamp( gdk_event
->time
);
938 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
939 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
940 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
941 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
942 event
.m_keyCode
= key_code
;
943 event
.m_scanCode
= gdk_event
->keyval
;
946 event
.SetEventObject( win
);
948 if (win
->GetEventHandler()->ProcessEvent( event
))
950 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_release_event" );
957 //-----------------------------------------------------------------------------
958 // "button_press_event"
959 //-----------------------------------------------------------------------------
961 static gint
gtk_window_button_press_callback( GtkWidget
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
964 wxapp_install_idle_handler();
967 wxPrintf( _T("1) OnButtonPress from ") );
968 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
969 wxPrintf( win->GetClassInfo()->GetClassName() );
970 wxPrintf( _T(".\n") );
972 if (!win
->m_hasVMT
) return FALSE
;
973 if (g_blockEventsOnDrag
) return TRUE
;
974 if (g_blockEventsOnScroll
) return TRUE
;
976 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
980 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
) && !GTK_WIDGET_HAS_FOCUS (win
->m_wxwindow
) )
982 gtk_widget_grab_focus (win
->m_wxwindow
);
985 wxPrintf( _T("GrabFocus from ") );
986 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
987 wxPrintf( win->GetClassInfo()->GetClassName() );
988 wxPrintf( _T(".\n") );
995 wxPrintf( _T("2) OnButtonPress from ") );
996 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
997 wxPrintf( win->GetClassInfo()->GetClassName() );
998 wxPrintf( _T(".\n") );
1001 wxEventType event_type
= wxEVT_LEFT_DOWN
;
1003 if (gdk_event
->button
== 1)
1005 switch (gdk_event
->type
)
1007 case GDK_BUTTON_PRESS
: event_type
= wxEVT_LEFT_DOWN
; break;
1008 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_LEFT_DCLICK
; break;
1012 else if (gdk_event
->button
== 2)
1014 switch (gdk_event
->type
)
1016 case GDK_BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DOWN
; break;
1017 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DCLICK
; break;
1021 else if (gdk_event
->button
== 3)
1023 switch (gdk_event
->type
)
1025 case GDK_BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DOWN
; break;
1026 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DCLICK
; break;
1031 wxMouseEvent
event( event_type
);
1032 event
.SetTimestamp( gdk_event
->time
);
1033 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1034 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1035 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1036 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1037 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1038 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1039 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1041 event
.m_x
= (long)gdk_event
->x
;
1042 event
.m_y
= (long)gdk_event
->y
;
1044 // Some control don't have their own X window and thus cannot get
1047 if (!g_captureWindow
)
1049 wxNode
*node
= win
->GetChildren().First();
1052 wxWindow
*child
= (wxWindow
*)node
->Data();
1054 if (child
->m_isStaticBox
)
1056 // wxStaticBox is transparent in the box itself
1059 int xx1
= child
->m_x
;
1060 int yy1
= child
->m_y
;
1061 int xx2
= child
->m_x
+ child
->m_width
;
1062 int yy2
= child
->m_x
+ child
->m_height
;
1065 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
1067 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
1069 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
1071 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
1074 event
.m_x
-= child
->m_x
;
1075 event
.m_y
-= child
->m_y
;
1082 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1083 (child
->m_x
<= event
.m_x
) &&
1084 (child
->m_y
<= event
.m_y
) &&
1085 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
1086 (child
->m_y
+child
->m_height
>= event
.m_y
))
1089 event
.m_x
-= child
->m_x
;
1090 event
.m_y
-= child
->m_y
;
1094 node
= node
->Next();
1098 event
.SetEventObject( win
);
1100 gs_timeLastClick
= gdk_event
->time
;
1102 if (win
->GetEventHandler()->ProcessEvent( event
))
1104 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
1111 //-----------------------------------------------------------------------------
1112 // "button_release_event"
1113 //-----------------------------------------------------------------------------
1115 static gint
gtk_window_button_release_callback( GtkWidget
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
1118 wxapp_install_idle_handler();
1120 if (!win
->m_hasVMT
) return FALSE
;
1121 if (g_blockEventsOnDrag
) return FALSE
;
1122 if (g_blockEventsOnScroll
) return FALSE
;
1124 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1127 printf( "OnButtonRelease from " );
1128 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1129 printf( win->GetClassInfo()->GetClassName() );
1133 wxEventType event_type
= wxEVT_NULL
;
1135 switch (gdk_event
->button
)
1137 case 1: event_type
= wxEVT_LEFT_UP
; break;
1138 case 2: event_type
= wxEVT_MIDDLE_UP
; break;
1139 case 3: event_type
= wxEVT_RIGHT_UP
; break;
1142 wxMouseEvent
event( event_type
);
1143 event
.SetTimestamp( gdk_event
->time
);
1144 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1145 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1146 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1147 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1148 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1149 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1150 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1151 event
.m_x
= (long)gdk_event
->x
;
1152 event
.m_y
= (long)gdk_event
->y
;
1154 // Some control don't have their own X window and thus cannot get
1157 if (!g_captureWindow
)
1159 wxNode
*node
= win
->GetChildren().First();
1162 wxWindow
*child
= (wxWindow
*)node
->Data();
1164 if (child
->m_isStaticBox
)
1166 // wxStaticBox is transparent in the box itself
1169 int xx1
= child
->m_x
;
1170 int yy1
= child
->m_y
;
1171 int xx2
= child
->m_x
+ child
->m_width
;
1172 int yy2
= child
->m_x
+ child
->m_height
;
1175 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
1177 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
1179 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
1181 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
1184 event
.m_x
-= child
->m_x
;
1185 event
.m_y
-= child
->m_y
;
1192 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1193 (child
->m_x
<= event
.m_x
) &&
1194 (child
->m_y
<= event
.m_y
) &&
1195 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
1196 (child
->m_y
+child
->m_height
>= event
.m_y
))
1199 event
.m_x
-= child
->m_x
;
1200 event
.m_y
-= child
->m_y
;
1204 node
= node
->Next();
1208 event
.SetEventObject( win
);
1210 if (win
->GetEventHandler()->ProcessEvent( event
))
1212 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
1219 //-----------------------------------------------------------------------------
1220 // "motion_notify_event"
1221 //-----------------------------------------------------------------------------
1223 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
, GdkEventMotion
*gdk_event
, wxWindow
*win
)
1226 wxapp_install_idle_handler();
1228 if (!win
->m_hasVMT
) return FALSE
;
1229 if (g_blockEventsOnDrag
) return FALSE
;
1230 if (g_blockEventsOnScroll
) return FALSE
;
1232 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1234 if (gdk_event
->is_hint
)
1238 GdkModifierType state
;
1239 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1242 gdk_event
->state
= state
;
1246 printf( "OnMotion from " );
1247 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1248 printf( win->GetClassInfo()->GetClassName() );
1252 wxMouseEvent
event( wxEVT_MOTION
);
1253 event
.SetTimestamp( gdk_event
->time
);
1254 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1255 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1256 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1257 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1258 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1259 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1260 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1262 event
.m_x
= (long)gdk_event
->x
;
1263 event
.m_y
= (long)gdk_event
->y
;
1265 // Some control don't have their own X window and thus cannot get
1268 if (!g_captureWindow
)
1270 wxNode
*node
= win
->GetChildren().First();
1273 wxWindow
*child
= (wxWindow
*)node
->Data();
1275 if (child
->m_isStaticBox
)
1277 // wxStaticBox is transparent in the box itself
1280 int xx1
= child
->m_x
;
1281 int yy1
= child
->m_y
;
1282 int xx2
= child
->m_x
+ child
->m_width
;
1283 int yy2
= child
->m_x
+ child
->m_height
;
1286 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
1288 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
1290 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
1292 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
1295 event
.m_x
-= child
->m_x
;
1296 event
.m_y
-= child
->m_y
;
1303 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1304 (child
->m_x
<= event
.m_x
) &&
1305 (child
->m_y
<= event
.m_y
) &&
1306 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
1307 (child
->m_y
+child
->m_height
>= event
.m_y
))
1310 event
.m_x
-= child
->m_x
;
1311 event
.m_y
-= child
->m_y
;
1315 node
= node
->Next();
1319 event
.SetEventObject( win
);
1321 if (win
->GetEventHandler()->ProcessEvent( event
))
1323 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
1330 //-----------------------------------------------------------------------------
1332 //-----------------------------------------------------------------------------
1334 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
1337 wxapp_install_idle_handler();
1339 if (!win
->m_hasVMT
) return FALSE
;
1340 if (g_blockEventsOnDrag
) return FALSE
;
1342 g_focusWindow
= win
;
1344 if (win
->m_wxwindow
)
1346 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
))
1348 GTK_WIDGET_SET_FLAGS (win
->m_wxwindow
, GTK_HAS_FOCUS
);
1350 printf( "SetFocus flag from " );
1351 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1352 printf( win->GetClassInfo()->GetClassName() );
1360 printf( "OnSetFocus from " );
1361 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1362 printf( win->GetClassInfo()->GetClassName() );
1364 printf( WXSTRINGCAST win->GetLabel() );
1368 wxFocusEvent
event( wxEVT_SET_FOCUS
, win
->GetId() );
1369 event
.SetEventObject( win
);
1371 if (win
->GetEventHandler()->ProcessEvent( event
))
1373 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
1380 //-----------------------------------------------------------------------------
1381 // "focus_out_event"
1382 //-----------------------------------------------------------------------------
1384 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
1387 wxapp_install_idle_handler();
1389 if (!win
->m_hasVMT
) return FALSE
;
1390 if (g_blockEventsOnDrag
) return FALSE
;
1392 if (win
->m_wxwindow
)
1394 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
))
1395 GTK_WIDGET_UNSET_FLAGS (win
->m_wxwindow
, GTK_HAS_FOCUS
);
1399 printf( "OnKillFocus from " );
1400 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1401 printf( win->GetClassInfo()->GetClassName() );
1405 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1406 event
.SetEventObject( win
);
1408 if (win
->GetEventHandler()->ProcessEvent( event
))
1410 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_out_event" );
1417 //-----------------------------------------------------------------------------
1418 // "enter_notify_event"
1419 //-----------------------------------------------------------------------------
1421 static gint
gtk_window_enter_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
1424 wxapp_install_idle_handler();
1426 if (!win
->m_hasVMT
) return FALSE
;
1427 if (g_blockEventsOnDrag
) return FALSE
;
1429 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1431 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1432 #if (GTK_MINOR_VERSION > 0)
1433 event
.SetTimestamp( gdk_event
->time
);
1435 event
.SetEventObject( win
);
1439 GdkModifierType state
= (GdkModifierType
)0;
1441 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1443 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
);
1444 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
);
1445 event
.m_altDown
= (state
& GDK_MOD1_MASK
);
1446 event
.m_metaDown
= (state
& GDK_MOD2_MASK
);
1447 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
);
1448 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
);
1449 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
);
1451 event
.m_x
= (long)x
;
1452 event
.m_y
= (long)y
;
1454 if (win
->GetEventHandler()->ProcessEvent( event
))
1456 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
1463 //-----------------------------------------------------------------------------
1464 // "leave_notify_event"
1465 //-----------------------------------------------------------------------------
1467 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
1470 wxapp_install_idle_handler();
1472 if (!win
->m_hasVMT
) return FALSE
;
1473 if (g_blockEventsOnDrag
) return FALSE
;
1475 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1477 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1478 #if (GTK_MINOR_VERSION > 0)
1479 event
.SetTimestamp( gdk_event
->time
);
1481 event
.SetEventObject( win
);
1485 GdkModifierType state
= (GdkModifierType
)0;
1487 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1489 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
);
1490 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
);
1491 event
.m_altDown
= (state
& GDK_MOD1_MASK
);
1492 event
.m_metaDown
= (state
& GDK_MOD2_MASK
);
1493 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
);
1494 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
);
1495 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
);
1497 event
.m_x
= (long)x
;
1498 event
.m_y
= (long)y
;
1500 if (win
->GetEventHandler()->ProcessEvent( event
))
1502 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
1509 //-----------------------------------------------------------------------------
1510 // "value_changed" from m_vAdjust
1511 //-----------------------------------------------------------------------------
1513 static void gtk_window_vscroll_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1516 wxapp_install_idle_handler();
1518 if (g_blockEventsOnDrag
) return;
1520 if (!win
->m_hasVMT
) return;
1522 float diff
= win
->m_vAdjust
->value
- win
->m_oldVerticalPos
;
1523 if (fabs(diff
) < 0.2) return;
1524 win
->m_oldVerticalPos
= win
->m_vAdjust
->value
;
1526 wxEventType command
= wxEVT_NULL
;
1528 float line_step
= win
->m_vAdjust
->step_increment
;
1529 float page_step
= win
->m_vAdjust
->page_increment
;
1531 if (win
->IsScrolling())
1533 command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1537 if (fabs(win
->m_vAdjust
->value
-win
->m_vAdjust
->lower
) < 0.2) command
= wxEVT_SCROLLWIN_BOTTOM
;
1538 else if (fabs(win
->m_vAdjust
->value
-win
->m_vAdjust
->upper
) < 0.2) command
= wxEVT_SCROLLWIN_TOP
;
1539 else if (fabs(diff
-line_step
) < 0.2) command
= wxEVT_SCROLLWIN_LINEDOWN
;
1540 else if (fabs(diff
+line_step
) < 0.2) command
= wxEVT_SCROLLWIN_LINEUP
;
1541 else if (fabs(diff
-page_step
) < 0.2) command
= wxEVT_SCROLLWIN_PAGEDOWN
;
1542 else if (fabs(diff
+page_step
) < 0.2) command
= wxEVT_SCROLLWIN_PAGEUP
;
1543 else command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1546 int value
= (int)(win
->m_vAdjust
->value
+0.5);
1548 wxScrollWinEvent
event( command
, value
, wxVERTICAL
);
1549 event
.SetEventObject( win
);
1550 win
->GetEventHandler()->ProcessEvent( event
);
1553 //-----------------------------------------------------------------------------
1554 // "value_changed" from m_hAdjust
1555 //-----------------------------------------------------------------------------
1557 static void gtk_window_hscroll_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1560 wxapp_install_idle_handler();
1562 if (g_blockEventsOnDrag
) return;
1563 if (!win
->m_hasVMT
) return;
1565 float diff
= win
->m_hAdjust
->value
- win
->m_oldHorizontalPos
;
1566 if (fabs(diff
) < 0.2) return;
1567 win
->m_oldHorizontalPos
= win
->m_hAdjust
->value
;
1569 wxEventType command
= wxEVT_NULL
;
1571 float line_step
= win
->m_hAdjust
->step_increment
;
1572 float page_step
= win
->m_hAdjust
->page_increment
;
1574 if (win
->IsScrolling())
1576 command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1580 if (fabs(win
->m_hAdjust
->value
-win
->m_hAdjust
->lower
) < 0.2) command
= wxEVT_SCROLLWIN_BOTTOM
;
1581 else if (fabs(win
->m_hAdjust
->value
-win
->m_hAdjust
->upper
) < 0.2) command
= wxEVT_SCROLLWIN_TOP
;
1582 else if (fabs(diff
-line_step
) < 0.2) command
= wxEVT_SCROLLWIN_LINEDOWN
;
1583 else if (fabs(diff
+line_step
) < 0.2) command
= wxEVT_SCROLLWIN_LINEUP
;
1584 else if (fabs(diff
-page_step
) < 0.2) command
= wxEVT_SCROLLWIN_PAGEDOWN
;
1585 else if (fabs(diff
+page_step
) < 0.2) command
= wxEVT_SCROLLWIN_PAGEUP
;
1586 else command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1589 int value
= (int)(win
->m_hAdjust
->value
+0.5);
1591 wxScrollWinEvent
event( command
, value
, wxHORIZONTAL
);
1592 event
.SetEventObject( win
);
1593 win
->GetEventHandler()->ProcessEvent( event
);
1596 //-----------------------------------------------------------------------------
1597 // "changed" from m_vAdjust
1598 //-----------------------------------------------------------------------------
1600 static void gtk_window_vscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1603 wxapp_install_idle_handler();
1605 if (g_blockEventsOnDrag
) return;
1606 if (!win
->m_hasVMT
) return;
1608 wxEventType command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1609 int value
= (int)(win
->m_vAdjust
->value
+0.5);
1611 wxScrollWinEvent
event( command
, value
, wxVERTICAL
);
1612 event
.SetEventObject( win
);
1613 win
->GetEventHandler()->ProcessEvent( event
);
1616 //-----------------------------------------------------------------------------
1617 // "changed" from m_hAdjust
1618 //-----------------------------------------------------------------------------
1620 static void gtk_window_hscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1623 wxapp_install_idle_handler();
1625 if (g_blockEventsOnDrag
) return;
1626 if (!win
->m_hasVMT
) return;
1628 wxEventType command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1629 int value
= (int)(win
->m_hAdjust
->value
+0.5);
1631 wxScrollWinEvent
event( command
, value
, wxHORIZONTAL
);
1632 event
.SetEventObject( win
);
1633 win
->GetEventHandler()->ProcessEvent( event
);
1636 //-----------------------------------------------------------------------------
1637 // "button_press_event" from scrollbar
1638 //-----------------------------------------------------------------------------
1640 static gint
gtk_scrollbar_button_press_callback( GtkRange
*WXUNUSED(widget
),
1641 GdkEventButton
*WXUNUSED(gdk_event
),
1645 wxapp_install_idle_handler();
1647 // don't test here as we can release the mouse while being over
1648 // a different window then the slider
1650 // if (gdk_event->window != widget->slider) return FALSE;
1652 win
->SetScrolling( TRUE
);
1657 //-----------------------------------------------------------------------------
1658 // "button_release_event" from scrollbar
1659 //-----------------------------------------------------------------------------
1661 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
,
1662 GdkEventButton
*WXUNUSED(gdk_event
),
1666 // don't test here as we can release the mouse while being over
1667 // a different window then the slider
1669 // if (gdk_event->window != widget->slider) return FALSE;
1671 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(win
->m_widget
);
1673 if (widget
== GTK_RANGE(scrolledWindow
->vscrollbar
))
1674 gtk_signal_emit_by_name( GTK_OBJECT(win
->m_hAdjust
), "value_changed" );
1676 gtk_signal_emit_by_name( GTK_OBJECT(win
->m_vAdjust
), "value_changed" );
1678 win
->SetScrolling( FALSE
);
1683 // ----------------------------------------------------------------------------
1684 // this wxWindowBase function is implemented here (in platform-specific file)
1685 // because it is static and so couldn't be made virtual
1686 // ----------------------------------------------------------------------------
1688 wxWindow
*wxWindowBase::FindFocus()
1690 return g_focusWindow
;
1693 //-----------------------------------------------------------------------------
1694 // "realize" from m_widget
1695 //-----------------------------------------------------------------------------
1697 /* we cannot set colours, fonts and cursors before the widget has
1698 been realized, so we do this directly after realization */
1701 gtk_window_realized_callback( GtkWidget
* WXUNUSED(widget
), wxWindow
*win
)
1704 wxapp_install_idle_handler();
1706 if (win
->m_delayedFont
)
1707 win
->SetFont( win
->GetFont() );
1709 if (win
->m_delayedBackgroundColour
)
1710 win
->SetBackgroundColour( win
->GetBackgroundColour() );
1712 if (win
->m_delayedForegroundColour
)
1713 win
->SetForegroundColour( win
->GetForegroundColour() );
1715 win
->SetCursor( win
->GetCursor() );
1717 wxWindowCreateEvent
event( win
);
1718 event
.SetEventObject( win
);
1719 win
->GetEventHandler()->ProcessEvent( event
);
1724 //-----------------------------------------------------------------------------
1725 // InsertChild for wxWindow.
1726 //-----------------------------------------------------------------------------
1728 /* Callback for wxWindow. This very strange beast has to be used because
1729 * C++ has no virtual methods in a constructor. We have to emulate a
1730 * virtual function here as wxNotebook requires a different way to insert
1731 * a child in it. I had opted for creating a wxNotebookPage window class
1732 * which would have made this superfluous (such in the MDI window system),
1733 * but no-one was listening to me... */
1735 static void wxInsertChildInWindow( wxWindow
* parent
, wxWindow
* child
)
1737 gtk_myfixed_put( GTK_MYFIXED(parent
->m_wxwindow
),
1738 GTK_WIDGET(child
->m_widget
),
1744 if (parent
->HasFlag(wxTAB_TRAVERSAL
))
1746 /* we now allow a window to get the focus as long as it
1747 doesn't have any children. */
1748 GTK_WIDGET_UNSET_FLAGS( parent
->m_wxwindow
, GTK_CAN_FOCUS
);
1752 //-----------------------------------------------------------------------------
1754 //-----------------------------------------------------------------------------
1756 wxWindow
* wxGetActiveWindow()
1758 return g_focusWindow
;
1761 //-----------------------------------------------------------------------------
1763 //-----------------------------------------------------------------------------
1765 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
1767 void wxWindow::Init()
1773 m_widget
= (GtkWidget
*) NULL
;
1774 m_wxwindow
= (GtkWidget
*) NULL
;
1784 m_needParent
= TRUE
;
1785 m_isBeingDeleted
= FALSE
;
1787 m_hasScrolling
= FALSE
;
1788 m_isScrolling
= FALSE
;
1790 m_hAdjust
= (GtkAdjustment
*) NULL
;
1791 m_vAdjust
= (GtkAdjustment
*) NULL
;
1792 m_oldHorizontalPos
= 0.0;
1793 m_oldVerticalPos
= 0.0;
1796 m_scrollGC
= (GdkGC
*) NULL
;
1797 m_widgetStyle
= (GtkStyle
*) NULL
;
1799 m_insertCallback
= (wxInsertChildFunction
) NULL
;
1801 m_isStaticBox
= FALSE
;
1802 m_acceptsFocus
= FALSE
;
1805 wxWindow::wxWindow()
1810 wxWindow::wxWindow( wxWindow
*parent
, wxWindowID id
,
1811 const wxPoint
&pos
, const wxSize
&size
,
1812 long style
, const wxString
&name
)
1816 Create( parent
, id
, pos
, size
, style
, name
);
1819 bool wxWindow::Create( wxWindow
*parent
, wxWindowID id
,
1820 const wxPoint
&pos
, const wxSize
&size
,
1821 long style
, const wxString
&name
)
1823 PreCreation( parent
, id
, pos
, size
, style
, name
);
1825 m_insertCallback
= wxInsertChildInWindow
;
1827 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
1828 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
1831 debug_focus_in( m_widget
, _T("wxWindow::m_widget"), name
);
1834 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
1837 debug_focus_in( scrolledWindow
->hscrollbar
, _T("wxWindow::hsrcollbar"), name
);
1838 debug_focus_in( scrolledWindow
->vscrollbar
, _T("wxWindow::vsrcollbar"), name
);
1841 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
1842 scroll_class
->scrollbar_spacing
= 0;
1844 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
1846 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->hscrollbar
) );
1847 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->vscrollbar
) );
1849 m_wxwindow
= gtk_myfixed_new();
1852 debug_focus_in( m_wxwindow
, _T("wxWindow::m_wxwindow"), name
);
1855 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
1857 #if (GTK_MINOR_VERSION > 0)
1858 GtkMyFixed
*myfixed
= GTK_MYFIXED(m_wxwindow
);
1860 if (HasFlag(wxRAISED_BORDER
))
1862 gtk_myfixed_set_shadow_type( myfixed
, GTK_SHADOW_OUT
);
1864 else if (HasFlag(wxSUNKEN_BORDER
))
1866 gtk_myfixed_set_shadow_type( myfixed
, GTK_SHADOW_IN
);
1870 gtk_myfixed_set_shadow_type( myfixed
, GTK_SHADOW_NONE
);
1872 #else // GTK_MINOR_VERSION == 0
1873 GtkViewport
*viewport
= GTK_VIEWPORT(scrolledWindow
->viewport
);
1875 if (HasFlag(wxRAISED_BORDER
))
1877 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_OUT
);
1879 else if (HasFlag(wxSUNKEN_BORDER
))
1881 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_IN
);
1885 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_NONE
);
1887 #endif // GTK_MINOR_VERSION
1889 if (HasFlag(wxTAB_TRAVERSAL
))
1891 /* we now allow a window to get the focus as long as it
1892 doesn't have any children. */
1893 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
1894 m_acceptsFocus
= FALSE
;
1898 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
1899 m_acceptsFocus
= TRUE
;
1902 #if (GTK_MINOR_VERSION == 0)
1903 // shut the viewport up
1904 gtk_viewport_set_hadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1905 gtk_viewport_set_vadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1906 #endif // GTK_MINOR_VERSION == 0
1908 // I _really_ don't want scrollbars in the beginning
1909 m_vAdjust
->lower
= 0.0;
1910 m_vAdjust
->upper
= 1.0;
1911 m_vAdjust
->value
= 0.0;
1912 m_vAdjust
->step_increment
= 1.0;
1913 m_vAdjust
->page_increment
= 1.0;
1914 m_vAdjust
->page_size
= 5.0;
1915 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
1916 m_hAdjust
->lower
= 0.0;
1917 m_hAdjust
->upper
= 1.0;
1918 m_hAdjust
->value
= 0.0;
1919 m_hAdjust
->step_increment
= 1.0;
1920 m_hAdjust
->page_increment
= 1.0;
1921 m_hAdjust
->page_size
= 5.0;
1922 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
1924 // these handlers block mouse events to any window during scrolling such as
1925 // motion events and prevent GTK and wxWindows from fighting over where the
1928 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_press_event",
1929 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
1931 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_press_event",
1932 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
1934 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_release_event",
1935 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
1937 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_release_event",
1938 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
1940 // these handlers get notified when screen updates are required either when
1941 // scrolling or when the window size (and therefore scrollbar configuration)
1944 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
1945 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
1946 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
1947 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
1949 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "changed",
1950 (GtkSignalFunc
) gtk_window_hscroll_change_callback
, (gpointer
) this );
1951 gtk_signal_connect(GTK_OBJECT(m_vAdjust
), "changed",
1952 (GtkSignalFunc
) gtk_window_vscroll_change_callback
, (gpointer
) this );
1954 gtk_widget_show( m_wxwindow
);
1957 m_parent
->DoAddChild( this );
1966 wxWindow::~wxWindow()
1968 m_isBeingDeleted
= TRUE
;
1977 m_parent
->RemoveChild( this );
1981 gtk_style_unref( m_widgetStyle
);
1982 m_widgetStyle
= (GtkStyle
*) NULL
;
1987 gdk_gc_unref( m_scrollGC
);
1988 m_scrollGC
= (GdkGC
*) NULL
;
1993 gtk_widget_destroy( m_wxwindow
);
1994 m_wxwindow
= (GtkWidget
*) NULL
;
1999 gtk_widget_destroy( m_widget
);
2000 m_widget
= (GtkWidget
*) NULL
;
2004 void wxWindow::PreCreation( wxWindow
*parent
,
2009 const wxString
&name
)
2011 wxASSERT_MSG( !m_needParent
|| parent
, _T("Need complete parent.") );
2013 if ( !CreateBase(parent
, id
, pos
, size
, style
, name
) )
2015 wxFAIL_MSG(_T("window creation failed"));
2018 m_width
= WidthDefault(size
.x
);
2019 m_height
= HeightDefault(size
.y
);
2024 if (!parent
) /* some reasonable defaults */
2028 m_x
= (gdk_screen_width () - m_width
) / 2;
2029 if (m_x
< 10) m_x
= 10;
2033 m_y
= (gdk_screen_height () - m_height
) / 2;
2034 if (m_y
< 10) m_y
= 10;
2039 void wxWindow::PostCreation()
2041 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
2045 /* these get reported to wxWindows -> wxPaintEvent */
2046 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
2047 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
2049 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
2050 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
2052 #if (GTK_MINOR_VERSION > 0)
2053 /* these are called when the "sunken" or "raised" borders are drawn */
2054 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
2055 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
2057 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
2058 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
2062 GtkWidget
*connect_widget
= GetConnectWidget();
2064 ConnectWidget( connect_widget
);
2066 /* we cannot set colours, fonts and cursors before the widget has
2067 been realized, so we do this directly after realization */
2068 gtk_signal_connect( GTK_OBJECT(connect_widget
), "realize",
2069 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
2074 void wxWindow::ConnectWidget( GtkWidget
*widget
)
2076 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
2077 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
2079 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
2080 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
2082 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
2083 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
2085 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
2086 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
2088 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
2089 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
2091 gtk_signal_connect( GTK_OBJECT(widget
), "focus_in_event",
2092 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
2094 gtk_signal_connect( GTK_OBJECT(widget
), "focus_out_event",
2095 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
2097 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
2098 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
2100 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
2101 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
2104 bool wxWindow::Destroy()
2106 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
2110 return wxWindowBase::Destroy();
2113 void wxWindow::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2115 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
2116 wxASSERT_MSG( (m_parent
!= NULL
), _T("wxWindow::SetSize requires parent.\n") );
2118 if (m_resizing
) return; /* I don't like recursions */
2121 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
2123 /* don't set the size for children of wxNotebook, just take the values. */
2131 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2133 if (x
!= -1) m_x
= x
;
2134 if (y
!= -1) m_y
= y
;
2135 if (width
!= -1) m_width
= width
;
2136 if (height
!= -1) m_height
= height
;
2146 if ((sizeFlags
& wxSIZE_AUTO_WIDTH
) == wxSIZE_AUTO_WIDTH
)
2148 if (width
== -1) m_width
= 80;
2151 if ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) == wxSIZE_AUTO_HEIGHT
)
2153 if (height
== -1) m_height
= 26;
2156 if ((m_minWidth
!= -1) && (m_width
< m_minWidth
)) m_width
= m_minWidth
;
2157 if ((m_minHeight
!= -1) && (m_height
< m_minHeight
)) m_height
= m_minHeight
;
2158 if ((m_maxWidth
!= -1) && (m_width
> m_maxWidth
)) m_width
= m_maxWidth
;
2159 if ((m_maxHeight
!= -1) && (m_height
> m_maxHeight
)) m_height
= m_maxHeight
;
2162 int bottom_border
= 0;
2164 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2166 /* the default button has a border around it */
2171 /* this is the result of hours of debugging: the following code
2172 means that if we have a m_wxwindow and we set the size of
2173 m_widget, m_widget (which is a GtkScrolledWindow) does NOT
2174 automatically propagate its size down to its m_wxwindow,
2175 which is its client area. therefore, we have to tell the
2176 client area directly that it has to resize itself.
2177 this will lead to that m_widget (GtkScrolledWindow) will
2178 calculate how much size it needs for scrollbars etc and
2179 it will then call XXX_size_allocate of its child, which
2180 is m_wxwindow. m_wxwindow in turn will do the same with its
2181 children and so on. problems can arise if this happens
2182 before all the children have been realized as some widgets
2183 stupidy need to be realized during XXX_size_allocate (e.g.
2184 GtkNotebook) and they will segv if called otherwise. this
2185 emergency is tested in gtk_myfixed_size_allocate. Normally
2186 this shouldn't be needed and only gtk_widget_queue_resize()
2187 should be enough to provoke a resize at the next appropriate
2188 moment, but this seems to fail, e.g. when a wxNotebook contains
2189 a wxSplitterWindow: the splitter window's children won't
2190 show up properly resized then. */
2192 gtk_myfixed_set_size( GTK_MYFIXED(m_parent
->m_wxwindow
),
2197 m_height
+border
+bottom_border
);
2202 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2203 event
.SetEventObject( this );
2204 GetEventHandler()->ProcessEvent( event
);
2209 void wxWindow::OnInternalIdle()
2211 wxCursor cursor
= m_cursor
;
2212 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2214 if (cursor
.Ok() && m_currentGdkCursor
!= cursor
)
2218 GdkWindow
*window
= m_wxwindow
->window
;
2220 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2222 if (!g_globalCursor
.Ok())
2223 cursor
= *wxSTANDARD_CURSOR
;
2225 window
= m_widget
->window
;
2227 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2231 GdkWindow
*window
= m_widget
->window
;
2233 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2236 m_currentGdkCursor
= cursor
;
2242 void wxWindow::DoGetSize( int *width
, int *height
) const
2244 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2246 if (width
) (*width
) = m_width
;
2247 if (height
) (*height
) = m_height
;
2250 void wxWindow::DoSetClientSize( int width
, int height
)
2252 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2256 SetSize( width
, height
);
2263 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
2264 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
2266 #if (GTK_MINOR_VERSION == 0)
2267 GtkWidget
*viewport
= scroll_window
->viewport
;
2268 GtkStyleClass
*viewport_class
= viewport
->style
->klass
;
2270 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2272 dw
+= 2 * viewport_class
->xthickness
;
2273 dh
+= 2 * viewport_class
->ythickness
;
2276 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2278 /* when using GTK 1.2 we set the border size to 2 */
2287 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2288 GtkWidget *vscrollbar = scroll_window->vscrollbar;
2290 we use this instead: range.slider_width = 11 + 2*2pts edge
2293 if (scroll_window
->vscrollbar_visible
)
2295 dw
+= 15; /* dw += vscrollbar->allocation.width; */
2296 dw
+= scroll_class
->scrollbar_spacing
;
2299 if (scroll_window
->hscrollbar_visible
)
2301 dh
+= 15; /* dh += hscrollbar->allocation.height; */
2302 dh
+= scroll_class
->scrollbar_spacing
;
2306 SetSize( width
+dw
, height
+dh
);
2310 void wxWindow::DoGetClientSize( int *width
, int *height
) const
2312 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2316 if (width
) (*width
) = m_width
;
2317 if (height
) (*height
) = m_height
;
2324 #if (GTK_MINOR_VERSION == 0)
2325 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2329 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
2330 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
2332 GtkWidget
*viewport
= scroll_window
->viewport
;
2333 GtkStyleClass
*viewport_class
= viewport
->style
->klass
;
2335 dw
+= 2 * viewport_class
->xthickness
;
2336 dh
+= 2 * viewport_class
->ythickness
;
2340 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2342 /* when using GTK 1.2 we set the border size to 2 */
2350 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2351 GtkWidget *vscrollbar = scroll_window->vscrollbar;
2353 we use this instead: range.slider_width = 11 + 2*2pts edge
2356 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
2357 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
2359 if (scroll_window
->vscrollbar_visible
)
2361 dw
+= 15; /* dw += vscrollbar->allocation.width; */
2362 dw
+= scroll_class
->scrollbar_spacing
;
2365 if (scroll_window
->hscrollbar_visible
)
2367 dh
+= 15; /* dh += hscrollbar->allocation.height; */
2368 dh
+= scroll_class
->scrollbar_spacing
;
2372 if (width
) (*width
) = m_width
- dw
;
2373 if (height
) (*height
) = m_height
- dh
;
2377 void wxWindow::DoGetPosition( int *x
, int *y
) const
2379 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2385 void wxWindow::DoClientToScreen( int *x
, int *y
) const
2387 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2389 if (!m_widget
->window
) return;
2391 GdkWindow
*source
= (GdkWindow
*) NULL
;
2393 source
= m_wxwindow
->window
;
2395 source
= m_widget
->window
;
2399 gdk_window_get_origin( source
, &org_x
, &org_y
);
2403 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2405 org_x
+= m_widget
->allocation
.x
;
2406 org_y
+= m_widget
->allocation
.y
;
2414 void wxWindow::DoScreenToClient( int *x
, int *y
) const
2416 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2418 if (!m_widget
->window
) return;
2420 GdkWindow
*source
= (GdkWindow
*) NULL
;
2422 source
= m_wxwindow
->window
;
2424 source
= m_widget
->window
;
2428 gdk_window_get_origin( source
, &org_x
, &org_y
);
2432 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2434 org_x
+= m_widget
->allocation
.x
;
2435 org_y
+= m_widget
->allocation
.y
;
2443 bool wxWindow::Show( bool show
)
2445 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, _T("invalid window") );
2447 if (!wxWindowBase::Show(show
))
2454 gtk_widget_show( m_widget
);
2456 gtk_widget_hide( m_widget
);
2461 bool wxWindow::Enable( bool enable
)
2463 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, _T("invalid window") );
2465 if (!wxWindowBase::Enable(enable
))
2471 gtk_widget_set_sensitive( m_widget
, enable
);
2473 gtk_widget_set_sensitive( m_wxwindow
, enable
);
2478 int wxWindow::GetCharHeight() const
2480 wxCHECK_MSG( (m_widget
!= NULL
), 12, _T("invalid window") );
2482 wxCHECK_MSG( m_font
.Ok(), 12, _T("invalid font") );
2484 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
2486 return font
->ascent
+ font
->descent
;
2489 int wxWindow::GetCharWidth() const
2491 wxCHECK_MSG( (m_widget
!= NULL
), 8, _T("invalid window") );
2493 wxCHECK_MSG( m_font
.Ok(), 8, _T("invalid font") );
2495 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
2497 return gdk_string_width( font
, "H" );
2500 void wxWindow::GetTextExtent( const wxString
& string
,
2504 int *externalLeading
,
2505 const wxFont
*theFont
) const
2507 wxFont fontToUse
= m_font
;
2508 if (theFont
) fontToUse
= *theFont
;
2510 wxCHECK_RET( fontToUse
.Ok(), _T("invalid font") );
2512 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
2513 if (x
) (*x
) = gdk_string_width( font
, string
.mbc_str() );
2514 if (y
) (*y
) = font
->ascent
+ font
->descent
;
2515 if (descent
) (*descent
) = font
->descent
;
2516 if (externalLeading
) (*externalLeading
) = 0; // ??
2519 void wxWindow::SetFocus()
2521 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2523 GtkWidget
*connect_widget
= GetConnectWidget();
2526 if (GTK_WIDGET_CAN_FOCUS(connect_widget
) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ )
2528 gtk_widget_grab_focus (connect_widget
);
2530 else if (GTK_IS_CONTAINER(connect_widget
))
2532 gtk_container_focus( GTK_CONTAINER(connect_widget
), GTK_DIR_TAB_FORWARD
);
2540 bool wxWindow::AcceptsFocus() const
2542 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
2545 bool wxWindow::Reparent( wxWindow
*newParent
)
2547 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, _T("invalid window") );
2549 wxWindow
*oldParent
= m_parent
;
2551 if ( !wxWindowBase::Reparent(newParent
) )
2556 gtk_container_remove( GTK_CONTAINER(oldParent
->m_wxwindow
), m_widget
);
2561 /* insert GTK representation */
2562 (*(newParent
->m_insertCallback
))(newParent
, this);
2568 void wxWindow::DoAddChild(wxWindow
*child
)
2570 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
2572 wxASSERT_MSG( (child
!= NULL
), _T("invalid child window") );
2574 wxASSERT_MSG( (m_insertCallback
!= NULL
), _T("invalid child insertion function") );
2579 /* insert GTK representation */
2580 (*m_insertCallback
)(this, child
);
2583 void wxWindow::Raise()
2585 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2587 if (!m_widget
->window
) return;
2589 gdk_window_raise( m_widget
->window
);
2592 void wxWindow::Lower()
2594 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2596 if (!m_widget
->window
) return;
2598 gdk_window_lower( m_widget
->window
);
2601 bool wxWindow::SetCursor( const wxCursor
&cursor
)
2603 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, _T("invalid window") );
2605 if (!wxWindowBase::SetCursor(cursor
))
2607 // don't leave if the GTK widget has just
2609 if (!m_delayedCursor
) return FALSE
;
2612 GtkWidget
*connect_widget
= GetConnectWidget();
2613 if (!connect_widget
->window
)
2615 // indicate that a new style has been set
2616 // but it couldn't get applied as the
2617 // widget hasn't been realized yet.
2618 m_delayedCursor
= TRUE
;
2620 // pretend we have done something
2624 // gdk_window_set_cursor( connect_widget->window, GetCursor().GetCursor() );
2630 void wxWindow::WarpPointer( int x
, int y
)
2632 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2634 GtkWidget
*connect_widget
= GetConnectWidget();
2635 if (connect_widget
->window
)
2637 /* we provide this function ourselves as it is
2639 gdk_window_warp_pointer( connect_widget
->window
, x
, y
);
2643 void wxWindow::Refresh( bool eraseBackground
, const wxRect
*rect
)
2645 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2647 if (!m_widget
->window
) return;
2649 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
2653 gdk_window_clear_area( m_wxwindow
->window
,
2655 rect
->width
, rect
->height
);
2659 gdk_window_clear( m_wxwindow
->window
);
2666 gtk_widget_draw( m_wxwindow
, (GdkRectangle
*) NULL
);
2668 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
2672 GdkRectangle gdk_rect
;
2673 gdk_rect
.x
= rect
->x
;
2674 gdk_rect
.y
= rect
->y
;
2675 gdk_rect
.width
= rect
->width
;
2676 gdk_rect
.height
= rect
->height
;
2679 gtk_widget_draw( m_wxwindow
, &gdk_rect
);
2681 gtk_widget_draw( m_widget
, &gdk_rect
);
2685 void wxWindow::Clear()
2687 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2689 if (!m_widget
->window
) return;
2691 if (m_wxwindow
&& m_wxwindow
->window
)
2693 gdk_window_clear( m_wxwindow
->window
);
2698 void wxWindow::DoSetToolTip( wxToolTip
*tip
)
2700 wxWindowBase::DoSetToolTip(tip
);
2703 m_tooltip
->Apply( this );
2706 void wxWindow::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
2708 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxConvCurrent
->cWX2MB(tip
), (gchar
*) NULL
);
2710 #endif // wxUSE_TOOLTIPS
2712 bool wxWindow::SetBackgroundColour( const wxColour
&colour
)
2714 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2716 if (!wxWindowBase::SetBackgroundColour(colour
))
2718 // don't leave if the GTK widget has just
2720 if (!m_delayedBackgroundColour
) return FALSE
;
2723 GtkWidget
*connect_widget
= GetConnectWidget();
2724 if (!connect_widget
->window
)
2726 // indicate that a new style has been set
2727 // but it couldn't get applied as the
2728 // widget hasn't been realized yet.
2729 m_delayedBackgroundColour
= TRUE
;
2731 // pretend we have done something
2735 if (m_wxwindow
&& m_wxwindow
->window
)
2737 /* wxMSW doesn't clear the window here. I don't do that either to
2738 provide compatibility. call Clear() to do the job. */
2740 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( m_wxwindow
->window
) );
2741 gdk_window_set_background( m_wxwindow
->window
, m_backgroundColour
.GetColor() );
2744 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
2745 if (sysbg
== m_backgroundColour
)
2747 m_backgroundColour
= wxNullColour
;
2749 m_backgroundColour
= sysbg
;
2759 bool wxWindow::SetForegroundColour( const wxColour
&colour
)
2761 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2763 if (!wxWindowBase::SetForegroundColour(colour
))
2765 // don't leave if the GTK widget has just
2767 if (!m_delayedForegroundColour
) return FALSE
;
2770 GtkWidget
*connect_widget
= GetConnectWidget();
2771 if (!connect_widget
->window
)
2773 // indicate that a new style has been set
2774 // but it couldn't get applied as the
2775 // widget hasn't been realized yet.
2776 m_delayedForegroundColour
= TRUE
;
2778 // pretend we have done something
2782 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
2783 if ( sysbg
== m_backgroundColour
)
2785 m_backgroundColour
= wxNullColour
;
2787 m_backgroundColour
= sysbg
;
2797 GtkStyle
*wxWindow::GetWidgetStyle()
2799 if (m_widgetStyle
) gtk_style_unref( m_widgetStyle
);
2801 m_widgetStyle
= gtk_style_copy( gtk_widget_get_style( m_widget
) );
2803 return m_widgetStyle
;
2806 void wxWindow::SetWidgetStyle()
2808 GtkStyle
*style
= GetWidgetStyle();
2810 gdk_font_unref( style
->font
);
2811 style
->font
= gdk_font_ref( m_font
.GetInternalFont( 1.0 ) );
2813 if (m_foregroundColour
.Ok())
2815 m_foregroundColour
.CalcPixel( gdk_window_get_colormap( m_widget
->window
) );
2816 style
->fg
[GTK_STATE_NORMAL
] = *m_foregroundColour
.GetColor();
2817 style
->fg
[GTK_STATE_PRELIGHT
] = *m_foregroundColour
.GetColor();
2818 style
->fg
[GTK_STATE_ACTIVE
] = *m_foregroundColour
.GetColor();
2821 if (m_backgroundColour
.Ok())
2823 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( m_widget
->window
) );
2824 style
->bg
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
2825 style
->base
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
2826 style
->bg
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
2827 style
->base
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
2828 style
->bg
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
2829 style
->base
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
2830 style
->bg
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
2831 style
->base
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
2835 void wxWindow::ApplyWidgetStyle()
2839 static void SetInvokingWindow( wxMenu
*menu
, wxWindow
*win
)
2841 menu
->SetInvokingWindow( win
);
2842 wxNode
*node
= menu
->GetItems().First();
2845 wxMenuItem
*menuitem
= (wxMenuItem
*)node
->Data();
2846 if (menuitem
->IsSubMenu())
2848 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
2850 node
= node
->Next();
2854 static gint gs_pop_x
= 0;
2855 static gint gs_pop_y
= 0;
2857 static void pop_pos_callback( GtkMenu
* WXUNUSED(menu
),
2861 win
->ClientToScreen( &gs_pop_x
, &gs_pop_y
);
2866 bool wxWindow::PopupMenu( wxMenu
*menu
, int x
, int y
)
2868 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2870 wxCHECK_MSG( menu
!= NULL
, FALSE
, _T("invalid popup-menu") );
2872 SetInvokingWindow( menu
, this );
2880 GTK_MENU(menu
->m_menu
),
2881 (GtkWidget
*) NULL
, // parent menu shell
2882 (GtkWidget
*) NULL
, // parent menu item
2883 (GtkMenuPositionFunc
) pop_pos_callback
,
2884 (gpointer
) this, // client data
2885 0, // button used to activate it
2886 0 //gs_timeLastClick // the time of activation
2891 #if wxUSE_DRAG_AND_DROP
2893 void wxWindow::SetDropTarget( wxDropTarget
*dropTarget
)
2895 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2897 GtkWidget
*dnd_widget
= GetConnectWidget();
2899 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
2901 if (m_dropTarget
) delete m_dropTarget
;
2902 m_dropTarget
= dropTarget
;
2904 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
2907 #endif // wxUSE_DRAG_AND_DROP
2909 GtkWidget
* wxWindow::GetConnectWidget()
2911 GtkWidget
*connect_widget
= m_widget
;
2912 if (m_wxwindow
) connect_widget
= m_wxwindow
;
2914 return connect_widget
;
2917 bool wxWindow::IsOwnGtkWindow( GdkWindow
*window
)
2919 if (m_wxwindow
) return (window
== m_wxwindow
->window
);
2920 return (window
== m_widget
->window
);
2923 bool wxWindow::SetFont( const wxFont
&font
)
2925 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T( "invalid window") );
2927 if (!wxWindowBase::SetFont(font
))
2929 // don't leave if the GTK widget has just
2931 if (!m_delayedFont
) return FALSE
;
2934 GtkWidget
*connect_widget
= GetConnectWidget();
2935 if (!connect_widget
->window
)
2937 // indicate that a new style has been set
2938 // but it couldn't get applied as the
2939 // widget hasn't been realized yet.
2940 m_delayedFont
= TRUE
;
2942 // pretend we have done something
2946 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
2947 if ( sysbg
== m_backgroundColour
)
2949 m_backgroundColour
= wxNullColour
;
2951 m_backgroundColour
= sysbg
;
2961 void wxWindow::CaptureMouse()
2963 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2965 wxCHECK_RET( g_captureWindow
== NULL
, _T("CaptureMouse called twice") );
2967 GtkWidget
*connect_widget
= GetConnectWidget();
2968 if (!connect_widget
->window
) return;
2970 gdk_pointer_grab( connect_widget
->window
, FALSE
,
2972 (GDK_BUTTON_PRESS_MASK
|
2973 GDK_BUTTON_RELEASE_MASK
|
2974 GDK_POINTER_MOTION_MASK
),
2976 m_cursor
.GetCursor(),
2978 g_captureWindow
= this;
2981 void wxWindow::ReleaseMouse()
2983 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2985 wxCHECK_RET( g_captureWindow
, _T("ReleaseMouse called twice") );
2987 GtkWidget
*connect_widget
= GetConnectWidget();
2988 if (!connect_widget
->window
) return;
2990 gdk_pointer_ungrab ( GDK_CURRENT_TIME
);
2991 g_captureWindow
= (wxWindow
*) NULL
;
2994 bool wxWindow::IsRetained() const
2999 void wxWindow::SetScrollbar( int orient
, int pos
, int thumbVisible
,
3000 int range
, bool refresh
)
3002 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
3004 wxCHECK_RET( m_wxwindow
!= NULL
, _T("window needs client area for scrolling") );
3006 m_hasScrolling
= TRUE
;
3008 if (orient
== wxHORIZONTAL
)
3010 float fpos
= (float)pos
;
3011 float frange
= (float)range
;
3012 float fthumb
= (float)thumbVisible
;
3013 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
3014 if (fpos
< 0.0) fpos
= 0.0;
3016 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
3017 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
3019 SetScrollPos( orient
, pos
, refresh
);
3023 m_oldHorizontalPos
= fpos
;
3025 m_hAdjust
->lower
= 0.0;
3026 m_hAdjust
->upper
= frange
;
3027 m_hAdjust
->value
= fpos
;
3028 m_hAdjust
->step_increment
= 1.0;
3029 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
3030 m_hAdjust
->page_size
= fthumb
;
3034 float fpos
= (float)pos
;
3035 float frange
= (float)range
;
3036 float fthumb
= (float)thumbVisible
;
3037 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
3038 if (fpos
< 0.0) fpos
= 0.0;
3040 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
3041 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
3043 SetScrollPos( orient
, pos
, refresh
);
3047 m_oldVerticalPos
= fpos
;
3049 m_vAdjust
->lower
= 0.0;
3050 m_vAdjust
->upper
= frange
;
3051 m_vAdjust
->value
= fpos
;
3052 m_vAdjust
->step_increment
= 1.0;
3053 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
3054 m_vAdjust
->page_size
= fthumb
;
3057 if (orient
== wxHORIZONTAL
)
3058 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
3060 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
3063 void wxWindow::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
3065 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
3067 wxCHECK_RET( m_wxwindow
!= NULL
, _T("window needs client area for scrolling") );
3069 if (orient
== wxHORIZONTAL
)
3071 float fpos
= (float)pos
;
3072 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
3073 if (fpos
< 0.0) fpos
= 0.0;
3074 m_oldHorizontalPos
= fpos
;
3076 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
3077 m_hAdjust
->value
= fpos
;
3081 float fpos
= (float)pos
;
3082 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
3083 if (fpos
< 0.0) fpos
= 0.0;
3084 m_oldVerticalPos
= fpos
;
3086 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
3087 m_vAdjust
->value
= fpos
;
3090 if (!m_isScrolling
) /* prevent recursion */
3092 if (m_wxwindow
->window
)
3094 if (orient
== wxHORIZONTAL
)
3095 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
3097 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
3102 int wxWindow::GetScrollThumb( int orient
) const
3104 wxCHECK_MSG( m_widget
!= NULL
, 0, _T("invalid window") );
3106 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, _T("window needs client area for scrolling") );
3108 if (orient
== wxHORIZONTAL
)
3109 return (int)(m_hAdjust
->page_size
+0.5);
3111 return (int)(m_vAdjust
->page_size
+0.5);
3114 int wxWindow::GetScrollPos( int orient
) const
3116 wxCHECK_MSG( m_widget
!= NULL
, 0, _T("invalid window") );
3118 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, _T("window needs client area for scrolling") );
3120 if (orient
== wxHORIZONTAL
)
3121 return (int)(m_hAdjust
->value
+0.5);
3123 return (int)(m_vAdjust
->value
+0.5);
3126 int wxWindow::GetScrollRange( int orient
) const
3128 wxCHECK_MSG( m_widget
!= NULL
, 0, _T("invalid window") );
3130 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, _T("window needs client area for scrolling") );
3132 if (orient
== wxHORIZONTAL
)
3133 return (int)(m_hAdjust
->upper
+0.5);
3135 return (int)(m_vAdjust
->upper
+0.5);
3138 void wxWindow::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
3140 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
3142 wxCHECK_RET( m_wxwindow
!= NULL
, _T("window needs client area for scrolling") );
3146 m_scrollGC
= gdk_gc_new( m_wxwindow
->window
);
3147 gdk_gc_set_exposures( m_scrollGC
, TRUE
);
3150 wxNode
*node
= m_children
.First();
3153 wxWindow
*child
= (wxWindow
*) node
->Data();
3156 child
->GetSize( &sx
, &sy
);
3157 child
->SetSize( child
->m_x
+ dx
, child
->m_y
+ dy
, sx
, sy
, wxSIZE_ALLOW_MINUS_ONE
);
3158 node
= node
->Next();
3163 GetClientSize( &cw
, &ch
);
3164 int w
= cw
- abs(dx
);
3165 int h
= ch
- abs(dy
);
3167 if ((h
< 0) || (w
< 0))
3175 if (dx
< 0) s_x
= -dx
;
3176 if (dy
< 0) s_y
= -dy
;
3179 if (dx
> 0) d_x
= dx
;
3180 if (dy
> 0) d_y
= dy
;
3182 gdk_window_copy_area( m_wxwindow
->window
, m_scrollGC
, d_x
, d_y
,
3183 m_wxwindow
->window
, s_x
, s_y
, w
, h
);
3186 if (dx
< 0) rect
.x
= cw
+dx
; else rect
.x
= 0;
3187 if (dy
< 0) rect
.y
= ch
+dy
; else rect
.y
= 0;
3188 if (dy
!= 0) rect
.width
= cw
; else rect
.width
= abs(dx
);
3189 if (dx
!= 0) rect
.height
= ch
; else rect
.height
= abs(dy
);
3191 Refresh( TRUE
, &rect
);
3195 void wxWindow::SetScrolling(bool scroll
)
3197 m_isScrolling
= g_blockEventsOnScroll
= scroll
;