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"
47 //-----------------------------------------------------------------------------
48 // documentation on internals
49 //-----------------------------------------------------------------------------
52 I have been asked several times about writing some documentation about
53 the GTK port of wxWindows, especially its internal structures. Obviously,
54 you cannot understand wxGTK without knowing a little about the GTK, but
55 some more information about what the wxWindow, which is the base class
56 for all other window classes, does seems required as well.
58 What does wxWindow do? It contains the common interface for the following
59 jobs of its descendants:
61 1) Define the rudimentary behaviour common to all window classes, such as
62 resizing, intercepting user input (so as to make it possible to use these
63 events for special purposes in a derived class), window names etc.
65 2) Provide the possibility to contain and manage children, if the derived
66 class is allowed to contain children, which holds true for those window
67 classes which do not display a native GTK widget. To name them, these
68 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
69 work classes are a special case and are handled a bit differently from
70 the rest. The same holds true for the wxNotebook class.
72 3) Provide the possibility to draw into a client area of a window. This,
73 too, only holds true for classes that do not display a native GTK widget
76 4) Provide the entire mechanism for scrolling widgets. This actual inter-
77 face for this is usually in wxScrolledWindow, but the GTK implementation
80 5) A multitude of helper or extra methods for special purposes, such as
81 Drag'n'Drop, managing validators etc.
83 Normally one might expect, that one wxWindows window would always correspond
84 to one GTK widget. Under GTK, there is no such allround widget that has all
85 the functionality. Moreover, the GTK defines a client area as a different
86 widget from the actual widget you are handling. Last but not least some
87 special classes (e.g. wxFrame) handle different categories of widgets and
88 still have the possibility to draw something in the client area.
89 It was therefore required to write a special purpose GTK widget, that would
90 represent a client area in the sense of wxWindows capable to do the jobs
91 2), 3) and 4). I have written this class and it resides in win_gtk.c of
94 All windows must have a widget, with which they interact with other under-
95 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
96 thw wxWindow class has a member variable called m_widget which holds a
97 pointer to this widget. When the window class represents a GTK native widget,
98 this is (in most cases) the only GTK widget the class manages. E.g. the
99 wxStatitText class handles only a GtkLabel widget a pointer to which you
100 can find in m_widget (defined in wxWindow)
102 When the class has a client area for drawing into and for containing children
103 it has to handle the client area widget (of the type GtkMyFixed, defined in
104 win_gtk.c), but there could be any number of widgets, handled by a class
105 The common rule for all windows is only, that the widget that interacts with
106 the rest of GTK must be referenced in m_widget and all other widgets must be
107 children of this widget on the GTK level. The top-most widget, which also
108 represents the client area, must be in the m_wxwindow field and must be of
111 As I said, the window classes that display a GTK native widget only have
112 one widget, so in the case of e.g. the wxButton class m_widget holds a
113 pointer to a GtkButton widget. But windows with client areas (for drawing
114 and children) have a m_widget field that is a pointer to a GtkScrolled-
115 Window and a m_wxwindow field that is pointer to a GtkMyFixed and this
116 one is (in the GTK sense) a child of the GtkScrolledWindow.
118 If the m_wxwindow field is set, then all input to this widget is inter-
119 cepted and sent to the wxWindows class. If not, all input to the widget
120 that gets pointed to by m_widget gets intercepted and sent to the class.
124 //-----------------------------------------------------------------------------
126 //-----------------------------------------------------------------------------
128 extern wxList wxPendingDelete
;
129 extern bool g_blockEventsOnDrag
;
130 extern bool g_blockEventsOnScroll
;
131 static bool g_capturing
= FALSE
;
132 static wxWindow
*g_focusWindow
= (wxWindow
*) NULL
;
134 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
135 the last click here */
136 static guint32 gs_timeLastClick
= 0;
138 #if (GTK_MINOR_VERSION > 0)
140 //-----------------------------------------------------------------------------
141 // local code (see below)
142 //-----------------------------------------------------------------------------
144 static void draw_frame( GtkWidget
*widget
, wxWindow
*win
)
146 if (!win
->HasVMT()) return;
151 if (win
->m_hasScrolling
)
153 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(widget
);
154 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget
)->klass
);
157 GtkWidget *hscrollbar = scroll_window->hscrollbar;
158 GtkWidget *vscrollbar = scroll_window->vscrollbar;
160 we use this instead: range.slider_width = 11 + 2*2pts edge
163 if (scroll_window
->vscrollbar_visible
)
165 dw
+= 15; /* dw += vscrollbar->allocation.width; */
166 dw
+= scroll_class
->scrollbar_spacing
;
169 if (scroll_window
->hscrollbar_visible
)
171 dh
+= 15; /* dh += hscrollbar->allocation.height; */
172 dw
+= scroll_class
->scrollbar_spacing
;
178 if (GTK_WIDGET_NO_WINDOW (widget
))
180 dx
+= widget
->allocation
.x
;
181 dy
+= widget
->allocation
.y
;
184 if (win
->m_windowStyle
& wxRAISED_BORDER
)
186 gtk_draw_shadow( widget
->style
,
191 win
->m_width
-dw
, win
->m_height
-dh
);
195 if (win
->m_windowStyle
& wxSUNKEN_BORDER
)
197 gtk_draw_shadow( widget
->style
,
202 win
->m_width
-dw
, win
->m_height
-dh
);
207 //-----------------------------------------------------------------------------
208 // "expose_event" of m_widget
209 //-----------------------------------------------------------------------------
211 static void gtk_window_own_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindow
*win
)
213 if (gdk_event
->count
> 0) return;
214 draw_frame( widget
, win
);
217 //-----------------------------------------------------------------------------
218 // "draw" of m_wxwindow
219 //-----------------------------------------------------------------------------
221 static void gtk_window_own_draw_callback( GtkWidget
*widget
, GdkRectangle
*WXUNUSED(rect
), wxWindow
*win
)
223 draw_frame( widget
, win
);
228 //-----------------------------------------------------------------------------
229 // "expose_event" of m_wxwindow
230 //-----------------------------------------------------------------------------
232 static void gtk_window_expose_callback( GtkWidget
*WXUNUSED(widget
), GdkEventExpose
*gdk_event
, wxWindow
*win
)
234 if (!win
->HasVMT()) return;
236 win
->m_updateRegion
.Union( gdk_event
->area
.x
,
238 gdk_event
->area
.width
,
239 gdk_event
->area
.height
);
241 if (gdk_event
->count
> 0) return;
244 printf( "OnExpose from " );
245 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
246 printf( win->GetClassInfo()->GetClassName() );
250 wxPaintEvent
event( win
->GetId() );
251 event
.SetEventObject( win
);
252 win
->GetEventHandler()->ProcessEvent( event
);
254 win
->m_updateRegion
.Clear();
257 //-----------------------------------------------------------------------------
258 // "draw" of m_wxwindow
259 //-----------------------------------------------------------------------------
261 static void gtk_window_draw_callback( GtkWidget
*WXUNUSED(widget
), GdkRectangle
*rect
, wxWindow
*win
)
263 if (!win
->HasVMT()) return;
265 win
->m_updateRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
267 wxPaintEvent
event( win
->GetId() );
268 event
.SetEventObject( win
);
269 win
->GetEventHandler()->ProcessEvent( event
);
271 win
->m_updateRegion
.Clear();
274 //-----------------------------------------------------------------------------
275 // "key_press_event" from any window
276 //-----------------------------------------------------------------------------
278 static gint
gtk_window_key_press_callback( GtkWidget
*widget
, GdkEventKey
*gdk_event
, wxWindow
*win
)
280 if (!win
->HasVMT()) return FALSE
;
281 if (g_blockEventsOnDrag
) return FALSE
;
284 wxPrintf( _T("OnKeyPress from ") );
285 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
286 wxPrintf( win->GetClassInfo()->GetClassName() );
287 wxPrintf( _T(".\n") );
291 switch (gdk_event
->keyval
)
293 case GDK_BackSpace
: key_code
= WXK_BACK
; break;
294 case GDK_ISO_Left_Tab
:
296 case GDK_Tab
: key_code
= WXK_TAB
; break;
297 case GDK_Linefeed
: key_code
= WXK_RETURN
; break;
298 case GDK_Clear
: key_code
= WXK_CLEAR
; break;
299 case GDK_Return
: key_code
= WXK_RETURN
; break;
300 case GDK_Pause
: key_code
= WXK_PAUSE
; break;
301 case GDK_Scroll_Lock
: key_code
= WXK_SCROLL
; break;
302 case GDK_Escape
: key_code
= WXK_ESCAPE
; break;
303 case GDK_Delete
: key_code
= WXK_DELETE
; break;
304 case GDK_Home
: key_code
= WXK_HOME
; break;
305 case GDK_Left
: key_code
= WXK_LEFT
; break;
306 case GDK_Up
: key_code
= WXK_UP
; break;
307 case GDK_Right
: key_code
= WXK_RIGHT
; break;
308 case GDK_Down
: key_code
= WXK_DOWN
; break;
309 case GDK_Prior
: key_code
= WXK_PRIOR
; break;
310 // case GDK_Page_Up: key_code = WXK_PAGEUP; break;
311 case GDK_Next
: key_code
= WXK_NEXT
; break;
312 // case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
313 case GDK_End
: key_code
= WXK_END
; break;
314 case GDK_Begin
: key_code
= WXK_HOME
; break;
315 case GDK_Select
: key_code
= WXK_SELECT
; break;
316 case GDK_Print
: key_code
= WXK_PRINT
; break;
317 case GDK_Execute
: key_code
= WXK_EXECUTE
; break;
318 case GDK_Insert
: key_code
= WXK_INSERT
; break;
319 case GDK_Num_Lock
: key_code
= WXK_NUMLOCK
; break;
320 case GDK_KP_Enter
: key_code
= WXK_RETURN
; break;
321 case GDK_KP_Home
: key_code
= WXK_HOME
; break;
322 case GDK_KP_Left
: key_code
= WXK_LEFT
; break;
323 case GDK_KP_Up
: key_code
= WXK_UP
; break;
324 case GDK_KP_Right
: key_code
= WXK_RIGHT
; break;
325 case GDK_KP_Down
: key_code
= WXK_DOWN
; break;
326 case GDK_KP_Prior
: key_code
= WXK_PRIOR
; break;
327 // case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
328 case GDK_KP_Next
: key_code
= WXK_NEXT
; break;
329 // case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
330 case GDK_KP_End
: key_code
= WXK_END
; break;
331 case GDK_KP_Begin
: key_code
= WXK_HOME
; break;
332 case GDK_KP_Insert
: key_code
= WXK_INSERT
; break;
333 case GDK_KP_Delete
: key_code
= WXK_DELETE
; break;
334 case GDK_KP_Multiply
: key_code
= WXK_MULTIPLY
; break;
335 case GDK_KP_Add
: key_code
= WXK_ADD
; break;
336 case GDK_KP_Separator
: key_code
= WXK_SEPARATOR
; break;
337 case GDK_KP_Subtract
: key_code
= WXK_SUBTRACT
; break;
338 case GDK_KP_Decimal
: key_code
= WXK_DECIMAL
; break;
339 case GDK_KP_Divide
: key_code
= WXK_DIVIDE
; break;
340 case GDK_KP_0
: key_code
= WXK_NUMPAD0
; break;
341 case GDK_KP_1
: key_code
= WXK_NUMPAD1
; break;
342 case GDK_KP_2
: key_code
= WXK_NUMPAD2
; break;
343 case GDK_KP_3
: key_code
= WXK_NUMPAD3
; break;
344 case GDK_KP_4
: key_code
= WXK_NUMPAD4
; break;
345 case GDK_KP_5
: key_code
= WXK_NUMPAD5
; break;
346 case GDK_KP_6
: key_code
= WXK_NUMPAD6
; break;
347 case GDK_KP_7
: key_code
= WXK_NUMPAD7
; break;
348 case GDK_KP_8
: key_code
= WXK_NUMPAD7
; break;
349 case GDK_KP_9
: key_code
= WXK_NUMPAD9
; break;
350 case GDK_F1
: key_code
= WXK_F1
; break;
351 case GDK_F2
: key_code
= WXK_F2
; break;
352 case GDK_F3
: key_code
= WXK_F3
; break;
353 case GDK_F4
: key_code
= WXK_F4
; break;
354 case GDK_F5
: key_code
= WXK_F5
; break;
355 case GDK_F6
: key_code
= WXK_F6
; break;
356 case GDK_F7
: key_code
= WXK_F7
; break;
357 case GDK_F8
: key_code
= WXK_F8
; break;
358 case GDK_F9
: key_code
= WXK_F9
; break;
359 case GDK_F10
: key_code
= WXK_F10
; break;
360 case GDK_F11
: key_code
= WXK_F11
; break;
361 case GDK_F12
: key_code
= WXK_F12
; break;
364 if ((gdk_event
->keyval
>= 0x20) && (gdk_event
->keyval
<= 0xFF))
365 key_code
= gdk_event
->keyval
;
369 if (!key_code
) return FALSE
;
371 wxKeyEvent
event( wxEVT_KEY_DOWN
);
372 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
373 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
374 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
375 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
376 event
.m_keyCode
= key_code
;
379 event
.SetEventObject( win
);
381 bool ret
= win
->GetEventHandler()->ProcessEvent( event
);
385 wxWindow
*ancestor
= win
;
388 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
391 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
392 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
395 ancestor
= ancestor
->GetParent();
399 // win is a control: tab can be propagated up
401 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
402 ((win
->m_windowStyle
& wxTE_PROCESS_TAB
) == 0))
404 wxNavigationKeyEvent new_event
;
405 /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
406 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
407 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
408 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
409 new_event
.SetCurrentFocus( win
);
410 ret
= win
->GetEventHandler()->ProcessEvent( new_event
);
414 (gdk_event
->keyval
== GDK_Escape
) )
416 wxCommandEvent
new_event(wxEVT_COMMAND_BUTTON_CLICKED
,wxID_CANCEL
);
417 new_event
.SetEventObject( win
);
418 ret
= win
->GetEventHandler()->ProcessEvent( new_event
);
422 Damn, I forgot why this didn't work, but it didn't work.
424 // win is a panel: up can be propagated to the panel
425 if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
426 (gdk_event->keyval == GDK_Up))
428 win->m_parent->SetFocus();
432 // win is a panel: left/right can be propagated to the panel
433 if ((!ret) && (win->m_wxwindow) &&
434 ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) ||
435 (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
437 wxNavigationKeyEvent new_event;
438 new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
439 new_event.SetCurrentFocus( win );
440 ret = win->GetEventHandler()->ProcessEvent( new_event );
446 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_press_event" );
453 //-----------------------------------------------------------------------------
454 // "key_release_event" from any window
455 //-----------------------------------------------------------------------------
457 static gint
gtk_window_key_release_callback( GtkWidget
*widget
, GdkEventKey
*gdk_event
, wxWindow
*win
)
459 if (!win
->HasVMT()) return FALSE
;
460 if (g_blockEventsOnDrag
) return FALSE
;
463 printf( "OnKeyRelease from " );
464 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
465 printf( win->GetClassInfo()->GetClassName() );
470 switch (gdk_event
->keyval
)
472 case GDK_BackSpace
: key_code
= WXK_BACK
; break;
473 case GDK_ISO_Left_Tab
:
475 case GDK_Tab
: key_code
= WXK_TAB
; break;
476 case GDK_Linefeed
: key_code
= WXK_RETURN
; break;
477 case GDK_Clear
: key_code
= WXK_CLEAR
; break;
478 case GDK_Return
: key_code
= WXK_RETURN
; break;
479 case GDK_Pause
: key_code
= WXK_PAUSE
; break;
480 case GDK_Scroll_Lock
: key_code
= WXK_SCROLL
; break;
481 case GDK_Escape
: key_code
= WXK_ESCAPE
; break;
482 case GDK_Delete
: key_code
= WXK_DELETE
; break;
483 case GDK_Home
: key_code
= WXK_HOME
; break;
484 case GDK_Left
: key_code
= WXK_LEFT
; break;
485 case GDK_Up
: key_code
= WXK_UP
; break;
486 case GDK_Right
: key_code
= WXK_RIGHT
; break;
487 case GDK_Down
: key_code
= WXK_DOWN
; break;
488 case GDK_Prior
: key_code
= WXK_PRIOR
; break;
489 // case GDK_Page_Up: key_code = WXK_PAGEUP; break;
490 case GDK_Next
: key_code
= WXK_NEXT
; break;
491 // case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
492 case GDK_End
: key_code
= WXK_END
; break;
493 case GDK_Begin
: key_code
= WXK_HOME
; break;
494 case GDK_Select
: key_code
= WXK_SELECT
; break;
495 case GDK_Print
: key_code
= WXK_PRINT
; break;
496 case GDK_Execute
: key_code
= WXK_EXECUTE
; break;
497 case GDK_Insert
: key_code
= WXK_INSERT
; break;
498 case GDK_Num_Lock
: key_code
= WXK_NUMLOCK
; break;
499 case GDK_KP_Enter
: key_code
= WXK_RETURN
; break;
500 case GDK_KP_Home
: key_code
= WXK_HOME
; break;
501 case GDK_KP_Left
: key_code
= WXK_LEFT
; break;
502 case GDK_KP_Up
: key_code
= WXK_UP
; break;
503 case GDK_KP_Right
: key_code
= WXK_RIGHT
; break;
504 case GDK_KP_Down
: key_code
= WXK_DOWN
; break;
505 case GDK_KP_Prior
: key_code
= WXK_PRIOR
; break;
506 // case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
507 case GDK_KP_Next
: key_code
= WXK_NEXT
; break;
508 // case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
509 case GDK_KP_End
: key_code
= WXK_END
; break;
510 case GDK_KP_Begin
: key_code
= WXK_HOME
; break;
511 case GDK_KP_Insert
: key_code
= WXK_INSERT
; break;
512 case GDK_KP_Delete
: key_code
= WXK_DELETE
; break;
513 case GDK_KP_Multiply
: key_code
= WXK_MULTIPLY
; break;
514 case GDK_KP_Add
: key_code
= WXK_ADD
; break;
515 case GDK_KP_Separator
: key_code
= WXK_SEPARATOR
; break;
516 case GDK_KP_Subtract
: key_code
= WXK_SUBTRACT
; break;
517 case GDK_KP_Decimal
: key_code
= WXK_DECIMAL
; break;
518 case GDK_KP_Divide
: key_code
= WXK_DIVIDE
; break;
519 case GDK_KP_0
: key_code
= WXK_NUMPAD0
; break;
520 case GDK_KP_1
: key_code
= WXK_NUMPAD1
; break;
521 case GDK_KP_2
: key_code
= WXK_NUMPAD2
; break;
522 case GDK_KP_3
: key_code
= WXK_NUMPAD3
; break;
523 case GDK_KP_4
: key_code
= WXK_NUMPAD4
; break;
524 case GDK_KP_5
: key_code
= WXK_NUMPAD5
; break;
525 case GDK_KP_6
: key_code
= WXK_NUMPAD6
; break;
526 case GDK_KP_7
: key_code
= WXK_NUMPAD7
; break;
527 case GDK_KP_8
: key_code
= WXK_NUMPAD7
; break;
528 case GDK_KP_9
: key_code
= WXK_NUMPAD9
; break;
529 case GDK_F1
: key_code
= WXK_F1
; break;
530 case GDK_F2
: key_code
= WXK_F2
; break;
531 case GDK_F3
: key_code
= WXK_F3
; break;
532 case GDK_F4
: key_code
= WXK_F4
; break;
533 case GDK_F5
: key_code
= WXK_F5
; break;
534 case GDK_F6
: key_code
= WXK_F6
; break;
535 case GDK_F7
: key_code
= WXK_F7
; break;
536 case GDK_F8
: key_code
= WXK_F8
; break;
537 case GDK_F9
: key_code
= WXK_F9
; break;
538 case GDK_F10
: key_code
= WXK_F10
; break;
539 case GDK_F11
: key_code
= WXK_F11
; break;
540 case GDK_F12
: key_code
= WXK_F12
; break;
543 if ((gdk_event
->keyval
>= 0x20) && (gdk_event
->keyval
<= 0xFF))
544 key_code
= gdk_event
->keyval
;
548 if (!key_code
) return FALSE
;
550 wxKeyEvent
event( wxEVT_KEY_UP
);
551 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
552 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
553 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
554 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
555 event
.m_keyCode
= key_code
;
558 event
.SetEventObject( win
);
560 if (win
->GetEventHandler()->ProcessEvent( event
))
562 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_release_event" );
569 //-----------------------------------------------------------------------------
570 // "button_press_event"
571 //-----------------------------------------------------------------------------
573 static gint
gtk_window_button_press_callback( GtkWidget
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
576 wxPrintf( _T("1) OnButtonPress from ") );
577 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
578 wxPrintf( win->GetClassInfo()->GetClassName() );
579 wxPrintf( _T(".\n") );
582 if (!win
->HasVMT()) return FALSE
;
583 if (g_blockEventsOnDrag
) return TRUE
;
584 if (g_blockEventsOnScroll
) return TRUE
;
586 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
590 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
) && !GTK_WIDGET_HAS_FOCUS (win
->m_wxwindow
) )
592 gtk_widget_grab_focus (win
->m_wxwindow
);
595 wxPrintf( _T("GrabFocus from ") );
596 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
597 wxPrintf( win->GetClassInfo()->GetClassName() );
598 wxPrintf( _T(".\n") );
605 wxPrintf( _T("No GrabFocus from ") );
606 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
607 wxPrintf( win->GetClassInfo()->GetClassName() );
608 if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
609 wxPrintf( _T(" because it already has") );
610 wxPrintf( _T(".\n") );
616 wxPrintf( _T("2) OnButtonPress from ") );
617 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
618 wxPrintf( win->GetClassInfo()->GetClassName() );
619 wxPrintf( _T(".\n") );
622 wxEventType event_type
= wxEVT_LEFT_DOWN
;
624 if (gdk_event
->button
== 1)
626 switch (gdk_event
->type
)
628 case GDK_BUTTON_PRESS
: event_type
= wxEVT_LEFT_DOWN
; break;
629 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_LEFT_DCLICK
; break;
633 else if (gdk_event
->button
== 2)
635 switch (gdk_event
->type
)
637 case GDK_BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DOWN
; break;
638 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DCLICK
; break;
642 else if (gdk_event
->button
== 3)
644 switch (gdk_event
->type
)
646 case GDK_BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DOWN
; break;
647 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DCLICK
; break;
652 wxMouseEvent
event( event_type
);
653 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
654 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
655 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
656 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
657 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
658 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
659 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
661 event
.m_x
= (long)gdk_event
->x
;
662 event
.m_y
= (long)gdk_event
->y
;
664 // Some control don't have their own X window and thus cannot get
669 wxNode
*node
= win
->GetChildren().First();
672 wxWindow
*child
= (wxWindow
*)node
->Data();
674 if (child
->m_isStaticBox
)
676 // wxStaticBox is transparent in the box itself
679 int xx1
= child
->m_x
;
680 int yy1
= child
->m_y
;
681 int xx2
= child
->m_x
+ child
->m_width
;
682 int yy2
= child
->m_x
+ child
->m_height
;
685 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
687 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
689 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
691 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
694 event
.m_x
-= child
->m_x
;
695 event
.m_y
-= child
->m_y
;
702 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
703 (child
->m_x
<= event
.m_x
) &&
704 (child
->m_y
<= event
.m_y
) &&
705 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
706 (child
->m_y
+child
->m_height
>= event
.m_y
))
709 event
.m_x
-= child
->m_x
;
710 event
.m_y
-= child
->m_y
;
718 event
.SetEventObject( win
);
720 gs_timeLastClick
= gdk_event
->time
;
722 if (win
->GetEventHandler()->ProcessEvent( event
))
724 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
731 //-----------------------------------------------------------------------------
732 // "button_release_event"
733 //-----------------------------------------------------------------------------
735 static gint
gtk_window_button_release_callback( GtkWidget
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
737 if (!win
->HasVMT()) return FALSE
;
738 if (g_blockEventsOnDrag
) return FALSE
;
739 if (g_blockEventsOnScroll
) return FALSE
;
741 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
744 printf( "OnButtonRelease from " );
745 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
746 printf( win->GetClassInfo()->GetClassName() );
750 wxEventType event_type
= wxEVT_NULL
;
752 switch (gdk_event
->button
)
754 case 1: event_type
= wxEVT_LEFT_UP
; break;
755 case 2: event_type
= wxEVT_MIDDLE_UP
; break;
756 case 3: event_type
= wxEVT_RIGHT_UP
; break;
759 wxMouseEvent
event( event_type
);
760 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
761 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
762 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
763 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
764 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
765 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
766 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
767 event
.m_x
= (long)gdk_event
->x
;
768 event
.m_y
= (long)gdk_event
->y
;
770 // Some control don't have their own X window and thus cannot get
775 wxNode
*node
= win
->GetChildren().First();
778 wxWindow
*child
= (wxWindow
*)node
->Data();
780 if (child
->m_isStaticBox
)
782 // wxStaticBox is transparent in the box itself
785 int xx1
= child
->m_x
;
786 int yy1
= child
->m_y
;
787 int xx2
= child
->m_x
+ child
->m_width
;
788 int yy2
= child
->m_x
+ child
->m_height
;
791 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
793 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
795 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
797 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
800 event
.m_x
-= child
->m_x
;
801 event
.m_y
-= child
->m_y
;
808 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
809 (child
->m_x
<= event
.m_x
) &&
810 (child
->m_y
<= event
.m_y
) &&
811 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
812 (child
->m_y
+child
->m_height
>= event
.m_y
))
815 event
.m_x
-= child
->m_x
;
816 event
.m_y
-= child
->m_y
;
824 event
.SetEventObject( win
);
826 if (win
->GetEventHandler()->ProcessEvent( event
))
828 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
835 //-----------------------------------------------------------------------------
836 // "motion_notify_event"
837 //-----------------------------------------------------------------------------
839 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
, GdkEventMotion
*gdk_event
, wxWindow
*win
)
841 if (!win
->HasVMT()) return FALSE
;
842 if (g_blockEventsOnDrag
) return FALSE
;
843 if (g_blockEventsOnScroll
) return FALSE
;
845 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
847 if (gdk_event
->is_hint
)
851 GdkModifierType state
;
852 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
855 gdk_event
->state
= state
;
859 printf( "OnMotion from " );
860 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
861 printf( win->GetClassInfo()->GetClassName() );
865 wxMouseEvent
event( wxEVT_MOTION
);
866 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
867 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
868 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
869 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
870 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
871 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
872 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
874 event
.m_x
= (long)gdk_event
->x
;
875 event
.m_y
= (long)gdk_event
->y
;
877 // Some control don't have their own X window and thus cannot get
882 wxNode
*node
= win
->GetChildren().First();
885 wxWindow
*child
= (wxWindow
*)node
->Data();
887 if (child
->m_isStaticBox
)
889 // wxStaticBox is transparent in the box itself
892 int xx1
= child
->m_x
;
893 int yy1
= child
->m_y
;
894 int xx2
= child
->m_x
+ child
->m_width
;
895 int yy2
= child
->m_x
+ child
->m_height
;
898 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
900 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
902 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
904 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
907 event
.m_x
-= child
->m_x
;
908 event
.m_y
-= child
->m_y
;
915 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
916 (child
->m_x
<= event
.m_x
) &&
917 (child
->m_y
<= event
.m_y
) &&
918 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
919 (child
->m_y
+child
->m_height
>= event
.m_y
))
922 event
.m_x
-= child
->m_x
;
923 event
.m_y
-= child
->m_y
;
931 event
.SetEventObject( win
);
933 if (win
->GetEventHandler()->ProcessEvent( event
))
935 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
942 //-----------------------------------------------------------------------------
944 //-----------------------------------------------------------------------------
946 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
948 if (!win
->HasVMT()) return FALSE
;
949 if (g_blockEventsOnDrag
) return FALSE
;
955 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
))
957 GTK_WIDGET_SET_FLAGS (win
->m_wxwindow
, GTK_HAS_FOCUS
);
959 printf( "SetFocus flag from " );
960 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
961 printf( win->GetClassInfo()->GetClassName() );
969 wxPrintf( _T("OnSetFocus from ") );
970 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
971 wxPrintf( win->GetClassInfo()->GetClassName() );
973 wxPrintf( win->GetLabel() );
974 wxPrintf( _T(".\n") );
977 wxFocusEvent
event( wxEVT_SET_FOCUS
, win
->GetId() );
978 event
.SetEventObject( win
);
980 if (win
->GetEventHandler()->ProcessEvent( event
))
982 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
989 //-----------------------------------------------------------------------------
991 //-----------------------------------------------------------------------------
993 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
995 if (!win
->HasVMT()) return FALSE
;
996 if (g_blockEventsOnDrag
) return FALSE
;
1000 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
))
1001 GTK_WIDGET_UNSET_FLAGS (win
->m_wxwindow
, GTK_HAS_FOCUS
);
1005 wxPrintf( _T("OnKillFocus from ") );
1006 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1007 wxPrintf( win->GetClassInfo()->GetClassName() );
1008 wxPrintf( _T(" ") );
1009 wxPrintf( win->GetLabel() );
1010 wxPrintf( _T(".\n") );
1013 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1014 event
.SetEventObject( win
);
1016 if (win
->GetEventHandler()->ProcessEvent( event
))
1018 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_out_event" );
1025 //-----------------------------------------------------------------------------
1026 // "enter_notify_event"
1027 //-----------------------------------------------------------------------------
1029 static gint
gtk_window_enter_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
1031 if (!win
->HasVMT()) return FALSE
;
1032 if (g_blockEventsOnDrag
) return FALSE
;
1034 if (widget
->window
!= gdk_event
->window
) return FALSE
;
1036 if ((widget
->window
) && (win
->m_cursor
))
1037 gdk_window_set_cursor( widget
->window
, win
->m_cursor
->GetCursor() );
1040 printf( "OnEnter from " );
1041 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1042 printf( win->GetClassInfo()->GetClassName() );
1046 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1047 event
.SetEventObject( win
);
1051 GdkModifierType state
= (GdkModifierType
)0;
1053 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1055 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
);
1056 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
);
1057 event
.m_altDown
= (state
& GDK_MOD1_MASK
);
1058 event
.m_metaDown
= (state
& GDK_MOD2_MASK
);
1059 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
);
1060 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
);
1061 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
);
1063 event
.m_x
= (long)x
;
1064 event
.m_y
= (long)y
;
1066 if (win
->GetEventHandler()->ProcessEvent( event
))
1068 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
1075 //-----------------------------------------------------------------------------
1076 // "leave_notify_event"
1077 //-----------------------------------------------------------------------------
1079 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
1081 if (!win
->HasVMT()) return FALSE
;
1082 if (g_blockEventsOnDrag
) return FALSE
;
1084 if (widget
->window
!= gdk_event
->window
) return FALSE
;
1086 if ((widget
->window
) && (win
->m_cursor
))
1087 gdk_window_set_cursor( widget
->window
, wxSTANDARD_CURSOR
->GetCursor() );
1090 printf( "OnLeave from " );
1091 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1092 printf( win->GetClassInfo()->GetClassName() );
1096 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1097 event
.SetEventObject( win
);
1101 GdkModifierType state
= (GdkModifierType
)0;
1103 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1105 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
);
1106 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
);
1107 event
.m_altDown
= (state
& GDK_MOD1_MASK
);
1108 event
.m_metaDown
= (state
& GDK_MOD2_MASK
);
1109 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
);
1110 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
);
1111 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
);
1113 event
.m_x
= (long)x
;
1114 event
.m_y
= (long)y
;
1116 if (win
->GetEventHandler()->ProcessEvent( event
))
1118 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
1125 //-----------------------------------------------------------------------------
1126 // "value_changed" from m_vAdjust
1127 //-----------------------------------------------------------------------------
1129 static void gtk_window_vscroll_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1131 if (g_blockEventsOnDrag
) return;
1134 printf( "OnVScroll from " );
1135 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1136 printf( win->GetClassInfo()->GetClassName() );
1140 if (!win
->HasVMT()) return;
1142 float diff
= win
->m_vAdjust
->value
- win
->m_oldVerticalPos
;
1143 if (fabs(diff
) < 0.2) return;
1144 win
->m_oldVerticalPos
= win
->m_vAdjust
->value
;
1146 wxEventType command
= wxEVT_NULL
;
1148 float line_step
= win
->m_vAdjust
->step_increment
;
1149 float page_step
= win
->m_vAdjust
->page_increment
;
1151 if (win
->m_isScrolling
)
1153 command
= wxEVT_SCROLL_THUMBTRACK
;
1157 if (fabs(win
->m_vAdjust
->value
-win
->m_vAdjust
->lower
) < 0.2) command
= wxEVT_SCROLL_BOTTOM
;
1158 else if (fabs(win
->m_vAdjust
->value
-win
->m_vAdjust
->upper
) < 0.2) command
= wxEVT_SCROLL_TOP
;
1159 else if (fabs(diff
-line_step
) < 0.2) command
= wxEVT_SCROLL_LINEDOWN
;
1160 else if (fabs(diff
+line_step
) < 0.2) command
= wxEVT_SCROLL_LINEUP
;
1161 else if (fabs(diff
-page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEDOWN
;
1162 else if (fabs(diff
+page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEUP
;
1163 else command
= wxEVT_SCROLL_THUMBTRACK
;
1166 int value
= (int)(win
->m_vAdjust
->value
+0.5);
1168 wxScrollEvent
event( command
, win
->GetId(), value
, wxVERTICAL
);
1169 event
.SetEventObject( win
);
1170 win
->GetEventHandler()->ProcessEvent( event
);
1173 //-----------------------------------------------------------------------------
1174 // "value_changed" from m_hAdjust
1175 //-----------------------------------------------------------------------------
1177 static void gtk_window_hscroll_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1179 if (g_blockEventsOnDrag
) return;
1182 printf( "OnHScroll from " );
1183 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1184 printf( win->GetClassInfo()->GetClassName() );
1188 if (!win
->HasVMT()) return;
1190 float diff
= win
->m_hAdjust
->value
- win
->m_oldHorizontalPos
;
1191 if (fabs(diff
) < 0.2) return;
1192 win
->m_oldHorizontalPos
= win
->m_hAdjust
->value
;
1194 wxEventType command
= wxEVT_NULL
;
1196 float line_step
= win
->m_hAdjust
->step_increment
;
1197 float page_step
= win
->m_hAdjust
->page_increment
;
1199 if (win
->m_isScrolling
)
1201 command
= wxEVT_SCROLL_THUMBTRACK
;
1205 if (fabs(win
->m_hAdjust
->value
-win
->m_hAdjust
->lower
) < 0.2) command
= wxEVT_SCROLL_BOTTOM
;
1206 else if (fabs(win
->m_hAdjust
->value
-win
->m_hAdjust
->upper
) < 0.2) command
= wxEVT_SCROLL_TOP
;
1207 else if (fabs(diff
-line_step
) < 0.2) command
= wxEVT_SCROLL_LINEDOWN
;
1208 else if (fabs(diff
+line_step
) < 0.2) command
= wxEVT_SCROLL_LINEUP
;
1209 else if (fabs(diff
-page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEDOWN
;
1210 else if (fabs(diff
+page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEUP
;
1211 else command
= wxEVT_SCROLL_THUMBTRACK
;
1214 int value
= (int)(win
->m_hAdjust
->value
+0.5);
1216 wxScrollEvent
event( command
, win
->GetId(), value
, wxHORIZONTAL
);
1217 event
.SetEventObject( win
);
1218 win
->GetEventHandler()->ProcessEvent( event
);
1221 //-----------------------------------------------------------------------------
1222 // "changed" from m_vAdjust
1223 //-----------------------------------------------------------------------------
1225 static void gtk_window_vscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1227 if (g_blockEventsOnDrag
) return;
1230 printf( "OnVScroll change from " );
1231 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1232 printf( win->GetClassInfo()->GetClassName() );
1236 if (!win
->HasVMT()) return;
1238 wxEventType command
= wxEVT_SCROLL_THUMBTRACK
;
1239 int value
= (int)(win
->m_vAdjust
->value
+0.5);
1241 wxScrollEvent
event( command
, win
->GetId(), value
, wxVERTICAL
);
1242 event
.SetEventObject( win
);
1243 win
->GetEventHandler()->ProcessEvent( event
);
1246 //-----------------------------------------------------------------------------
1247 // "changed" from m_hAdjust
1248 //-----------------------------------------------------------------------------
1250 static void gtk_window_hscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1252 if (g_blockEventsOnDrag
) return;
1255 printf( "OnHScroll change from " );
1256 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1257 printf( win->GetClassInfo()->GetClassName() );
1261 if (!win
->HasVMT()) return;
1263 wxEventType command
= wxEVT_SCROLL_THUMBTRACK
;
1264 int value
= (int)(win
->m_hAdjust
->value
+0.5);
1266 wxScrollEvent
event( command
, win
->GetId(), value
, wxHORIZONTAL
);
1267 event
.SetEventObject( win
);
1268 win
->GetEventHandler()->ProcessEvent( event
);
1271 //-----------------------------------------------------------------------------
1272 // "button_press_event" from scrollbar
1273 //-----------------------------------------------------------------------------
1275 static gint
gtk_scrollbar_button_press_callback( GtkRange
*WXUNUSED(widget
),
1276 GdkEventButton
*WXUNUSED(gdk_event
),
1279 // don't test here as we can release the mouse while being over
1280 // a different window then the slider
1282 // if (gdk_event->window != widget->slider) return FALSE;
1284 win
->m_isScrolling
= TRUE
;
1285 g_blockEventsOnScroll
= TRUE
;
1290 //-----------------------------------------------------------------------------
1291 // "button_release_event" from scrollbar
1292 //-----------------------------------------------------------------------------
1294 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
,
1295 GdkEventButton
*WXUNUSED(gdk_event
),
1299 // don't test here as we can release the mouse while being over
1300 // a different window then the slider
1302 // if (gdk_event->window != widget->slider) return FALSE;
1304 GtkScrolledWindow
*s_window
= GTK_SCROLLED_WINDOW(win
->m_widget
);
1306 if (widget
== GTK_RANGE(s_window
->vscrollbar
))
1307 gtk_signal_emit_by_name( GTK_OBJECT(win
->m_hAdjust
), "value_changed" );
1309 gtk_signal_emit_by_name( GTK_OBJECT(win
->m_vAdjust
), "value_changed" );
1311 win
->m_isScrolling
= FALSE
;
1312 g_blockEventsOnScroll
= FALSE
;
1317 //-----------------------------------------------------------------------------
1318 // "realize" from m_widget
1319 //-----------------------------------------------------------------------------
1321 /* we cannot set colours, fonts and cursors before the widget has
1322 been realized, so we do this directly after realization */
1325 gtk_window_realized_callback( GtkWidget
*widget
, wxWindow
*win
)
1327 if (win
->m_font
!= *wxSWISS_FONT
)
1329 wxFont
font( win
->m_font
);
1330 win
->m_font
= wxNullFont
;
1331 win
->SetFont( font
);
1334 if (win
->m_backgroundColour
!= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
))
1336 wxColour
bg( win
->m_backgroundColour
);
1337 win
->m_backgroundColour
= wxNullColour
;
1338 win
->SetBackgroundColour( bg
);
1341 if (win
->m_foregroundColour
!= *wxBLACK
)
1343 wxColour
fg( win
->m_foregroundColour
);
1344 win
->m_foregroundColour
= wxNullColour
;
1345 win
->SetForegroundColour( fg
);
1351 //-----------------------------------------------------------------------------
1352 // InsertChild for wxWindow.
1353 //-----------------------------------------------------------------------------
1355 /* Callback for wxWindow. This very strange beast has to be used because
1356 * C++ has no virtual methods in a constructor. We have to emulate a
1357 * virtual function here as wxNotebook requires a different way to insert
1358 * a child in it. I had opted for creating a wxNotebookPage window class
1359 * which would have made this superfluous (such in the MDI window system),
1360 * but no-one was listening to me... */
1362 static void wxInsertChildInWindow( wxWindow
* parent
, wxWindow
* child
)
1364 gtk_myfixed_put( GTK_MYFIXED(parent
->m_wxwindow
),
1365 GTK_WIDGET(child
->m_widget
),
1369 gtk_widget_set_usize( GTK_WIDGET(child
->m_widget
),
1373 if (parent
->m_windowStyle
& wxTAB_TRAVERSAL
)
1375 /* we now allow a window to get the focus as long as it
1376 doesn't have any children. */
1377 GTK_WIDGET_UNSET_FLAGS( parent
->m_wxwindow
, GTK_CAN_FOCUS
);
1381 //-----------------------------------------------------------------------------
1383 //-----------------------------------------------------------------------------
1385 wxWindow
* wxGetActiveWindow()
1387 return g_focusWindow
;
1390 //-----------------------------------------------------------------------------
1392 //-----------------------------------------------------------------------------
1394 IMPLEMENT_DYNAMIC_CLASS(wxWindow
,wxEvtHandler
)
1396 BEGIN_EVENT_TABLE(wxWindow
, wxEvtHandler
)
1397 EVT_SIZE(wxWindow::OnSize
)
1398 EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged
)
1399 EVT_INIT_DIALOG(wxWindow::OnInitDialog
)
1400 EVT_KEY_DOWN(wxWindow::OnKeyDown
)
1403 void wxWindow::Init()
1407 m_widget
= (GtkWidget
*) NULL
;
1408 m_wxwindow
= (GtkWidget
*) NULL
;
1409 m_parent
= (wxWindow
*) NULL
;
1410 m_children
.DeleteContents( FALSE
);
1423 m_eventHandler
= this;
1424 m_windowValidator
= (wxValidator
*) NULL
;
1428 m_cursor
= (wxCursor
*) NULL
;
1429 m_font
= *wxSWISS_FONT
;
1431 m_windowName
= "noname";
1433 m_constraints
= (wxLayoutConstraints
*) NULL
;
1434 m_constraintsInvolvedIn
= (wxList
*) NULL
;
1435 m_windowSizer
= (wxSizer
*) NULL
;
1436 m_sizerParent
= (wxWindow
*) NULL
;
1437 m_autoLayout
= FALSE
;
1441 m_needParent
= TRUE
;
1443 m_hasScrolling
= FALSE
;
1444 m_isScrolling
= FALSE
;
1445 m_hAdjust
= (GtkAdjustment
*) NULL
;
1446 m_vAdjust
= (GtkAdjustment
*) NULL
;
1447 m_oldHorizontalPos
= 0.0;
1448 m_oldVerticalPos
= 0.0;
1453 #if wxUSE_DRAG_AND_DROP
1454 m_dropTarget
= (wxDropTarget
*) NULL
;
1457 m_scrollGC
= (GdkGC
*) NULL
;
1458 m_widgetStyle
= (GtkStyle
*) NULL
;
1460 m_insertCallback
= wxInsertChildInWindow
;
1462 m_clientObject
= (wxClientData
*) NULL
;
1463 m_clientData
= NULL
;
1465 m_isStaticBox
= FALSE
;
1466 m_acceptsFocus
= FALSE
;
1469 m_toolTip
= (wxToolTip
*) NULL
;
1470 #endif // wxUSE_TOOLTIPS
1473 wxWindow::wxWindow()
1478 wxWindow::wxWindow( wxWindow
*parent
, wxWindowID id
,
1479 const wxPoint
&pos
, const wxSize
&size
,
1480 long style
, const wxString
&name
)
1484 Create( parent
, id
, pos
, size
, style
, name
);
1487 bool wxWindow::Create( wxWindow
*parent
, wxWindowID id
,
1488 const wxPoint
&pos
, const wxSize
&size
,
1489 long style
, const wxString
&name
)
1491 wxASSERT_MSG( m_isWindow
, _T("Init() must have been called before!") );
1493 PreCreation( parent
, id
, pos
, size
, style
, name
);
1495 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
1496 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
1498 GtkScrolledWindow
*s_window
= GTK_SCROLLED_WINDOW(m_widget
);
1500 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
1501 scroll_class
->scrollbar_spacing
= 0;
1503 gtk_scrolled_window_set_policy( s_window
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
1505 m_oldHorizontalPos
= 0.0;
1506 m_oldVerticalPos
= 0.0;
1508 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(s_window
->hscrollbar
) );
1509 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(s_window
->vscrollbar
) );
1511 m_wxwindow
= gtk_myfixed_new();
1512 gtk_widget_show( m_wxwindow
);
1514 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
1516 #if (GTK_MINOR_VERSION > 0)
1517 GtkMyFixed
*myfixed
= GTK_MYFIXED(m_wxwindow
);
1519 if (m_windowStyle
& wxRAISED_BORDER
)
1521 gtk_myfixed_set_shadow_type( myfixed
, GTK_SHADOW_OUT
);
1523 else if (m_windowStyle
& wxSUNKEN_BORDER
)
1525 gtk_myfixed_set_shadow_type( myfixed
, GTK_SHADOW_IN
);
1529 gtk_myfixed_set_shadow_type( myfixed
, GTK_SHADOW_NONE
);
1532 GtkViewport
*viewport
= GTK_VIEWPORT(s_window
->viewport
);
1534 if (m_windowStyle
& wxRAISED_BORDER
)
1536 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_OUT
);
1538 else if (m_windowStyle
& wxSUNKEN_BORDER
)
1540 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_IN
);
1544 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_NONE
);
1548 /* we always allow a window to get the focus as long as it
1549 doesn't have any children. */
1550 if (m_windowStyle
& wxTAB_TRAVERSAL
)
1552 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
1553 m_acceptsFocus
= FALSE
;
1557 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
1558 m_acceptsFocus
= TRUE
;
1561 /* grab the actual focus */
1562 gtk_widget_grab_focus( m_wxwindow
);
1564 #if (GTK_MINOR_VERSION == 0)
1565 // shut the viewport up
1566 gtk_viewport_set_hadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1567 gtk_viewport_set_vadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1570 // I _really_ don't want scrollbars in the beginning
1571 m_vAdjust
->lower
= 0.0;
1572 m_vAdjust
->upper
= 1.0;
1573 m_vAdjust
->value
= 0.0;
1574 m_vAdjust
->step_increment
= 1.0;
1575 m_vAdjust
->page_increment
= 1.0;
1576 m_vAdjust
->page_size
= 5.0;
1577 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
1578 m_hAdjust
->lower
= 0.0;
1579 m_hAdjust
->upper
= 1.0;
1580 m_hAdjust
->value
= 0.0;
1581 m_hAdjust
->step_increment
= 1.0;
1582 m_hAdjust
->page_increment
= 1.0;
1583 m_hAdjust
->page_size
= 5.0;
1584 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
1586 // these handlers block mouse events to any window during scrolling
1587 // such as motion events and prevent GTK and wxWindows from fighting
1588 // over where the slider should be
1590 gtk_signal_connect( GTK_OBJECT(s_window
->vscrollbar
), "button_press_event",
1591 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
1593 gtk_signal_connect( GTK_OBJECT(s_window
->hscrollbar
), "button_press_event",
1594 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
1596 gtk_signal_connect( GTK_OBJECT(s_window
->vscrollbar
), "button_release_event",
1597 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
1599 gtk_signal_connect( GTK_OBJECT(s_window
->hscrollbar
), "button_release_event",
1600 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
1602 // these handlers get notified when screen updates are required either when
1603 // scrolling or when the window size (and therefore scrollbar configuration)
1606 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
1607 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
1608 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
1609 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
1611 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "changed",
1612 (GtkSignalFunc
) gtk_window_hscroll_change_callback
, (gpointer
) this );
1613 gtk_signal_connect(GTK_OBJECT(m_vAdjust
), "changed",
1614 (GtkSignalFunc
) gtk_window_vscroll_change_callback
, (gpointer
) this );
1616 if (m_parent
) m_parent
->AddChild( this );
1618 (m_parent
->m_insertCallback
)( m_parent
, this );
1627 wxWindow::~wxWindow()
1631 #if wxUSE_DRAG_AND_DROP
1634 delete m_dropTarget
;
1635 m_dropTarget
= (wxDropTarget
*) NULL
;
1643 m_toolTip
= (wxToolTip
*) NULL
;
1645 #endif // wxUSE_TOOLTIPS
1647 if (m_widget
) Show( FALSE
);
1651 if (m_parent
) m_parent
->RemoveChild( this );
1653 if (m_widgetStyle
) gtk_style_unref( m_widgetStyle
);
1655 if (m_scrollGC
) gdk_gc_unref( m_scrollGC
);
1657 if (m_wxwindow
) gtk_widget_destroy( m_wxwindow
);
1659 if (m_widget
) gtk_widget_destroy( m_widget
);
1661 if (m_cursor
) delete m_cursor
;
1663 DeleteRelatedConstraints();
1666 /* This removes any dangling pointers to this window
1667 * in other windows' constraintsInvolvedIn lists. */
1668 UnsetConstraints(m_constraints
);
1669 delete m_constraints
;
1670 m_constraints
= (wxLayoutConstraints
*) NULL
;
1675 delete m_windowSizer
;
1676 m_windowSizer
= (wxSizer
*) NULL
;
1678 /* If this is a child of a sizer, remove self from parent */
1679 if (m_sizerParent
) m_sizerParent
->RemoveChild((wxWindow
*)this);
1681 /* Just in case the window has been Closed, but
1682 * we're then deleting immediately: don't leave
1683 * dangling pointers. */
1684 wxPendingDelete
.DeleteObject(this);
1686 /* Just in case we've loaded a top-level window via
1687 * wxWindow::LoadNativeDialog but we weren't a dialog
1689 wxTopLevelWindows
.DeleteObject(this);
1691 if (m_windowValidator
) delete m_windowValidator
;
1693 if (m_clientObject
) delete m_clientObject
;
1696 void wxWindow::PreCreation( wxWindow
*parent
, wxWindowID id
,
1697 const wxPoint
&pos
, const wxSize
&size
,
1698 long style
, const wxString
&name
)
1700 wxASSERT_MSG( (!m_needParent
) || (parent
), _T("Need complete parent.") );
1702 m_widget
= (GtkWidget
*) NULL
;
1703 m_wxwindow
= (GtkWidget
*) NULL
;
1706 m_children
.DeleteContents( FALSE
);
1709 if (m_width
== -1) m_width
= 20;
1711 if (m_height
== -1) m_height
= 20;
1716 if (!m_needParent
) /* some reasonable defaults */
1720 m_x
= (gdk_screen_width () - m_width
) / 2;
1721 if (m_x
< 10) m_x
= 10;
1725 m_y
= (gdk_screen_height () - m_height
) / 2;
1726 if (m_y
< 10) m_y
= 10;
1737 m_eventHandler
= this;
1739 m_windowId
= id
== -1 ? wxNewId() : id
;
1743 m_cursor
= new wxCursor( wxCURSOR_ARROW
);
1744 m_font
= *wxSWISS_FONT
;
1745 m_backgroundColour
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
1746 m_foregroundColour
= *wxBLACK
;
1747 m_windowStyle
= style
;
1748 m_windowName
= name
;
1750 m_constraints
= (wxLayoutConstraints
*) NULL
;
1751 m_constraintsInvolvedIn
= (wxList
*) NULL
;
1752 m_windowSizer
= (wxSizer
*) NULL
;
1753 m_sizerParent
= (wxWindow
*) NULL
;
1754 m_autoLayout
= FALSE
;
1756 m_hasScrolling
= FALSE
;
1757 m_isScrolling
= FALSE
;
1758 m_hAdjust
= (GtkAdjustment
*) NULL
;
1759 m_vAdjust
= (GtkAdjustment
*) NULL
;
1760 m_oldHorizontalPos
= 0.0;
1761 m_oldVerticalPos
= 0.0;
1766 #if wxUSE_DRAG_AND_DROP
1767 m_dropTarget
= (wxDropTarget
*) NULL
;
1770 m_windowValidator
= (wxValidator
*) NULL
;
1771 m_scrollGC
= (GdkGC
*) NULL
;
1772 m_widgetStyle
= (GtkStyle
*) NULL
;
1774 m_clientObject
= (wxClientData
*)NULL
;
1775 m_clientData
= NULL
;
1777 m_isStaticBox
= FALSE
;
1780 m_toolTip
= (wxToolTip
*) NULL
;
1781 #endif // wxUSE_TOOLTIPS
1784 void wxWindow::PostCreation()
1786 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
1790 /* these get reported to wxWindows -> wxPaintEvent */
1791 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
1792 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
1794 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
1795 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
1797 #if (GTK_MINOR_VERSION > 0)
1798 /* these are called when the "sunken" or "raised" borders are drawn */
1799 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
1800 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
1802 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
1803 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
1807 GtkWidget
*connect_widget
= GetConnectWidget();
1809 ConnectWidget( connect_widget
);
1811 /* we cannot set colours, fonts and cursors before the widget has
1812 been realized, so we do this directly after realization */
1813 gtk_signal_connect( GTK_OBJECT(connect_widget
), "realize",
1814 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
1819 void wxWindow::ConnectWidget( GtkWidget
*widget
)
1821 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
1822 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
1824 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
1825 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
1827 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
1828 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
1830 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
1831 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
1833 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
1834 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
1836 gtk_signal_connect( GTK_OBJECT(widget
), "focus_in_event",
1837 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
1839 gtk_signal_connect( GTK_OBJECT(widget
), "focus_out_event",
1840 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
1842 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
1843 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
1845 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
1846 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
1849 bool wxWindow::HasVMT()
1854 bool wxWindow::Close( bool force
)
1856 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
1858 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
1859 event
.SetEventObject(this);
1860 event
.SetCanVeto(!force
);
1862 /* return FALSE if window wasn't closed because the application vetoed the
1864 return GetEventHandler()->ProcessEvent(event
) && !event
.GetVeto();
1867 bool wxWindow::Destroy()
1869 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
1876 bool wxWindow::DestroyChildren()
1879 while ((node
= m_children
.First()) != (wxNode
*)NULL
)
1882 if ((child
= (wxWindow
*)node
->Data()) != (wxWindow
*)NULL
)
1885 if (m_children
.Member(child
)) delete node
;
1891 void wxWindow::PrepareDC( wxDC
&WXUNUSED(dc
) )
1893 // are we to set fonts here ?
1896 void wxWindow::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
1898 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
1899 wxASSERT_MSG( (m_parent
!= NULL
), _T("wxWindow::SetSize requires parent.\n") );
1901 if (m_resizing
) return; /* I don't like recursions */
1904 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
1906 /* don't set the size for children of wxNotebook, just take the values. */
1914 int old_width
= m_width
;
1915 int old_height
= m_height
;
1917 if ((sizeFlags
& wxSIZE_USE_EXISTING
) == wxSIZE_USE_EXISTING
)
1919 if (x
!= -1) m_x
= x
;
1920 if (y
!= -1) m_y
= y
;
1921 if (width
!= -1) m_width
= width
;
1922 if (height
!= -1) m_height
= height
;
1932 if ((sizeFlags
& wxSIZE_AUTO_WIDTH
) == wxSIZE_AUTO_WIDTH
)
1934 if (width
== -1) m_width
= 80;
1937 if ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) == wxSIZE_AUTO_HEIGHT
)
1939 if (height
== -1) m_height
= 26;
1942 if ((m_minWidth
!= -1) && (m_width
< m_minWidth
)) m_width
= m_minWidth
;
1943 if ((m_minHeight
!= -1) && (m_height
< m_minHeight
)) m_height
= m_minHeight
;
1944 if ((m_maxWidth
!= -1) && (m_width
> m_maxWidth
)) m_width
= m_maxWidth
;
1945 if ((m_maxHeight
!= -1) && (m_height
> m_maxHeight
)) m_height
= m_maxHeight
;
1947 if (GTK_WIDGET_HAS_DEFAULT(m_widget
))
1949 /* the default button has a border around it */
1952 gtk_myfixed_move( GTK_MYFIXED(m_parent
->m_wxwindow
), m_widget
, m_x
-border
, m_y
-border
);
1954 gtk_widget_set_usize( m_widget
, m_width
+2*border
, m_height
+2*border
);
1958 gtk_myfixed_move( GTK_MYFIXED(m_parent
->m_wxwindow
), m_widget
, m_x
, m_y
);
1960 if ((old_width
!= m_width
) || (old_height
!= m_height
))
1961 gtk_widget_set_usize( m_widget
, m_width
, m_height
);
1967 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
1968 event
.SetEventObject( this );
1969 GetEventHandler()->ProcessEvent( event
);
1974 void wxWindow::OnInternalIdle()
1979 void wxWindow::GetSize( int *width
, int *height
) const
1981 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
1983 if (width
) (*width
) = m_width
;
1984 if (height
) (*height
) = m_height
;
1987 void wxWindow::DoSetClientSize( int width
, int height
)
1989 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
1993 SetSize( width
, height
);
2000 if (!m_hasScrolling
)
2002 GtkStyleClass
*window_class
= m_wxwindow
->style
->klass
;
2004 if ((m_windowStyle
& wxRAISED_BORDER
) ||
2005 (m_windowStyle
& wxSUNKEN_BORDER
))
2007 dw
+= 2 * window_class
->xthickness
;
2008 dh
+= 2 * window_class
->ythickness
;
2013 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
2014 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
2016 #if (GTK_MINOR_VERSION == 0)
2017 GtkWidget
*viewport
= scroll_window
->viewport
;
2018 GtkStyleClass
*viewport_class
= viewport
->style
->klass
;
2020 if ((m_windowStyle
& wxRAISED_BORDER
) ||
2021 (m_windowStyle
& wxSUNKEN_BORDER
))
2023 dw
+= 2 * viewport_class
->xthickness
;
2024 dh
+= 2 * viewport_class
->ythickness
;
2029 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2030 GtkWidget *vscrollbar = scroll_window->vscrollbar;
2032 we use this instead: range.slider_width = 11 + 2*2pts edge
2035 if (scroll_window
->vscrollbar_visible
)
2037 dw
+= 15; /* dw += vscrollbar->allocation.width; */
2038 dw
+= scroll_class
->scrollbar_spacing
;
2041 if (scroll_window
->hscrollbar_visible
)
2043 dh
+= 15; /* dh += hscrollbar->allocation.height; */
2044 dw
+= scroll_class
->scrollbar_spacing
;
2048 SetSize( width
+dw
, height
+dh
);
2052 void wxWindow::GetClientSize( int *width
, int *height
) const
2054 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2058 if (width
) (*width
) = m_width
;
2059 if (height
) (*height
) = m_height
;
2066 if (!m_hasScrolling
)
2068 GtkStyleClass
*window_class
= m_wxwindow
->style
->klass
;
2070 if ((m_windowStyle
& wxRAISED_BORDER
) ||
2071 (m_windowStyle
& wxSUNKEN_BORDER
))
2073 dw
+= 2 * window_class
->xthickness
;
2074 dh
+= 2 * window_class
->ythickness
;
2079 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
2080 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
2082 #if (GTK_MINOR_VERSION == 0)
2083 GtkWidget
*viewport
= scroll_window
->viewport
;
2084 GtkStyleClass
*viewport_class
= viewport
->style
->klass
;
2086 if ((m_windowStyle
& wxRAISED_BORDER
) ||
2087 (m_windowStyle
& wxSUNKEN_BORDER
))
2089 dw
+= 2 * viewport_class
->xthickness
;
2090 dh
+= 2 * viewport_class
->ythickness
;
2094 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2095 GtkWidget *vscrollbar = scroll_window->vscrollbar;
2097 we use this instead: range.slider_width = 11 + 2*2pts edge
2100 if (scroll_window
->vscrollbar_visible
)
2102 dw
+= 15; /* dw += vscrollbar->allocation.width; */
2103 dw
+= scroll_class
->scrollbar_spacing
;
2106 if (scroll_window
->hscrollbar_visible
)
2108 dh
+= 15; /* dh += hscrollbar->allocation.height; */
2109 dh
+= scroll_class
->scrollbar_spacing
;
2113 if (width
) (*width
) = m_width
- dw
;
2114 if (height
) (*height
) = m_height
- dh
;
2118 void wxWindow::GetPosition( int *x
, int *y
) const
2120 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2126 void wxWindow::ClientToScreen( int *x
, int *y
)
2128 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2130 if (!m_widget
->window
) return;
2132 GdkWindow
*source
= (GdkWindow
*) NULL
;
2134 source
= m_wxwindow
->window
;
2136 source
= m_widget
->window
;
2140 gdk_window_get_origin( source
, &org_x
, &org_y
);
2144 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2146 org_x
+= m_widget
->allocation
.x
;
2147 org_y
+= m_widget
->allocation
.y
;
2155 void wxWindow::ScreenToClient( int *x
, int *y
)
2157 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2159 if (!m_widget
->window
) return;
2161 GdkWindow
*source
= (GdkWindow
*) NULL
;
2163 source
= m_wxwindow
->window
;
2165 source
= m_widget
->window
;
2169 gdk_window_get_origin( source
, &org_x
, &org_y
);
2173 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2175 org_x
+= m_widget
->allocation
.x
;
2176 org_y
+= m_widget
->allocation
.y
;
2184 void wxWindow::Centre( int direction
)
2186 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2195 m_parent
->GetSize( &p_w
, &p_h
);
2196 if (direction
& wxHORIZONTAL
== wxHORIZONTAL
) x
= (p_w
- m_width
) / 2;
2197 if (direction
& wxVERTICAL
== wxVERTICAL
) y
= (p_h
- m_height
) / 2;
2201 if (direction
& wxHORIZONTAL
== wxHORIZONTAL
) x
= (gdk_screen_width () - m_width
) / 2;
2202 if (direction
& wxVERTICAL
== wxVERTICAL
) y
= (gdk_screen_height () - m_height
) / 2;
2208 void wxWindow::Fit()
2210 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2214 wxNode
*node
= m_children
.First();
2217 wxWindow
*win
= (wxWindow
*)node
->Data();
2219 win
->GetPosition(&wx
, &wy
);
2220 win
->GetSize(&ww
, &wh
);
2221 if (wx
+ ww
> maxX
) maxX
= wx
+ ww
;
2222 if (wy
+ wh
> maxY
) maxY
= wy
+ wh
;
2224 node
= node
->Next();
2227 SetClientSize(maxX
+ 7, maxY
+ 14);
2230 void wxWindow::SetSizeHints( int minW
, int minH
, int maxW
, int maxH
, int WXUNUSED(incW
), int WXUNUSED(incH
) )
2232 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2240 void wxWindow::OnSize( wxSizeEvent
&WXUNUSED(event
) )
2242 // if (GetAutoLayout()) Layout();
2245 bool wxWindow::Show( bool show
)
2247 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, _T("invalid window") );
2249 if (show
== m_isShown
) return TRUE
;
2252 gtk_widget_show( m_widget
);
2254 gtk_widget_hide( m_widget
);
2261 void wxWindow::Enable( bool enable
)
2263 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2265 m_isEnabled
= enable
;
2267 gtk_widget_set_sensitive( m_widget
, enable
);
2268 if (m_wxwindow
) gtk_widget_set_sensitive( m_wxwindow
, enable
);
2271 int wxWindow::GetCharHeight() const
2273 wxCHECK_MSG( (m_widget
!= NULL
), 12, _T("invalid window") );
2275 wxCHECK_MSG( m_font
.Ok(), 12, _T("invalid font") );
2277 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
2279 return font
->ascent
+ font
->descent
;
2282 int wxWindow::GetCharWidth() const
2284 wxCHECK_MSG( (m_widget
!= NULL
), 8, _T("invalid window") );
2286 wxCHECK_MSG( m_font
.Ok(), 8, _T("invalid font") );
2288 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
2290 return gdk_string_width( font
, "H" );
2293 void wxWindow::GetTextExtent( const wxString
& string
, int *x
, int *y
,
2294 int *descent
, int *externalLeading
, const wxFont
*theFont
, bool WXUNUSED(use16
) ) const
2296 wxFont fontToUse
= m_font
;
2297 if (theFont
) fontToUse
= *theFont
;
2299 wxCHECK_RET( fontToUse
.Ok(), _T("invalid font") );
2301 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
2302 if (x
) (*x
) = gdk_string_width( font
, string
.mbc_str() );
2303 if (y
) (*y
) = font
->ascent
+ font
->descent
;
2304 if (descent
) (*descent
) = font
->descent
;
2305 if (externalLeading
) (*externalLeading
) = 0; // ??
2308 void wxWindow::MakeModal( bool modal
)
2312 // Disable all other windows
2313 if (this->IsKindOf(CLASSINFO(wxDialog
)) || this->IsKindOf(CLASSINFO(wxFrame
)))
2315 wxNode
*node
= wxTopLevelWindows
.First();
2318 wxWindow
*win
= (wxWindow
*)node
->Data();
2319 if (win
!= this) win
->Enable(!modal
);
2321 node
= node
->Next();
2326 void wxWindow::OnKeyDown( wxKeyEvent
&event
)
2328 event
.SetEventType( wxEVT_CHAR
);
2330 if (!GetEventHandler()->ProcessEvent( event
))
2336 void wxWindow::SetFocus()
2338 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2340 GtkWidget
*connect_widget
= GetConnectWidget();
2343 if (GTK_WIDGET_CAN_FOCUS(connect_widget
) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ )
2345 gtk_widget_grab_focus (connect_widget
);
2347 else if (GTK_IS_CONTAINER(connect_widget
))
2349 gtk_container_focus( GTK_CONTAINER(connect_widget
), GTK_DIR_TAB_FORWARD
);
2357 wxWindow
*wxWindow::FindFocus()
2359 return g_focusWindow
;
2362 bool wxWindow::AcceptsFocus() const
2364 return IsEnabled() && IsShown() && m_acceptsFocus
;
2367 void wxWindow::AddChild( wxWindow
*child
)
2369 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2370 wxCHECK_RET( (child
!= NULL
), _T("invalid child") );
2372 m_children
.Append( child
);
2375 wxWindow
*wxWindow::ReParent( wxWindow
*newParent
)
2377 wxCHECK_MSG( (m_widget
!= NULL
), (wxWindow
*) NULL
, _T("invalid window") );
2379 wxWindow
*oldParent
= GetParent();
2381 if (oldParent
) oldParent
->RemoveChild( this );
2383 gtk_widget_unparent( m_widget
);
2387 newParent
->AddChild( this );
2388 (newParent
->m_insertCallback
)( newParent
, this );
2394 void wxWindow::RemoveChild( wxWindow
*child
)
2396 m_children
.DeleteObject( child
);
2397 child
->m_parent
= (wxWindow
*) NULL
;
2400 void wxWindow::SetReturnCode( int retCode
)
2402 m_retCode
= retCode
;
2405 int wxWindow::GetReturnCode()
2410 void wxWindow::Raise()
2412 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2414 if (!m_widget
->window
) return;
2416 if (m_widget
) gdk_window_raise( m_widget
->window
);
2419 void wxWindow::Lower()
2421 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2423 if (!m_widget
->window
) return;
2425 if (m_widget
) gdk_window_lower( m_widget
->window
);
2428 wxEvtHandler
*wxWindow::GetEventHandler() const
2430 return m_eventHandler
;
2433 void wxWindow::SetEventHandler( wxEvtHandler
*handler
)
2435 m_eventHandler
= handler
;
2438 void wxWindow::PushEventHandler(wxEvtHandler
*handler
)
2440 handler
->SetNextHandler(GetEventHandler());
2441 SetEventHandler(handler
);
2444 wxEvtHandler
*wxWindow::PopEventHandler(bool deleteHandler
)
2446 if (GetEventHandler())
2448 wxEvtHandler
*handlerA
= GetEventHandler();
2449 wxEvtHandler
*handlerB
= handlerA
->GetNextHandler();
2450 handlerA
->SetNextHandler((wxEvtHandler
*) NULL
);
2451 SetEventHandler(handlerB
);
2455 return (wxEvtHandler
*) NULL
;
2461 return (wxEvtHandler
*) NULL
;
2464 wxValidator
*wxWindow::GetValidator()
2466 return m_windowValidator
;
2469 void wxWindow::SetValidator( const wxValidator
& validator
)
2471 if (m_windowValidator
) delete m_windowValidator
;
2472 m_windowValidator
= validator
.Clone();
2473 if (m_windowValidator
) m_windowValidator
->SetWindow(this);
2476 void wxWindow::SetClientObject( wxClientData
*data
)
2478 if (m_clientObject
) delete m_clientObject
;
2479 m_clientObject
= data
;
2482 wxClientData
*wxWindow::GetClientObject()
2484 return m_clientObject
;
2487 void wxWindow::SetClientData( void *data
)
2489 m_clientData
= data
;
2492 void *wxWindow::GetClientData()
2494 return m_clientData
;
2497 bool wxWindow::IsBeingDeleted()
2502 void wxWindow::SetId( wxWindowID id
)
2507 wxWindowID
wxWindow::GetId() const
2512 void wxWindow::SetCursor( const wxCursor
&cursor
)
2514 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2518 if (cursor
== *m_cursor
) return;
2523 *m_cursor
= *wxSTANDARD_CURSOR
;
2526 if (!m_widget
->window
) return;
2528 gdk_window_set_cursor( m_widget
->window
, m_cursor
->GetCursor() );
2530 if ((m_wxwindow
) && (m_wxwindow
->window
))
2531 gdk_window_set_cursor( m_wxwindow
->window
, m_cursor
->GetCursor() );
2534 void wxWindow::WarpPointer( int WXUNUSED(x
), int WXUNUSED(y
) )
2539 void wxWindow::Refresh( bool eraseBackground
, const wxRect
*rect
)
2541 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2543 if (!m_widget
->window
) return;
2545 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
2549 gdk_window_clear_area( m_wxwindow
->window
,
2551 rect
->width
, rect
->height
);
2555 gdk_window_clear( m_wxwindow
->window
);
2562 gtk_widget_draw( m_wxwindow
, (GdkRectangle
*) NULL
);
2564 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
2568 GdkRectangle gdk_rect
;
2569 gdk_rect
.x
= rect
->x
;
2570 gdk_rect
.y
= rect
->y
;
2571 gdk_rect
.width
= rect
->width
;
2572 gdk_rect
.height
= rect
->height
;
2575 gtk_widget_draw( m_wxwindow
, &gdk_rect
);
2577 gtk_widget_draw( m_widget
, &gdk_rect
);
2581 wxRegion
wxWindow::GetUpdateRegion() const
2583 return m_updateRegion
;
2586 bool wxWindow::IsExposed( int x
, int y
) const
2588 return (m_updateRegion
.Contains( x
, y
) != wxOutRegion
);
2591 bool wxWindow::IsExposed( int x
, int y
, int w
, int h
) const
2593 return (m_updateRegion
.Contains( x
, y
, w
, h
) != wxOutRegion
);
2596 bool wxWindow::IsExposed( const wxPoint
& pt
) const
2598 return (m_updateRegion
.Contains( pt
.x
, pt
.y
) != wxOutRegion
);
2601 bool wxWindow::IsExposed( const wxRect
& rect
) const
2603 return (m_updateRegion
.Contains( rect
.x
, rect
.y
, rect
.width
, rect
.height
) != wxOutRegion
);
2606 void wxWindow::Clear()
2608 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2610 if (!m_widget
->window
) return;
2612 if (m_wxwindow
&& m_wxwindow
->window
)
2614 gdk_window_clear( m_wxwindow
->window
);
2619 void wxWindow::SetToolTip( const wxString
&tip
)
2623 m_toolTip
->SetTip( tip
);
2627 SetToolTip( new wxToolTip( tip
) );
2630 // setting empty tooltip text does not remove the tooltip any more for
2631 // wxMSW compatibility - use SetToolTip((wxToolTip *)NULL) for this
2634 void wxWindow::SetToolTip( wxToolTip
*tip
)
2638 m_toolTip
->SetTip( (char*) NULL
);
2645 m_toolTip
->Apply( this );
2648 void wxWindow::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
2650 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxConv_current
->cWX2MB(tip
), (gchar
*) NULL
);
2652 #endif // wxUSE_TOOLTIPS
2654 wxColour
wxWindow::GetBackgroundColour() const
2656 return m_backgroundColour
;
2659 void wxWindow::SetBackgroundColour( const wxColour
&colour
)
2661 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2663 if (m_backgroundColour
== colour
) return;
2665 m_backgroundColour
= colour
;
2666 if (!m_backgroundColour
.Ok()) return;
2668 GtkWidget
*connect_widget
= GetConnectWidget();
2669 if (!connect_widget
->window
) return;
2671 if (m_wxwindow
&& m_wxwindow
->window
)
2673 /* wxMSW doesn't clear the window here. I don't do that
2674 either to provide compatibility. call Clear() to do
2677 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( m_wxwindow
->window
) );
2678 gdk_window_set_background( m_wxwindow
->window
, m_backgroundColour
.GetColor() );
2681 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
2683 if (sysbg
.Red() == colour
.Red() &&
2684 sysbg
.Green() == colour
.Green() &&
2685 sysbg
.Blue() == colour
.Blue())
2687 m_backgroundColour
= wxNullColour
;
2689 m_backgroundColour
= sysbg
;
2697 wxColour
wxWindow::GetForegroundColour() const
2699 return m_foregroundColour
;
2702 void wxWindow::SetForegroundColour( const wxColour
&colour
)
2704 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2706 if (m_foregroundColour
== colour
) return;
2708 m_foregroundColour
= colour
;
2709 if (!m_foregroundColour
.Ok()) return;
2711 if (!m_widget
->window
) return;
2713 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
2714 if (sysbg
.Red() == colour
.Red() &&
2715 sysbg
.Green() == colour
.Green() &&
2716 sysbg
.Blue() == colour
.Blue())
2718 m_backgroundColour
= wxNullColour
;
2720 m_backgroundColour
= sysbg
;
2728 GtkStyle
*wxWindow::GetWidgetStyle()
2730 if (m_widgetStyle
) gtk_style_unref( m_widgetStyle
);
2734 gtk_widget_get_style( m_widget
) );
2736 return m_widgetStyle
;
2739 void wxWindow::SetWidgetStyle()
2741 GtkStyle
*style
= GetWidgetStyle();
2743 gdk_font_unref( style
->font
);
2744 style
->font
= gdk_font_ref( m_font
.GetInternalFont( 1.0 ) );
2746 if (m_foregroundColour
.Ok())
2748 m_foregroundColour
.CalcPixel( gdk_window_get_colormap( m_widget
->window
) );
2749 style
->fg
[GTK_STATE_NORMAL
] = *m_foregroundColour
.GetColor();
2750 style
->fg
[GTK_STATE_PRELIGHT
] = *m_foregroundColour
.GetColor();
2751 style
->fg
[GTK_STATE_ACTIVE
] = *m_foregroundColour
.GetColor();
2754 if (m_backgroundColour
.Ok())
2756 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( m_widget
->window
) );
2757 style
->bg
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
2758 style
->base
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
2759 style
->bg
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
2760 style
->base
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
2761 style
->bg
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
2762 style
->base
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
2763 style
->bg
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
2764 style
->base
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
2768 void wxWindow::ApplyWidgetStyle()
2772 bool wxWindow::Validate()
2774 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2776 wxNode
*node
= m_children
.First();
2779 wxWindow
*child
= (wxWindow
*)node
->Data();
2780 if (child
->GetValidator() && /* child->GetValidator()->Ok() && */ !child
->GetValidator()->Validate(this))
2784 node
= node
->Next();
2789 bool wxWindow::TransferDataToWindow()
2791 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2793 wxNode
*node
= m_children
.First();
2796 wxWindow
*child
= (wxWindow
*)node
->Data();
2797 if (child
->GetValidator() && /* child->GetValidator()->Ok() && */
2798 !child
->GetValidator()->TransferToWindow() )
2800 wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK
|wxICON_EXCLAMATION
);
2803 node
= node
->Next();
2808 bool wxWindow::TransferDataFromWindow()
2810 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2812 wxNode
*node
= m_children
.First();
2815 wxWindow
*child
= (wxWindow
*)node
->Data();
2816 if ( child
->GetValidator() && /* child->GetValidator()->Ok() && */ !child
->GetValidator()->TransferFromWindow() )
2820 node
= node
->Next();
2825 void wxWindow::SetAcceleratorTable( const wxAcceleratorTable
& accel
)
2827 m_acceleratorTable
= accel
;
2830 void wxWindow::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2832 TransferDataToWindow();
2835 void wxWindow::InitDialog()
2837 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2839 wxInitDialogEvent
event(GetId());
2840 event
.SetEventObject( this );
2841 GetEventHandler()->ProcessEvent(event
);
2844 static void SetInvokingWindow( wxMenu
*menu
, wxWindow
*win
)
2846 menu
->SetInvokingWindow( win
);
2847 wxNode
*node
= menu
->GetItems().First();
2850 wxMenuItem
*menuitem
= (wxMenuItem
*)node
->Data();
2851 if (menuitem
->IsSubMenu())
2853 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
2855 node
= node
->Next();
2859 static gint gs_pop_x
= 0;
2860 static gint gs_pop_y
= 0;
2862 static void pop_pos_callback( GtkMenu
*menu
, gint
*x
, gint
*y
, wxWindow
*win
)
2864 win
->ClientToScreen( &gs_pop_x
, &gs_pop_y
);
2869 bool wxWindow::PopupMenu( wxMenu
*menu
, int x
, int y
)
2871 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2873 wxCHECK_MSG( menu
!= NULL
, FALSE
, _T("invalid popup-menu") );
2875 SetInvokingWindow( menu
, this );
2883 GTK_MENU(menu
->m_menu
),
2884 (GtkWidget
*) NULL
, // parent menu shell
2885 (GtkWidget
*) NULL
, // parent menu item
2886 (GtkMenuPositionFunc
) pop_pos_callback
,
2887 (gpointer
) this, // client data
2888 0, // button used to activate it
2889 0 //gs_timeLastClick // the time of activation
2894 #if wxUSE_DRAG_AND_DROP
2896 void wxWindow::SetDropTarget( wxDropTarget
*dropTarget
)
2898 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2900 GtkWidget
*dnd_widget
= GetConnectWidget();
2902 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
2904 if (m_dropTarget
) delete m_dropTarget
;
2905 m_dropTarget
= dropTarget
;
2907 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
2910 wxDropTarget
*wxWindow::GetDropTarget() const
2912 return m_dropTarget
;
2917 GtkWidget
* wxWindow::GetConnectWidget()
2919 GtkWidget
*connect_widget
= m_widget
;
2920 if (m_wxwindow
) connect_widget
= m_wxwindow
;
2922 return connect_widget
;
2925 bool wxWindow::IsOwnGtkWindow( GdkWindow
*window
)
2927 if (m_wxwindow
) return (window
== m_wxwindow
->window
);
2928 return (window
== m_widget
->window
);
2931 void wxWindow::SetFont( const wxFont
&font
)
2933 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2935 if (m_font
== font
) return;
2937 if (((wxFont
*)&font
)->Ok())
2940 m_font
= *wxSWISS_FONT
;
2942 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
2943 if (sysbg
.Red() == m_backgroundColour
.Red() &&
2944 sysbg
.Green() == m_backgroundColour
.Green() &&
2945 sysbg
.Blue() == m_backgroundColour
.Blue())
2947 m_backgroundColour
= wxNullColour
;
2949 m_backgroundColour
= sysbg
;
2957 void wxWindow::SetWindowStyleFlag( long flag
)
2959 m_windowStyle
= flag
;
2962 long wxWindow::GetWindowStyleFlag() const
2964 return m_windowStyle
;
2967 void wxWindow::CaptureMouse()
2969 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2971 wxCHECK_RET( g_capturing
== FALSE
, _T("CaptureMouse called twice") );
2973 if (!m_widget
->window
) return;
2975 GtkWidget
*connect_widget
= GetConnectWidget();
2976 gtk_grab_add( connect_widget
);
2977 gdk_pointer_grab( connect_widget
->window
, FALSE
,
2979 (GDK_BUTTON_PRESS_MASK
|
2980 GDK_BUTTON_RELEASE_MASK
|
2981 GDK_POINTER_MOTION_MASK
),
2988 void wxWindow::ReleaseMouse()
2990 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2992 wxCHECK_RET( g_capturing
== TRUE
, _T("ReleaseMouse called twice") );
2994 if (!m_widget
->window
) return;
2996 GtkWidget
*connect_widget
= GetConnectWidget();
2997 gtk_grab_remove( connect_widget
);
2998 gdk_pointer_ungrab ( GDK_CURRENT_TIME
);
2999 g_capturing
= FALSE
;
3002 void wxWindow::SetTitle( const wxString
&WXUNUSED(title
) )
3006 wxString
wxWindow::GetTitle() const
3008 return (wxString
&)m_windowName
;
3011 wxString
wxWindow::GetLabel() const
3016 void wxWindow::SetName( const wxString
&name
)
3018 m_windowName
= name
;
3021 wxString
wxWindow::GetName() const
3023 return (wxString
&)m_windowName
;
3026 bool wxWindow::IsShown() const
3031 bool wxWindow::IsRetained()
3036 wxWindow
*wxWindow::FindWindow( long id
)
3038 if (id
== m_windowId
) return this;
3039 wxNode
*node
= m_children
.First();
3042 wxWindow
*child
= (wxWindow
*)node
->Data();
3043 wxWindow
*res
= child
->FindWindow( id
);
3044 if (res
) return res
;
3045 node
= node
->Next();
3047 return (wxWindow
*) NULL
;
3050 wxWindow
*wxWindow::FindWindow( const wxString
& name
)
3052 if (name
== m_windowName
) return this;
3053 wxNode
*node
= m_children
.First();
3056 wxWindow
*child
= (wxWindow
*)node
->Data();
3057 wxWindow
*res
= child
->FindWindow( name
);
3058 if (res
) return res
;
3059 node
= node
->Next();
3061 return (wxWindow
*) NULL
;
3064 void wxWindow::SetScrollbar( int orient
, int pos
, int thumbVisible
,
3065 int range
, bool refresh
)
3067 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
3069 wxCHECK_RET( m_wxwindow
!= NULL
, _T("window needs client area for scrolling") );
3071 m_hasScrolling
= TRUE
;
3073 if (orient
== wxHORIZONTAL
)
3075 float fpos
= (float)pos
;
3076 float frange
= (float)range
;
3077 float fthumb
= (float)thumbVisible
;
3078 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
3079 if (fpos
< 0.0) fpos
= 0.0;
3081 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
3082 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
3084 SetScrollPos( orient
, pos
, refresh
);
3088 m_oldHorizontalPos
= fpos
;
3090 m_hAdjust
->lower
= 0.0;
3091 m_hAdjust
->upper
= frange
;
3092 m_hAdjust
->value
= fpos
;
3093 m_hAdjust
->step_increment
= 1.0;
3094 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
3095 m_hAdjust
->page_size
= fthumb
;
3099 float fpos
= (float)pos
;
3100 float frange
= (float)range
;
3101 float fthumb
= (float)thumbVisible
;
3102 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
3103 if (fpos
< 0.0) fpos
= 0.0;
3105 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
3106 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
3108 SetScrollPos( orient
, pos
, refresh
);
3112 m_oldVerticalPos
= fpos
;
3114 m_vAdjust
->lower
= 0.0;
3115 m_vAdjust
->upper
= frange
;
3116 m_vAdjust
->value
= fpos
;
3117 m_vAdjust
->step_increment
= 1.0;
3118 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
3119 m_vAdjust
->page_size
= fthumb
;
3124 if (orient
== wxHORIZONTAL
)
3125 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
3127 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
3129 gtk_widget_set_usize( m_widget
, m_width
, m_height
);
3133 void wxWindow::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
3135 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
3137 wxCHECK_RET( m_wxwindow
!= NULL
, _T("window needs client area for scrolling") );
3139 if (orient
== wxHORIZONTAL
)
3141 float fpos
= (float)pos
;
3142 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
3143 if (fpos
< 0.0) fpos
= 0.0;
3144 m_oldHorizontalPos
= fpos
;
3146 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
3147 m_hAdjust
->value
= fpos
;
3151 float fpos
= (float)pos
;
3152 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
3153 if (fpos
< 0.0) fpos
= 0.0;
3154 m_oldVerticalPos
= fpos
;
3156 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
3157 m_vAdjust
->value
= fpos
;
3162 if (m_wxwindow
->window
)
3164 if (orient
== wxHORIZONTAL
)
3165 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
3167 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
3172 int wxWindow::GetScrollThumb( int orient
) const
3174 wxCHECK_MSG( m_widget
!= NULL
, 0, _T("invalid window") );
3176 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, _T("window needs client area for scrolling") );
3178 if (orient
== wxHORIZONTAL
)
3179 return (int)(m_hAdjust
->page_size
+0.5);
3181 return (int)(m_vAdjust
->page_size
+0.5);
3184 int wxWindow::GetScrollPos( int orient
) const
3186 wxCHECK_MSG( m_widget
!= NULL
, 0, _T("invalid window") );
3188 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, _T("window needs client area for scrolling") );
3190 if (orient
== wxHORIZONTAL
)
3191 return (int)(m_hAdjust
->value
+0.5);
3193 return (int)(m_vAdjust
->value
+0.5);
3196 int wxWindow::GetScrollRange( int orient
) const
3198 wxCHECK_MSG( m_widget
!= NULL
, 0, _T("invalid window") );
3200 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, _T("window needs client area for scrolling") );
3202 if (orient
== wxHORIZONTAL
)
3203 return (int)(m_hAdjust
->upper
+0.5);
3205 return (int)(m_vAdjust
->upper
+0.5);
3208 void wxWindow::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
3210 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
3212 wxCHECK_RET( m_wxwindow
!= NULL
, _T("window needs client area for scrolling") );
3214 wxNode
*node
= m_children
.First();
3217 wxWindow
*child
= (wxWindow
*) node
->Data();
3218 child
->Move( child
->m_x
+ dx
, child
->m_y
+ dy
);
3219 node
= node
->Next();
3224 GetClientSize( &cw
, &ch
);
3226 int w
= cw
- abs(dx
);
3227 int h
= ch
- abs(dy
);
3228 if ((h
< 0) || (w
< 0))
3235 if (dx
< 0) s_x
= -dx
;
3236 if (dy
< 0) s_y
= -dy
;
3239 if (dx
> 0) d_x
= dx
;
3240 if (dy
> 0) d_y
= dy
;
3244 m_scrollGC
= gdk_gc_new( m_wxwindow
->window
);
3245 gdk_gc_set_exposures( m_scrollGC
, TRUE
);
3248 gdk_window_copy_area( m_wxwindow
->window
, m_scrollGC
, d_x
, d_y
,
3249 m_wxwindow
->window
, s_x
, s_y
, w
, h
);
3252 if (dx
< 0) rect
.x
= cw
+dx
; else rect
.x
= 0;
3253 if (dy
< 0) rect
.y
= ch
+dy
; else rect
.y
= 0;
3254 if (dy
!= 0) rect
.width
= cw
; else rect
.width
= abs(dx
);
3255 if (dx
!= 0) rect
.height
= ch
; else rect
.height
= abs(dy
);
3257 Refresh( TRUE
, &rect
);
3260 //-------------------------------------------------------------------------------------
3262 //-------------------------------------------------------------------------------------
3264 wxLayoutConstraints
*wxWindow::GetConstraints() const
3266 return m_constraints
;
3269 void wxWindow::SetConstraints( wxLayoutConstraints
*constraints
)
3273 UnsetConstraints(m_constraints
);
3274 delete m_constraints
;
3276 m_constraints
= constraints
;
3279 // Make sure other windows know they're part of a 'meaningful relationship'
3280 if (m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this))
3281 m_constraints
->left
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3282 if (m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this))
3283 m_constraints
->top
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3284 if (m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this))
3285 m_constraints
->right
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3286 if (m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this))
3287 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3288 if (m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this))
3289 m_constraints
->width
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3290 if (m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this))
3291 m_constraints
->height
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3292 if (m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this))
3293 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3294 if (m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this))
3295 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3301 void wxWindow::SetAutoLayout( bool autoLayout
)
3303 m_autoLayout
= autoLayout
;
3306 bool wxWindow::GetAutoLayout() const
3308 return m_autoLayout
;
3311 wxSizer
*wxWindow::GetSizer() const
3313 return m_windowSizer
;
3316 void wxWindow::SetSizerParent( wxWindow
*win
)
3318 m_sizerParent
= win
;
3321 wxWindow
*wxWindow::GetSizerParent() const
3323 return m_sizerParent
;
3326 // This removes any dangling pointers to this window
3327 // in other windows' constraintsInvolvedIn lists.
3328 void wxWindow::UnsetConstraints(wxLayoutConstraints
*c
)
3332 if (c
->left
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this))
3333 c
->left
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3334 if (c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this))
3335 c
->top
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3336 if (c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this))
3337 c
->right
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3338 if (c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this))
3339 c
->bottom
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3340 if (c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this))
3341 c
->width
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3342 if (c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this))
3343 c
->height
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3344 if (c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this))
3345 c
->centreX
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3346 if (c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this))
3347 c
->centreY
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3351 // Back-pointer to other windows we're involved with, so if we delete
3352 // this window, we must delete any constraints we're involved with.
3353 void wxWindow::AddConstraintReference(wxWindow
*otherWin
)
3355 if (!m_constraintsInvolvedIn
)
3356 m_constraintsInvolvedIn
= new wxList
;
3357 if (!m_constraintsInvolvedIn
->Member(otherWin
))
3358 m_constraintsInvolvedIn
->Append(otherWin
);
3361 // REMOVE back-pointer to other windows we're involved with.
3362 void wxWindow::RemoveConstraintReference(wxWindow
*otherWin
)
3364 if (m_constraintsInvolvedIn
)
3365 m_constraintsInvolvedIn
->DeleteObject(otherWin
);
3368 // Reset any constraints that mention this window
3369 void wxWindow::DeleteRelatedConstraints()
3371 if (m_constraintsInvolvedIn
)
3373 wxNode
*node
= m_constraintsInvolvedIn
->First();
3376 wxWindow
*win
= (wxWindow
*)node
->Data();
3377 wxNode
*next
= node
->Next();
3378 wxLayoutConstraints
*constr
= win
->GetConstraints();
3380 // Reset any constraints involving this window
3383 constr
->left
.ResetIfWin((wxWindow
*)this);
3384 constr
->top
.ResetIfWin((wxWindow
*)this);
3385 constr
->right
.ResetIfWin((wxWindow
*)this);
3386 constr
->bottom
.ResetIfWin((wxWindow
*)this);
3387 constr
->width
.ResetIfWin((wxWindow
*)this);
3388 constr
->height
.ResetIfWin((wxWindow
*)this);
3389 constr
->centreX
.ResetIfWin((wxWindow
*)this);
3390 constr
->centreY
.ResetIfWin((wxWindow
*)this);
3395 delete m_constraintsInvolvedIn
;
3396 m_constraintsInvolvedIn
= (wxList
*) NULL
;
3400 void wxWindow::SetSizer(wxSizer
*sizer
)
3402 m_windowSizer
= sizer
;
3404 sizer
->SetSizerParent((wxWindow
*)this);
3411 bool wxWindow::Layout()
3413 if (GetConstraints())
3416 GetClientSize(&w
, &h
);
3417 GetConstraints()->width
.SetValue(w
);
3418 GetConstraints()->height
.SetValue(h
);
3421 // If top level (one sizer), evaluate the sizer's constraints.
3425 GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated
3426 GetSizer()->LayoutPhase1(&noChanges
);
3427 GetSizer()->LayoutPhase2(&noChanges
);
3428 GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
3433 // Otherwise, evaluate child constraints
3434 ResetConstraints(); // Mark all constraints as unevaluated
3435 DoPhase(1); // Just one phase need if no sizers involved
3437 SetConstraintSizes(); // Recursively set the real window sizes
3443 // Do a phase of evaluating constraints:
3444 // the default behaviour. wxSizers may do a similar
3445 // thing, but also impose their own 'constraints'
3446 // and order the evaluation differently.
3447 bool wxWindow::LayoutPhase1(int *noChanges
)
3449 wxLayoutConstraints
*constr
= GetConstraints();
3452 return constr
->SatisfyConstraints((wxWindow
*)this, noChanges
);
3458 bool wxWindow::LayoutPhase2(int *noChanges
)
3468 // Do a phase of evaluating child constraints
3469 bool wxWindow::DoPhase(int phase
)
3471 int noIterations
= 0;
3472 int maxIterations
= 500;
3476 while ((noChanges
> 0) && (noIterations
< maxIterations
))
3480 wxNode
*node
= m_children
.First();
3483 wxWindow
*child
= (wxWindow
*)node
->Data();
3484 if (!child
->IsKindOf(CLASSINFO(wxFrame
)) && !child
->IsKindOf(CLASSINFO(wxDialog
)))
3486 wxLayoutConstraints
*constr
= child
->GetConstraints();
3489 if (succeeded
.Member(child
))
3494 int tempNoChanges
= 0;
3495 bool success
= ( (phase
== 1) ? child
->LayoutPhase1(&tempNoChanges
) : child
->LayoutPhase2(&tempNoChanges
) ) ;
3496 noChanges
+= tempNoChanges
;
3499 succeeded
.Append(child
);
3504 node
= node
->Next();
3511 void wxWindow::ResetConstraints()
3513 wxLayoutConstraints
*constr
= GetConstraints();
3516 constr
->left
.SetDone(FALSE
);
3517 constr
->top
.SetDone(FALSE
);
3518 constr
->right
.SetDone(FALSE
);
3519 constr
->bottom
.SetDone(FALSE
);
3520 constr
->width
.SetDone(FALSE
);
3521 constr
->height
.SetDone(FALSE
);
3522 constr
->centreX
.SetDone(FALSE
);
3523 constr
->centreY
.SetDone(FALSE
);
3525 wxNode
*node
= m_children
.First();
3528 wxWindow
*win
= (wxWindow
*)node
->Data();
3529 if (!win
->IsKindOf(CLASSINFO(wxFrame
)) && !win
->IsKindOf(CLASSINFO(wxDialog
)))
3530 win
->ResetConstraints();
3531 node
= node
->Next();
3535 // Need to distinguish between setting the 'fake' size for
3536 // windows and sizers, and setting the real values.
3537 void wxWindow::SetConstraintSizes(bool recurse
)
3539 wxLayoutConstraints
*constr
= GetConstraints();
3540 if (constr
&& constr
->left
.GetDone() && constr
->right
.GetDone() &&
3541 constr
->width
.GetDone() && constr
->height
.GetDone())
3543 int x
= constr
->left
.GetValue();
3544 int y
= constr
->top
.GetValue();
3545 int w
= constr
->width
.GetValue();
3546 int h
= constr
->height
.GetValue();
3548 // If we don't want to resize this window, just move it...
3549 if ((constr
->width
.GetRelationship() != wxAsIs
) ||
3550 (constr
->height
.GetRelationship() != wxAsIs
))
3552 // Calls Layout() recursively. AAAGH. How can we stop that.
3553 // Simply take Layout() out of non-top level OnSizes.
3554 SizerSetSize(x
, y
, w
, h
);
3563 wxChar
*windowClass
= this->GetClassInfo()->GetClassName();
3566 if (GetName() == _T(""))
3567 winName
= _T("unnamed");
3569 winName
= GetName();
3570 wxLogDebug( _T("Constraint(s) not satisfied for window of type %s, name %s:\n"),
3571 (const wxChar
*)windowClass
,
3572 (const wxChar
*)winName
);
3573 if (!constr
->left
.GetDone()) wxLogDebug( _T(" unsatisfied 'left' constraint.\n") );
3574 if (!constr
->right
.GetDone()) wxLogDebug( _T(" unsatisfied 'right' constraint.\n") );
3575 if (!constr
->width
.GetDone()) wxLogDebug( _T(" unsatisfied 'width' constraint.\n") );
3576 if (!constr
->height
.GetDone()) wxLogDebug( _T(" unsatisfied 'height' constraint.\n") );
3577 wxLogDebug( _T("Please check constraints: try adding AsIs() constraints.\n") );
3582 wxNode
*node
= m_children
.First();
3585 wxWindow
*win
= (wxWindow
*)node
->Data();
3586 if (!win
->IsKindOf(CLASSINFO(wxFrame
)) && !win
->IsKindOf(CLASSINFO(wxDialog
)))
3587 win
->SetConstraintSizes();
3588 node
= node
->Next();
3593 // This assumes that all sizers are 'on' the same
3594 // window, i.e. the parent of this window.
3595 void wxWindow::TransformSizerToActual(int *x
, int *y
) const
3597 if (!m_sizerParent
|| m_sizerParent
->IsKindOf(CLASSINFO(wxDialog
)) ||
3598 m_sizerParent
->IsKindOf(CLASSINFO(wxFrame
)) )
3602 m_sizerParent
->GetPosition(&xp
, &yp
);
3603 m_sizerParent
->TransformSizerToActual(&xp
, &yp
);
3608 void wxWindow::SizerSetSize(int x
, int y
, int w
, int h
)
3612 TransformSizerToActual(&xx
, &yy
);
3613 SetSize(xx
, yy
, w
, h
);
3616 void wxWindow::SizerMove(int x
, int y
)
3620 TransformSizerToActual(&xx
, &yy
);
3624 // Only set the size/position of the constraint (if any)
3625 void wxWindow::SetSizeConstraint(int x
, int y
, int w
, int h
)
3627 wxLayoutConstraints
*constr
= GetConstraints();
3632 constr
->left
.SetValue(x
);
3633 constr
->left
.SetDone(TRUE
);
3637 constr
->top
.SetValue(y
);
3638 constr
->top
.SetDone(TRUE
);
3642 constr
->width
.SetValue(w
);
3643 constr
->width
.SetDone(TRUE
);
3647 constr
->height
.SetValue(h
);
3648 constr
->height
.SetDone(TRUE
);
3653 void wxWindow::MoveConstraint(int x
, int y
)
3655 wxLayoutConstraints
*constr
= GetConstraints();
3660 constr
->left
.SetValue(x
);
3661 constr
->left
.SetDone(TRUE
);
3665 constr
->top
.SetValue(y
);
3666 constr
->top
.SetDone(TRUE
);
3671 void wxWindow::GetSizeConstraint(int *w
, int *h
) const
3673 wxLayoutConstraints
*constr
= GetConstraints();
3676 *w
= constr
->width
.GetValue();
3677 *h
= constr
->height
.GetValue();
3683 void wxWindow::GetClientSizeConstraint(int *w
, int *h
) const
3685 wxLayoutConstraints
*constr
= GetConstraints();
3688 *w
= constr
->width
.GetValue();
3689 *h
= constr
->height
.GetValue();
3692 GetClientSize(w
, h
);
3695 void wxWindow::GetPositionConstraint(int *x
, int *y
) const
3697 wxLayoutConstraints
*constr
= GetConstraints();
3700 *x
= constr
->left
.GetValue();
3701 *y
= constr
->top
.GetValue();