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"
24 #include "wx/dcclient.h"
27 #include "wx/statusbr.h"
29 #include "gdk/gdkprivate.h"
30 #include "gdk/gdkkeysyms.h"
34 //-----------------------------------------------------------------------------
35 // documentation on internals
36 //-----------------------------------------------------------------------------
39 I have been asked several times about writing some documentation about
40 the GTK port of wxWindows, especially its internal structures. Obviously,
41 you cannot understand wxGTK without knowing a little about the GTK, but
42 some more information about what the wxWindow, which is the base class
43 for all other window classes, does seems required as well.
45 What does wxWindow do? It contains the common interface for the following
46 jobs of its descendants:
48 1) Define the rudimentary behaviour common to all window classes, such as
49 resizing, intercepting user input (so as to make it possible to use these
50 events for special purposes in a derived class), window names etc.
52 2) Provide the possibility to contain and manage children, if the derived
53 class is allowed to contain children, which holds true for those window
54 classes which do not display a native GTK widget. To name them, these
55 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
56 work classes are a special case and are handled a bit differently from
57 the rest. The same holds true for the wxNotebook class.
59 3) Provide the possibility to draw into a client area of a window. This,
60 too, only holds true for classes that do not display a native GTK widget
63 4) Provide the entire mechanism for scrolling widgets. This actual inter-
64 face for this is usually in wxScrolledWindow, but the GTK implementation
67 5) A multitude of helper or extra methods for special purposes, such as
68 Drag'n'Drop, managing validators etc.
70 Normally one might expect, that one wxWindows window would always correspond
71 to one GTK widget. Under GTK, there is no such allround widget that has all
72 the functionality. Moreover, the GTK defines a client area as a different
73 widget from the actual widget you are handling. Last but not least some
74 special classes (e.g. wxFrame) handle different categories of widgets and
75 still have the possibility to draw something in the client area.
76 It was therefore required to write a special purpose GTK widget, that would
77 represent a client area in the sense of wxWindows capable to do the jobs
78 2), 3) and 4). I have written this class and it resides in win_gtk.c of
81 All windows must have a widget, with which they interact with other under-
82 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
83 thw wxWindow class has a member variable called m_widget which holds a
84 pointer to this widget. When the window class represents a GTK native widget,
85 this is (in most cases) the only GTK widget the class manages. E.g. the
86 wxStatitText class handles only a GtkLabel widget a pointer to which you
87 can find in m_widget (defined in wxWindow)
89 When the class has a client area for drawing into and for containing children
90 it has to handle the client area widget (of the type GtkMyFixed, defined in
91 win_gtk.c), but there could be any number of widgets, handled by a class
92 The common rule for all windows is only, that the widget that interacts with
93 the rest of GTK must be referenced in m_widget and all other widgets must be
94 children of this widget on the GTK level. The top-most widget, which also
95 represents the client area, must be in the m_wxwindow field and must be of
98 As I said, the window classes that display a GTK native widget only have
99 one widget, so in the case of e.g. the wxButton class m_widget holds a
100 pointer to a GtkButton widget. But windows with client areas (for drawing
101 and children) have a m_widget field that is a pointer to a GtkScrolled-
102 Window and a m_wxwindow field that is pointer to a GtkMyFixed and this
103 one is (in the GTK sense) a child of the GtkScrolledWindow.
105 If the m_wxwindow field is set, then all input to this widget is inter-
106 cepted and sent to the wxWindows class. If not, all input to the widget
107 that gets pointed to by m_widget gets intercepted and sent to the class.
111 //-----------------------------------------------------------------------------
113 //-----------------------------------------------------------------------------
115 extern wxList wxPendingDelete
;
116 extern wxList wxTopLevelWindows
;
117 extern bool g_blockEventsOnDrag
;
118 static bool g_capturing
= FALSE
;
120 // hack: we need something to pass to gtk_menu_popup, so we store the time of
121 // the last click here
122 static guint32 gs_timeLastClick
= 0;
124 //-----------------------------------------------------------------------------
125 // "expose_event" (of m_wxwindow, not of m_widget)
126 //-----------------------------------------------------------------------------
128 static void gtk_window_expose_callback( GtkWidget
*WXUNUSED(widget
), GdkEventExpose
*gdk_event
, wxWindow
*win
)
130 if (!win
->HasVMT()) return;
131 if (g_blockEventsOnDrag
) return;
133 win
->m_updateRegion
.Union( gdk_event
->area
.x
,
135 gdk_event
->area
.width
,
136 gdk_event
->area
.height
);
138 if (gdk_event
->count
> 0) return;
141 printf( "OnExpose from " );
142 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
143 printf( win->GetClassInfo()->GetClassName() );
147 wxPaintEvent
event( win
->GetId() );
148 event
.SetEventObject( win
);
149 win
->GetEventHandler()->ProcessEvent( event
);
151 win
->m_updateRegion
.Clear();
154 //-----------------------------------------------------------------------------
155 // "draw" (of m_wxwindow, not of m_widget)
156 //-----------------------------------------------------------------------------
158 static void gtk_window_draw_callback( GtkWidget
*WXUNUSED(widget
), GdkRectangle
*rect
, wxWindow
*win
)
160 if (!win
->HasVMT()) return;
161 if (g_blockEventsOnDrag
) return;
163 win
->m_updateRegion
.Union( rect
->x
, rect
->y
, rect
->width
, rect
->height
);
165 wxPaintEvent
event( win
->GetId() );
166 event
.SetEventObject( win
);
167 win
->GetEventHandler()->ProcessEvent( event
);
169 win
->m_updateRegion
.Clear();
172 //-----------------------------------------------------------------------------
174 //-----------------------------------------------------------------------------
176 static gint
gtk_window_key_press_callback( GtkWidget
*widget
, GdkEventKey
*gdk_event
, wxWindow
*win
)
178 if (!win
->HasVMT()) return FALSE
;
179 if (g_blockEventsOnDrag
) return FALSE
;
182 printf( "OnKeyPress from " );
183 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
184 printf( win->GetClassInfo()->GetClassName() );
189 switch (gdk_event
->keyval
)
191 case GDK_BackSpace
: key_code
= WXK_BACK
; break;
192 case GDK_Tab
: key_code
= WXK_TAB
; break;
193 case GDK_Linefeed
: key_code
= WXK_RETURN
; break;
194 case GDK_Clear
: key_code
= WXK_CLEAR
; break;
195 case GDK_Return
: key_code
= WXK_RETURN
; break;
196 case GDK_Pause
: key_code
= WXK_PAUSE
; break;
197 case GDK_Scroll_Lock
: key_code
= WXK_SCROLL
; break;
198 case GDK_Escape
: key_code
= WXK_ESCAPE
; break;
199 case GDK_Delete
: key_code
= WXK_DELETE
; break;
200 case GDK_Home
: key_code
= WXK_HOME
; break;
201 case GDK_Left
: key_code
= WXK_LEFT
; break;
202 case GDK_Up
: key_code
= WXK_UP
; break;
203 case GDK_Right
: key_code
= WXK_RIGHT
; break;
204 case GDK_Down
: key_code
= WXK_DOWN
; break;
205 case GDK_Prior
: key_code
= WXK_PRIOR
; break;
206 // case GDK_Page_Up: key_code = WXK_PAGEUP; break;
207 case GDK_Next
: key_code
= WXK_NEXT
; break;
208 // case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
209 case GDK_End
: key_code
= WXK_END
; break;
210 case GDK_Begin
: key_code
= WXK_HOME
; break;
211 case GDK_Select
: key_code
= WXK_SELECT
; break;
212 case GDK_Print
: key_code
= WXK_PRINT
; break;
213 case GDK_Execute
: key_code
= WXK_EXECUTE
; break;
214 case GDK_Insert
: key_code
= WXK_INSERT
; break;
215 case GDK_Num_Lock
: key_code
= WXK_NUMLOCK
; break;
216 case GDK_KP_Tab
: key_code
= WXK_TAB
; break;
217 case GDK_KP_Enter
: key_code
= WXK_RETURN
; break;
218 case GDK_KP_Home
: key_code
= WXK_HOME
; break;
219 case GDK_KP_Left
: key_code
= WXK_LEFT
; break;
220 case GDK_KP_Up
: key_code
= WXK_UP
; break;
221 case GDK_KP_Right
: key_code
= WXK_RIGHT
; break;
222 case GDK_KP_Down
: key_code
= WXK_DOWN
; break;
223 case GDK_KP_Prior
: key_code
= WXK_PRIOR
; break;
224 // case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
225 case GDK_KP_Next
: key_code
= WXK_NEXT
; break;
226 // case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
227 case GDK_KP_End
: key_code
= WXK_END
; break;
228 case GDK_KP_Begin
: key_code
= WXK_HOME
; break;
229 case GDK_KP_Insert
: key_code
= WXK_INSERT
; break;
230 case GDK_KP_Delete
: key_code
= WXK_DELETE
; break;
231 case GDK_KP_Multiply
: key_code
= WXK_MULTIPLY
; break;
232 case GDK_KP_Add
: key_code
= WXK_ADD
; break;
233 case GDK_KP_Separator
: key_code
= WXK_SEPARATOR
; break;
234 case GDK_KP_Subtract
: key_code
= WXK_SUBTRACT
; break;
235 case GDK_KP_Decimal
: key_code
= WXK_DECIMAL
; break;
236 case GDK_KP_Divide
: key_code
= WXK_DIVIDE
; break;
237 case GDK_KP_0
: key_code
= WXK_NUMPAD0
; break;
238 case GDK_KP_1
: key_code
= WXK_NUMPAD1
; break;
239 case GDK_KP_2
: key_code
= WXK_NUMPAD2
; break;
240 case GDK_KP_3
: key_code
= WXK_NUMPAD3
; break;
241 case GDK_KP_4
: key_code
= WXK_NUMPAD4
; break;
242 case GDK_KP_5
: key_code
= WXK_NUMPAD5
; break;
243 case GDK_KP_6
: key_code
= WXK_NUMPAD6
; break;
244 case GDK_KP_7
: key_code
= WXK_NUMPAD7
; break;
245 case GDK_KP_8
: key_code
= WXK_NUMPAD7
; break;
246 case GDK_KP_9
: key_code
= WXK_NUMPAD9
; break;
247 case GDK_F1
: key_code
= WXK_F1
; break;
248 case GDK_F2
: key_code
= WXK_F2
; break;
249 case GDK_F3
: key_code
= WXK_F3
; break;
250 case GDK_F4
: key_code
= WXK_F4
; break;
251 case GDK_F5
: key_code
= WXK_F5
; break;
252 case GDK_F6
: key_code
= WXK_F6
; break;
253 case GDK_F7
: key_code
= WXK_F7
; break;
254 case GDK_F8
: key_code
= WXK_F8
; break;
255 case GDK_F9
: key_code
= WXK_F9
; break;
256 case GDK_F10
: key_code
= WXK_F10
; break;
257 case GDK_F11
: key_code
= WXK_F11
; break;
258 case GDK_F12
: key_code
= WXK_F12
; break;
261 if ((gdk_event
->keyval
>= 0x20) && (gdk_event
->keyval
<= 0xFF))
262 key_code
= gdk_event
->keyval
;
266 if (!key_code
) return FALSE
;
268 wxKeyEvent
event( wxEVT_CHAR
);
269 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
270 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
271 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
272 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
273 event
.m_keyCode
= key_code
;
276 event
.SetEventObject( win
);
278 bool ret
= win
->GetEventHandler()->ProcessEvent( event
);
282 wxWindow
*ancestor
= win
;
285 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
288 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
289 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
292 ancestor
= ancestor
->GetParent();
298 if ((gdk_event
->keyval
>= 0x20) && (gdk_event
->keyval
<= 0xFF))
299 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_press_event" );
305 //-----------------------------------------------------------------------------
306 // "button_press_event"
307 //-----------------------------------------------------------------------------
309 static gint
gtk_window_button_press_callback( GtkWidget
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
311 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return TRUE
;
313 if (g_blockEventsOnDrag
) return TRUE
;
317 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
) && !GTK_WIDGET_HAS_FOCUS (win
->m_wxwindow
) )
319 gtk_widget_grab_focus (win
->m_wxwindow
);
322 printf( "GrabFocus from " );
323 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
324 printf( win->GetClassInfo()->GetClassName() );
331 if (!win
->HasVMT()) return TRUE
;
334 printf( "OnButtonPress from " );
335 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
336 printf( win->GetClassInfo()->GetClassName() );
340 wxEventType event_type
= wxEVT_LEFT_DOWN
;
342 if (gdk_event
->button
== 1)
344 switch (gdk_event
->type
)
346 case GDK_BUTTON_PRESS
: event_type
= wxEVT_LEFT_DOWN
; break;
347 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_LEFT_DCLICK
; break;
351 else if (gdk_event
->button
== 2)
353 switch (gdk_event
->type
)
355 case GDK_BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DOWN
; break;
356 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DCLICK
; break;
360 else if (gdk_event
->button
== 3)
362 switch (gdk_event
->type
)
364 case GDK_BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DOWN
; break;
365 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DCLICK
; break;
370 wxMouseEvent
event( event_type
);
371 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
372 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
373 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
374 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
375 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
376 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
377 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
379 event
.m_x
= (long)gdk_event
->x
;
380 event
.m_y
= (long)gdk_event
->y
;
382 // Some control don't have their own X window and thus cannot get
387 wxNode
*node
= win
->GetChildren()->First();
390 wxWindow
*child
= (wxWindow
*)node
->Data();
391 if ((child
->m_x
<= event
.m_x
) &&
392 (child
->m_y
<= event
.m_y
) &&
393 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
394 (child
->m_y
+child
->m_height
>= event
.m_y
))
397 event
.m_x
-= child
->m_x
;
398 event
.m_y
-= child
->m_y
;
405 event
.SetEventObject( win
);
407 gs_timeLastClick
= gdk_event
->time
;
409 if (win
->GetEventHandler()->ProcessEvent( event
))
410 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
415 //-----------------------------------------------------------------------------
416 // "button_release_event"
417 //-----------------------------------------------------------------------------
419 static gint
gtk_window_button_release_callback( GtkWidget
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
421 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return TRUE
;
423 if (g_blockEventsOnDrag
) return TRUE
;
425 if (!win
->HasVMT()) return TRUE
;
428 printf( "OnButtonRelease from " );
429 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
430 printf( win->GetClassInfo()->GetClassName() );
434 wxEventType event_type
= wxEVT_NULL
;
436 switch (gdk_event
->button
)
438 case 1: event_type
= wxEVT_LEFT_UP
; break;
439 case 2: event_type
= wxEVT_MIDDLE_UP
; break;
440 case 3: event_type
= wxEVT_RIGHT_UP
; break;
443 wxMouseEvent
event( event_type
);
444 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
445 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
446 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
447 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
448 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
449 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
450 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
451 event
.m_x
= (long)gdk_event
->x
;
452 event
.m_y
= (long)gdk_event
->y
;
454 // Some control don't have their own X window and thus cannot get
459 wxNode
*node
= win
->GetChildren()->First();
462 wxWindow
*child
= (wxWindow
*)node
->Data();
463 if ((child
->m_x
<= event
.m_x
) &&
464 (child
->m_y
<= event
.m_y
) &&
465 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
466 (child
->m_y
+child
->m_height
>= event
.m_y
))
469 event
.m_x
-= child
->m_x
;
470 event
.m_y
-= child
->m_y
;
477 event
.SetEventObject( win
);
479 if (win
->GetEventHandler()->ProcessEvent( event
))
480 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
485 //-----------------------------------------------------------------------------
486 // "motion_notify_event"
487 //-----------------------------------------------------------------------------
489 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
, GdkEventMotion
*gdk_event
, wxWindow
*win
)
491 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return TRUE
;
493 if (g_blockEventsOnDrag
) return TRUE
;
495 if (!win
->HasVMT()) return TRUE
;
498 printf( "OnMotion from " );
499 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
500 printf( win->GetClassInfo()->GetClassName() );
504 wxMouseEvent
event( wxEVT_MOTION
);
505 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
506 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
507 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
508 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
509 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
510 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
511 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
513 event
.m_x
= (long)gdk_event
->x
;
514 event
.m_y
= (long)gdk_event
->y
;
516 // Some control don't have their own X window and thus cannot get
521 wxNode
*node
= win
->GetChildren()->First();
524 wxWindow
*child
= (wxWindow
*)node
->Data();
525 if ((child
->m_x
<= event
.m_x
) &&
526 (child
->m_y
<= event
.m_y
) &&
527 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
528 (child
->m_y
+child
->m_height
>= event
.m_y
))
531 event
.m_x
-= child
->m_x
;
532 event
.m_y
-= child
->m_y
;
539 event
.SetEventObject( win
);
541 if (win
->GetEventHandler()->ProcessEvent( event
))
542 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
547 //-----------------------------------------------------------------------------
549 //-----------------------------------------------------------------------------
551 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
553 if (g_blockEventsOnDrag
) return TRUE
;
556 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
))
558 GTK_WIDGET_SET_FLAGS (win
->m_wxwindow
, GTK_HAS_FOCUS
);
560 printf( "SetFocus flag from " );
561 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
562 printf( win->GetClassInfo()->GetClassName() );
568 if (!win
->HasVMT()) return TRUE
;
571 printf( "OnSetFocus from " );
572 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
573 printf( win->GetClassInfo()->GetClassName() );
575 printf( WXSTRINGCAST win->GetLabel() );
579 wxFocusEvent
event( wxEVT_SET_FOCUS
, win
->GetId() );
580 event
.SetEventObject( win
);
582 if (win
->GetEventHandler()->ProcessEvent( event
))
583 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
588 //-----------------------------------------------------------------------------
590 //-----------------------------------------------------------------------------
592 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
594 if (g_blockEventsOnDrag
) return TRUE
;
597 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
))
598 GTK_WIDGET_UNSET_FLAGS (win
->m_wxwindow
, GTK_HAS_FOCUS
);
601 if (!win
->HasVMT()) return TRUE
;
604 printf( "OnKillFocus from " );
605 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
606 printf( win->GetClassInfo()->GetClassName() );
610 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
611 event
.SetEventObject( win
);
613 if (win
->GetEventHandler()->ProcessEvent( event
))
614 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_out_event" );
619 //-----------------------------------------------------------------------------
620 // "enter_notify_event"
621 //-----------------------------------------------------------------------------
623 static gint
gtk_window_enter_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
625 if (widget
->window
!= gdk_event
->window
) return TRUE
;
627 if (g_blockEventsOnDrag
) return TRUE
;
629 if (!win
->HasVMT()) return TRUE
;
632 printf( "OnEnter from " );
633 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
634 printf( win->GetClassInfo()->GetClassName() );
638 if ((widget
->window
) && (win
->m_cursor
))
639 gdk_window_set_cursor( widget
->window
, win
->m_cursor
->GetCursor() );
641 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
642 event
.SetEventObject( win
);
644 if (win
->GetEventHandler()->ProcessEvent( event
))
645 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
650 //-----------------------------------------------------------------------------
651 // "leave_notify_event"
652 //-----------------------------------------------------------------------------
654 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
656 if (widget
->window
!= gdk_event
->window
) return TRUE
;
658 if (g_blockEventsOnDrag
) return TRUE
;
660 if (!win
->HasVMT()) return TRUE
;
663 printf( "OnLeave from " );
664 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
665 printf( win->GetClassInfo()->GetClassName() );
669 if ((widget
->window
) && (win
->m_cursor
))
670 gdk_window_set_cursor( widget
->window
, wxSTANDARD_CURSOR
->GetCursor() );
672 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
673 event
.SetEventObject( win
);
675 if (win
->GetEventHandler()->ProcessEvent( event
))
676 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
681 //-----------------------------------------------------------------------------
682 // "value_changed" from m_vAdjust
683 //-----------------------------------------------------------------------------
685 static void gtk_window_vscroll_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
687 if (g_blockEventsOnDrag
) return;
690 printf( "OnVScroll from " );
691 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
692 printf( win->GetClassInfo()->GetClassName() );
696 if (!win
->HasVMT()) return;
698 float diff
= win
->m_vAdjust
->value
- win
->m_oldVerticalPos
;
699 if (fabs(diff
) < 0.2) return;
701 wxEventType command
= wxEVT_NULL
;
703 float line_step
= win
->m_vAdjust
->step_increment
;
704 float page_step
= win
->m_vAdjust
->page_increment
;
706 if (fabs(diff
-line_step
) < 0.2) command
= wxEVT_SCROLL_LINEDOWN
;
707 else if (fabs(diff
+line_step
) < 0.2) command
= wxEVT_SCROLL_LINEUP
;
708 else if (fabs(diff
-page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEDOWN
;
709 else if (fabs(diff
+page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEUP
;
710 else command
= wxEVT_SCROLL_THUMBTRACK
;
712 int value
= (int)(win
->m_vAdjust
->value
+0.5);
714 wxScrollEvent
event( command
, win
->GetId(), value
, wxVERTICAL
);
715 event
.SetEventObject( win
);
716 win
->GetEventHandler()->ProcessEvent( event
);
719 //-----------------------------------------------------------------------------
720 // "value_changed" from m_hAdjust
721 //-----------------------------------------------------------------------------
723 static void gtk_window_hscroll_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
725 if (g_blockEventsOnDrag
) return;
728 printf( "OnHScroll from " );
729 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
730 printf( win->GetClassInfo()->GetClassName() );
734 if (!win
->HasVMT()) return;
736 float diff
= win
->m_hAdjust
->value
- win
->m_oldHorizontalPos
;
737 if (fabs(diff
) < 0.2) return;
739 wxEventType command
= wxEVT_NULL
;
741 float line_step
= win
->m_hAdjust
->step_increment
;
742 float page_step
= win
->m_hAdjust
->page_increment
;
744 if (fabs(diff
-line_step
) < 0.2) command
= wxEVT_SCROLL_LINEDOWN
;
745 else if (fabs(diff
+line_step
) < 0.2) command
= wxEVT_SCROLL_LINEUP
;
746 else if (fabs(diff
-page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEDOWN
;
747 else if (fabs(diff
+page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEUP
;
748 else command
= wxEVT_SCROLL_THUMBTRACK
;
750 int value
= (int)(win
->m_hAdjust
->value
+0.5);
752 wxScrollEvent
event( command
, win
->GetId(), value
, wxHORIZONTAL
);
753 event
.SetEventObject( win
);
754 win
->GetEventHandler()->ProcessEvent( event
);
757 //-----------------------------------------------------------------------------
758 // "changed" from m_vAdjust
759 //-----------------------------------------------------------------------------
761 static void gtk_window_vscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
763 if (g_blockEventsOnDrag
) return;
766 printf( "OnVScroll change from " );
767 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
768 printf( win->GetClassInfo()->GetClassName() );
772 if (!win
->HasVMT()) return;
774 wxEventType command
= wxEVT_SCROLL_THUMBTRACK
;
775 int value
= (int)(win
->m_vAdjust
->value
+0.5);
777 wxScrollEvent
event( command
, win
->GetId(), value
, wxVERTICAL
);
778 event
.SetEventObject( win
);
779 win
->GetEventHandler()->ProcessEvent( event
);
782 //-----------------------------------------------------------------------------
783 // "changed" from m_hAdjust
784 //-----------------------------------------------------------------------------
786 static void gtk_window_hscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
788 if (g_blockEventsOnDrag
) return;
791 printf( "OnHScroll change from " );
792 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
793 printf( win->GetClassInfo()->GetClassName() );
797 if (!win
->HasVMT()) return;
799 wxEventType command
= wxEVT_SCROLL_THUMBTRACK
;
800 int value
= (int)(win
->m_hAdjust
->value
+0.5);
802 wxScrollEvent
event( command
, win
->GetId(), value
, wxHORIZONTAL
);
803 event
.SetEventObject( win
);
804 win
->GetEventHandler()->ProcessEvent( event
);
807 //-----------------------------------------------------------------------------
808 // "button_press_event" from scrollbar
809 //-----------------------------------------------------------------------------
811 static gint
gtk_scrollbar_button_press_callback( GtkRange
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
813 if (gdk_event
->window
!= widget
->slider
) return FALSE
;
815 win
->m_isScrolling
= TRUE
;
820 //-----------------------------------------------------------------------------
821 // "button_release_event" from scrollbar
822 //-----------------------------------------------------------------------------
824 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
826 if (gdk_event
->window
!= widget
->slider
) return FALSE
;
828 GtkScrolledWindow
*s_window
= GTK_SCROLLED_WINDOW(win
->m_widget
);
830 if (widget
== GTK_RANGE(s_window
->vscrollbar
))
831 gtk_signal_emit_by_name( GTK_OBJECT(win
->m_hAdjust
), "value_changed" );
833 gtk_signal_emit_by_name( GTK_OBJECT(win
->m_vAdjust
), "value_changed" );
835 win
->m_isScrolling
= FALSE
;
840 //-----------------------------------------------------------------------------
841 // "drop_data_available_event"
842 //-----------------------------------------------------------------------------
844 static void gtk_window_drop_callback( GtkWidget
*widget
, GdkEventDropDataAvailable
*event
, wxWindow
*win
)
846 if (!win
->HasVMT()) return;
848 if (win
->GetDropTarget())
852 gdk_window_get_pointer( widget
->window
, &x
, &y
, (GdkModifierType
*) NULL
);
854 printf( "Drop data is of type %s.\n", event
->data_type
);
856 win
->GetDropTarget()->OnDrop( x
, y
, (const void*)event
->data
, (size_t)event
->data_numbytes
);
860 g_free (event->dropdataavailable.data);
861 g_free (event->dropdataavailable.data_type);
865 //-----------------------------------------------------------------------------
866 // InsertChild for wxWindow.
867 //-----------------------------------------------------------------------------
869 // Callback for wxWindow. This very strange beast has to be used because
870 // C++ has no virtual methods in a constructor. We have to emulate a
871 // virtual function here as wxNotebook requires a different way to insert
872 // a child in it. I had opted for creating a wxNotebookPage window class
873 // which would have made this superflouus (such in the MDI window system),
874 // but no-one is listening to me...
876 static void wxInsertChildInWindow( wxWindow
* parent
, wxWindow
* child
)
878 gtk_myfixed_put( GTK_MYFIXED(parent
->m_wxwindow
),
879 GTK_WIDGET(child
->m_widget
),
883 gtk_widget_set_usize( GTK_WIDGET(child
->m_widget
),
888 //-----------------------------------------------------------------------------
890 //-----------------------------------------------------------------------------
892 IMPLEMENT_DYNAMIC_CLASS(wxWindow
,wxEvtHandler
)
894 BEGIN_EVENT_TABLE(wxWindow
, wxEvtHandler
)
895 EVT_SIZE(wxWindow::OnSize
)
896 EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged
)
897 EVT_INIT_DIALOG(wxWindow::OnInitDialog
)
898 EVT_IDLE(wxWindow::OnIdle
)
903 m_widget
= (GtkWidget
*) NULL
;
904 m_wxwindow
= (GtkWidget
*) NULL
;
905 m_parent
= (wxWindow
*) NULL
;
906 m_children
.DeleteContents( FALSE
);
919 m_eventHandler
= this;
920 m_windowValidator
= (wxValidator
*) NULL
;
924 m_cursor
= (wxCursor
*) NULL
;
925 m_font
= *wxSWISS_FONT
;
927 m_windowName
= "noname";
929 m_constraints
= (wxLayoutConstraints
*) NULL
;
930 m_constraintsInvolvedIn
= (wxList
*) NULL
;
931 m_windowSizer
= (wxSizer
*) NULL
;
932 m_sizerParent
= (wxWindow
*) NULL
;
933 m_autoLayout
= FALSE
;
939 m_hasScrolling
= FALSE
;
940 m_isScrolling
= FALSE
;
941 m_hAdjust
= (GtkAdjustment
*) NULL
;
942 m_vAdjust
= (GtkAdjustment
*) NULL
;
943 m_oldHorizontalPos
= 0.0;
944 m_oldVerticalPos
= 0.0;
949 m_dropTarget
= (wxDropTarget
*) NULL
;
951 m_scrollGC
= (GdkGC
*) NULL
;
952 m_widgetStyle
= (GtkStyle
*) NULL
;
954 m_insertCallback
= wxInsertChildInWindow
;
956 m_clientObject
= (wxClientData
*) NULL
;
960 wxWindow::wxWindow( wxWindow
*parent
, wxWindowID id
,
961 const wxPoint
&pos
, const wxSize
&size
,
962 long style
, const wxString
&name
)
964 m_insertCallback
= wxInsertChildInWindow
;
965 Create( parent
, id
, pos
, size
, style
, name
);
968 bool wxWindow::Create( wxWindow
*parent
, wxWindowID id
,
969 const wxPoint
&pos
, const wxSize
&size
,
970 long style
, const wxString
&name
)
976 PreCreation( parent
, id
, pos
, size
, style
, name
);
978 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
979 m_hasScrolling
= TRUE
;
981 GtkScrolledWindow
*s_window
= GTK_SCROLLED_WINDOW(m_widget
);
983 gtk_signal_connect( GTK_OBJECT(s_window
->vscrollbar
), "button_press_event",
984 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
986 gtk_signal_connect( GTK_OBJECT(s_window
->hscrollbar
), "button_press_event",
987 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
989 gtk_signal_connect( GTK_OBJECT(s_window
->vscrollbar
), "button_release_event",
990 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
992 gtk_signal_connect( GTK_OBJECT(s_window
->hscrollbar
), "button_release_event",
993 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
995 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
996 scroll_class
->scrollbar_spacing
= 0;
998 gtk_scrolled_window_set_policy( s_window
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
1000 m_oldHorizontalPos
= 0.0;
1001 m_oldVerticalPos
= 0.0;
1003 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(s_window
->hscrollbar
) );
1004 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(s_window
->vscrollbar
) );
1006 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
1007 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
1008 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
1009 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
1011 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "changed",
1012 (GtkSignalFunc
) gtk_window_hscroll_change_callback
, (gpointer
) this );
1013 gtk_signal_connect(GTK_OBJECT(m_vAdjust
), "changed",
1014 (GtkSignalFunc
) gtk_window_vscroll_change_callback
, (gpointer
) this );
1016 GtkViewport
*viewport
= GTK_VIEWPORT(s_window
->viewport
);
1018 if (m_windowStyle
& wxRAISED_BORDER
)
1020 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_OUT
);
1022 else if (m_windowStyle
& wxSUNKEN_BORDER
)
1024 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_IN
);
1028 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_NONE
);
1031 m_wxwindow
= gtk_myfixed_new();
1033 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
1035 if (m_windowStyle
& wxTAB_TRAVERSAL
== wxTAB_TRAVERSAL
)
1036 GTK_WIDGET_UNSET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
1038 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
1040 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
1042 // shut the viewport up
1043 gtk_viewport_set_hadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1044 gtk_viewport_set_vadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1046 // I _really_ don't want scrollbars in the beginning
1047 m_vAdjust
->lower
= 0.0;
1048 m_vAdjust
->upper
= 1.0;
1049 m_vAdjust
->value
= 0.0;
1050 m_vAdjust
->step_increment
= 1.0;
1051 m_vAdjust
->page_increment
= 1.0;
1052 m_vAdjust
->page_size
= 5.0;
1053 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
1054 m_hAdjust
->lower
= 0.0;
1055 m_hAdjust
->upper
= 1.0;
1056 m_hAdjust
->value
= 0.0;
1057 m_hAdjust
->step_increment
= 1.0;
1058 m_hAdjust
->page_increment
= 1.0;
1059 m_hAdjust
->page_size
= 5.0;
1060 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
1062 gtk_widget_show( m_wxwindow
);
1064 if (m_parent
) m_parent
->AddChild( this );
1066 (m_parent
->m_insertCallback
)( m_parent
, this );
1075 wxWindow::~wxWindow()
1079 if (m_dropTarget
) delete m_dropTarget
;
1081 if (m_parent
) m_parent
->RemoveChild( this );
1082 if (m_widget
) Show( FALSE
);
1086 if (m_widgetStyle
) gtk_style_unref( m_widgetStyle
);
1088 if (m_scrollGC
) gdk_gc_unref( m_scrollGC
);
1090 if (m_wxwindow
) gtk_widget_destroy( m_wxwindow
);
1092 if (m_widget
) gtk_widget_destroy( m_widget
);
1096 DeleteRelatedConstraints();
1099 // This removes any dangling pointers to this window
1100 // in other windows' constraintsInvolvedIn lists.
1101 UnsetConstraints(m_constraints
);
1102 delete m_constraints
;
1103 m_constraints
= (wxLayoutConstraints
*) NULL
;
1107 delete m_windowSizer
;
1108 m_windowSizer
= (wxSizer
*) NULL
;
1110 // If this is a child of a sizer, remove self from parent
1111 if (m_sizerParent
) m_sizerParent
->RemoveChild((wxWindow
*)this);
1113 // Just in case the window has been Closed, but
1114 // we're then deleting immediately: don't leave
1115 // dangling pointers.
1116 wxPendingDelete
.DeleteObject(this);
1118 // Just in case we've loaded a top-level window via
1119 // wxWindow::LoadNativeDialog but we weren't a dialog
1121 wxTopLevelWindows
.DeleteObject(this);
1123 if (m_windowValidator
) delete m_windowValidator
;
1125 if (m_clientObject
) delete m_clientObject
;
1128 void wxWindow::PreCreation( wxWindow
*parent
, wxWindowID id
,
1129 const wxPoint
&pos
, const wxSize
&size
,
1130 long style
, const wxString
&name
)
1132 if (m_needParent
&& (parent
== NULL
))
1133 wxFatalError( "Need complete parent.", name
);
1135 m_widget
= (GtkWidget
*) NULL
;
1136 m_wxwindow
= (GtkWidget
*) NULL
;
1139 m_children
.DeleteContents( FALSE
);
1142 if (m_width
== -1) m_width
= 20;
1144 if (m_height
== -1) m_height
= 20;
1149 if (!m_needParent
) // some reasonable defaults
1153 m_x
= (gdk_screen_width () - m_width
) / 2;
1154 if (m_x
< 10) m_x
= 10;
1158 m_y
= (gdk_screen_height () - m_height
) / 2;
1159 if (m_y
< 10) m_y
= 10;
1170 m_eventHandler
= this;
1176 m_cursor
= new wxCursor( wxCURSOR_ARROW
);
1177 m_font
= *wxSWISS_FONT
;
1178 // m_backgroundColour = wxWHITE;
1179 // m_foregroundColour = wxBLACK;
1180 m_windowStyle
= style
;
1181 m_windowName
= name
;
1183 m_constraints
= (wxLayoutConstraints
*) NULL
;
1184 m_constraintsInvolvedIn
= (wxList
*) NULL
;
1185 m_windowSizer
= (wxSizer
*) NULL
;
1186 m_sizerParent
= (wxWindow
*) NULL
;
1187 m_autoLayout
= FALSE
;
1189 m_hasScrolling
= FALSE
;
1190 m_isScrolling
= FALSE
;
1191 m_hAdjust
= (GtkAdjustment
*) NULL
;
1192 m_vAdjust
= (GtkAdjustment
*) NULL
;
1193 m_oldHorizontalPos
= 0.0;
1194 m_oldVerticalPos
= 0.0;
1199 m_dropTarget
= (wxDropTarget
*) NULL
;
1201 m_windowValidator
= (wxValidator
*) NULL
;
1202 m_scrollGC
= (GdkGC
*) NULL
;
1203 m_widgetStyle
= (GtkStyle
*) NULL
;
1205 m_clientObject
= (wxClientData
*)NULL
;
1206 m_clientData
= NULL
;
1209 void wxWindow::PostCreation()
1213 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
1214 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
1216 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
1217 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
1220 ConnectWidget( GetConnectWidget() );
1222 if (m_widget
&& m_parent
) gtk_widget_realize( m_widget
);
1224 if (m_wxwindow
) gtk_widget_realize( m_wxwindow
);
1226 SetCursor( *wxSTANDARD_CURSOR
);
1231 void wxWindow::ConnectWidget( GtkWidget
*widget
)
1233 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
1234 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
1236 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
1237 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
1239 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
1240 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
1242 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
1243 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
1245 gtk_signal_connect( GTK_OBJECT(widget
), "focus_in_event",
1246 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
1248 gtk_signal_connect( GTK_OBJECT(widget
), "focus_out_event",
1249 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
1251 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
1252 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
1254 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
1255 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
1258 bool wxWindow::HasVMT()
1263 bool wxWindow::Close( bool force
)
1265 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1267 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
1268 event
.SetEventObject(this);
1269 event
.SetForce(force
);
1271 return GetEventHandler()->ProcessEvent(event
);
1274 bool wxWindow::Destroy()
1276 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1283 bool wxWindow::DestroyChildren()
1288 while ((node
= GetChildren()->First()) != (wxNode
*)NULL
)
1291 if ((child
= (wxWindow
*)node
->Data()) != (wxWindow
*)NULL
)
1294 if (GetChildren()->Member(child
)) delete node
;
1301 void wxWindow::PrepareDC( wxDC
&WXUNUSED(dc
) )
1303 // are we to set fonts here ?
1306 wxPoint
wxWindow::GetClientAreaOrigin() const
1308 return wxPoint(0,0);
1311 void wxWindow::AdjustForParentClientOrigin( int& x
, int& y
, int sizeFlags
)
1313 if (((sizeFlags
& wxSIZE_NO_ADJUSTMENTS
) == 0) && GetParent())
1315 wxPoint
pt(GetParent()->GetClientAreaOrigin());
1321 void wxWindow::SetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
1323 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1324 wxASSERT_MSG( (m_parent
!= NULL
), "wxWindow::SetSize requires parent.\n" );
1326 // Don't do anything for children of wxNotebook
1327 if (m_parent
->m_wxwindow
== NULL
) return;
1329 if (m_resizing
) return; // I don't like recursions
1332 int old_width
= m_width
;
1333 int old_height
= m_height
;
1335 if ((sizeFlags
& wxSIZE_USE_EXISTING
) == wxSIZE_USE_EXISTING
)
1337 if (x
!= -1) m_x
= x
;
1338 if (y
!= -1) m_y
= y
;
1339 if (width
!= -1) m_width
= width
;
1340 if (height
!= -1) m_height
= height
;
1350 if ((sizeFlags
& wxSIZE_AUTO_WIDTH
) == wxSIZE_AUTO_WIDTH
)
1352 if (width
== -1) m_width
= 80;
1355 if ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) == wxSIZE_AUTO_HEIGHT
)
1357 if (height
== -1) m_height
= 26;
1360 if ((m_minWidth
!= -1) && (m_width
< m_minWidth
)) m_width
= m_minWidth
;
1361 if ((m_minHeight
!= -1) && (m_height
< m_minHeight
)) m_height
= m_minHeight
;
1362 if ((m_maxWidth
!= -1) && (m_width
> m_maxWidth
)) m_width
= m_minWidth
;
1363 if ((m_maxHeight
!= -1) && (m_height
> m_maxHeight
)) m_height
= m_minHeight
;
1365 wxPoint
pt( m_parent
->GetClientAreaOrigin() );
1366 gtk_myfixed_move( GTK_MYFIXED(m_parent
->m_wxwindow
), m_widget
, m_x
+pt
.x
, m_y
+pt
.y
);
1368 if ((old_width
!= m_width
) || (old_height
!= m_height
))
1369 gtk_widget_set_usize( m_widget
, m_width
, m_height
);
1373 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
1374 event
.SetEventObject( this );
1375 ProcessEvent( event
);
1380 void wxWindow::SetSize( int width
, int height
)
1382 SetSize( -1, -1, width
, height
, wxSIZE_USE_EXISTING
);
1385 void wxWindow::Move( int x
, int y
)
1387 SetSize( x
, y
, -1, -1, wxSIZE_USE_EXISTING
);
1390 void wxWindow::GetSize( int *width
, int *height
) const
1392 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1394 if (width
) (*width
) = m_width
;
1395 if (height
) (*height
) = m_height
;
1398 void wxWindow::SetClientSize( int width
, int height
)
1400 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1404 SetSize( width
, height
);
1411 if (!m_hasScrolling
)
1414 do we have sunken dialogs ?
1416 GtkStyleClass *window_class = m_wxwindow->style->klass;
1418 dw += 2 * window_class->xthickness;
1419 dh += 2 * window_class->ythickness;
1424 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
1425 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
1427 GtkWidget
*viewport
= scroll_window
->viewport
;
1428 GtkStyleClass
*viewport_class
= viewport
->style
->klass
;
1430 GtkWidget
*hscrollbar
= scroll_window
->hscrollbar
;
1431 GtkWidget
*vscrollbar
= scroll_window
->vscrollbar
;
1433 if ((m_windowStyle
& wxRAISED_BORDER
) ||
1434 (m_windowStyle
& wxSUNKEN_BORDER
))
1436 dw
+= 2 * viewport_class
->xthickness
;
1437 dh
+= 2 * viewport_class
->ythickness
;
1440 if (GTK_WIDGET_VISIBLE(vscrollbar
))
1442 dw
+= vscrollbar
->allocation
.width
;
1443 dw
+= scroll_class
->scrollbar_spacing
;
1446 if (GTK_WIDGET_VISIBLE(hscrollbar
))
1448 dh
+= hscrollbar
->allocation
.height
;
1449 dw
+= scroll_class
->scrollbar_spacing
;
1453 SetSize( width
+dw
, height
+dh
);
1457 void wxWindow::GetClientSize( int *width
, int *height
) const
1459 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1463 if (width
) (*width
) = m_width
;
1464 if (height
) (*height
) = m_height
;
1471 if (!m_hasScrolling
)
1474 do we have sunken dialogs ?
1476 GtkStyleClass *window_class = m_wxwindow->style->klass;
1478 dw += 2 * window_class->xthickness;
1479 dh += 2 * window_class->ythickness;
1484 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
1485 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
1487 GtkWidget
*viewport
= scroll_window
->viewport
;
1488 GtkStyleClass
*viewport_class
= viewport
->style
->klass
;
1490 GtkWidget
*hscrollbar
= scroll_window
->hscrollbar
;
1491 GtkWidget
*vscrollbar
= scroll_window
->vscrollbar
;
1493 if ((m_windowStyle
& wxRAISED_BORDER
) ||
1494 (m_windowStyle
& wxSUNKEN_BORDER
))
1496 dw
+= 2 * viewport_class
->xthickness
;
1497 dh
+= 2 * viewport_class
->ythickness
;
1500 if (GTK_WIDGET_VISIBLE(vscrollbar
))
1502 // dw += vscrollbar->allocation.width;
1503 dw
+= 15; // range.slider_width = 11 + 2*2pts edge
1504 dw
+= scroll_class
->scrollbar_spacing
;
1507 if (GTK_WIDGET_VISIBLE(hscrollbar
))
1509 // dh += hscrollbar->allocation.height;
1511 dh
+= scroll_class
->scrollbar_spacing
;
1515 if (width
) (*width
) = m_width
- dw
;
1516 if (height
) (*height
) = m_height
- dh
;
1520 void wxWindow::GetPosition( int *x
, int *y
) const
1522 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1528 void wxWindow::ClientToScreen( int *x
, int *y
)
1530 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1532 GdkWindow
*source
= (GdkWindow
*) NULL
;
1534 source
= m_wxwindow
->window
;
1536 source
= m_widget
->window
;
1540 gdk_window_get_origin( source
, &org_x
, &org_y
);
1544 if (GTK_WIDGET_NO_WINDOW (m_widget
))
1546 org_x
+= m_widget
->allocation
.x
;
1547 org_y
+= m_widget
->allocation
.y
;
1551 wxPoint
pt(GetClientAreaOrigin());
1559 void wxWindow::ScreenToClient( int *x
, int *y
)
1561 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1563 GdkWindow
*source
= (GdkWindow
*) NULL
;
1565 source
= m_wxwindow
->window
;
1567 source
= m_widget
->window
;
1571 gdk_window_get_origin( source
, &org_x
, &org_y
);
1575 if (GTK_WIDGET_NO_WINDOW (m_widget
))
1577 org_x
+= m_widget
->allocation
.x
;
1578 org_y
+= m_widget
->allocation
.y
;
1582 wxPoint
pt(GetClientAreaOrigin());
1590 void wxWindow::Centre( int direction
)
1592 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1601 m_parent
->GetSize( &p_w
, &p_h
);
1602 if (direction
& wxHORIZONTAL
== wxHORIZONTAL
) x
= (p_w
- m_width
) / 2;
1603 if (direction
& wxVERTICAL
== wxVERTICAL
) y
= (p_h
- m_height
) / 2;
1607 if (direction
& wxHORIZONTAL
== wxHORIZONTAL
) x
= (gdk_screen_width () - m_width
) / 2;
1608 if (direction
& wxVERTICAL
== wxVERTICAL
) y
= (gdk_screen_height () - m_height
) / 2;
1614 void wxWindow::Fit()
1616 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1620 wxNode
*node
= GetChildren()->First();
1623 wxWindow
*win
= (wxWindow
*)node
->Data();
1625 win
->GetPosition(&wx
, &wy
);
1626 win
->GetSize(&ww
, &wh
);
1627 if ( wx
+ ww
> maxX
)
1629 if ( wy
+ wh
> maxY
)
1632 node
= node
->Next();
1634 SetClientSize(maxX
+ 5, maxY
+ 10);
1637 void wxWindow::SetSizeHints( int minW
, int minH
, int maxW
, int maxH
, int WXUNUSED(incW
), int WXUNUSED(incH
) )
1639 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1647 void wxWindow::OnSize( wxSizeEvent
&WXUNUSED(event
) )
1649 //if (GetAutoLayout()) Layout();
1652 bool wxWindow::Show( bool show
)
1654 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1657 gtk_widget_show( m_widget
);
1659 gtk_widget_hide( m_widget
);
1664 void wxWindow::Enable( bool enable
)
1666 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1668 m_isEnabled
= enable
;
1669 gtk_widget_set_sensitive( m_widget
, enable
);
1670 if (m_wxwindow
) gtk_widget_set_sensitive( m_wxwindow
, enable
);
1673 int wxWindow::GetCharHeight() const
1675 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1679 wxFAIL_MSG( "invalid font" );
1683 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
1684 return font
->ascent
+ font
->descent
;
1687 int wxWindow::GetCharWidth() const
1689 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1693 wxFAIL_MSG( "invalid font" );
1697 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
1698 return gdk_string_width( font
, "H" );
1701 void wxWindow::GetTextExtent( const wxString
& string
, int *x
, int *y
,
1702 int *descent
, int *externalLeading
, const wxFont
*theFont
, bool WXUNUSED(use16
) ) const
1704 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1706 wxFont fontToUse
= m_font
;
1707 if (theFont
) fontToUse
= *theFont
;
1709 if (!fontToUse
.Ok())
1711 wxFAIL_MSG( "invalid font" );
1714 wxASSERT_MSG( (m_font
.Ok()), "invalid font" );
1716 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
1717 if (x
) (*x
) = gdk_string_width( font
, string
);
1718 if (y
) (*y
) = font
->ascent
+ font
->descent
;
1719 if (descent
) (*descent
) = font
->descent
;
1720 if (externalLeading
) (*externalLeading
) = 0; // ??
1723 void wxWindow::MakeModal( bool modal
)
1726 // Disable all other windows
1727 if (this->IsKindOf(CLASSINFO(wxDialog
)) || this->IsKindOf(CLASSINFO(wxFrame
)))
1729 wxNode
*node
= wxTopLevelWindows
.First();
1732 wxWindow
*win
= (wxWindow
*)node
->Data();
1734 win
->Enable(!modal
);
1736 node
= node
->Next();
1741 void wxWindow::SetFocus()
1743 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1745 GtkWidget
*connect_widget
= GetConnectWidget();
1748 if (GTK_WIDGET_CAN_FOCUS(connect_widget
) && !GTK_WIDGET_HAS_FOCUS (connect_widget
) )
1750 gtk_widget_grab_focus (connect_widget
);
1755 bool wxWindow::OnClose()
1760 void wxWindow::AddChild( wxWindow
*child
)
1762 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1763 wxASSERT_MSG( (child
!= NULL
), "invalid child" );
1765 m_children
.Append( child
);
1768 wxList
*wxWindow::GetChildren()
1770 return (&m_children
);
1773 void wxWindow::RemoveChild( wxWindow
*child
)
1775 if (GetChildren()) GetChildren()->DeleteObject( child
);
1776 child
->m_parent
= (wxWindow
*) NULL
;
1779 void wxWindow::SetReturnCode( int retCode
)
1781 m_retCode
= retCode
;
1784 int wxWindow::GetReturnCode()
1789 void wxWindow::Raise()
1791 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1793 if (m_widget
) gdk_window_raise( m_widget
->window
);
1796 void wxWindow::Lower()
1798 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1800 if (m_widget
) gdk_window_lower( m_widget
->window
);
1803 wxEvtHandler
*wxWindow::GetEventHandler()
1805 return m_eventHandler
;
1808 void wxWindow::SetEventHandler( wxEvtHandler
*handler
)
1810 m_eventHandler
= handler
;
1813 void wxWindow::PushEventHandler(wxEvtHandler
*handler
)
1815 handler
->SetNextHandler(GetEventHandler());
1816 SetEventHandler(handler
);
1819 wxEvtHandler
*wxWindow::PopEventHandler(bool deleteHandler
)
1821 if (GetEventHandler())
1823 wxEvtHandler
*handlerA
= GetEventHandler();
1824 wxEvtHandler
*handlerB
= handlerA
->GetNextHandler();
1825 handlerA
->SetNextHandler((wxEvtHandler
*) NULL
);
1826 SetEventHandler(handlerB
);
1830 return (wxEvtHandler
*) NULL
;
1836 return (wxEvtHandler
*) NULL
;
1839 wxValidator
*wxWindow::GetValidator()
1841 return m_windowValidator
;
1844 void wxWindow::SetValidator( const wxValidator
& validator
)
1846 if (m_windowValidator
) delete m_windowValidator
;
1847 m_windowValidator
= validator
.Clone();
1848 if (m_windowValidator
) m_windowValidator
->SetWindow(this);
1851 void wxWindow::SetClientObject( wxClientData
*data
)
1853 if (m_clientObject
) delete m_clientObject
;
1854 m_clientObject
= data
;
1857 wxClientData
*wxWindow::GetClientObject()
1859 return m_clientObject
;
1862 void wxWindow::SetClientData( void *data
)
1864 m_clientData
= data
;
1867 void *wxWindow::GetClientData()
1869 return m_clientData
;
1872 bool wxWindow::IsBeingDeleted()
1877 void wxWindow::SetId( wxWindowID id
)
1882 wxWindowID
wxWindow::GetId()
1887 void wxWindow::SetCursor( const wxCursor
&cursor
)
1889 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1891 if (m_cursor
== NULL
)
1893 wxFAIL_MSG( "wxWindow::SetCursor m_cursor == NULL" );
1894 m_cursor
= new wxCursor( wxCURSOR_ARROW
);
1899 if (*((wxCursor
*)&cursor
) == m_cursor
) return;
1904 *m_cursor
= *wxSTANDARD_CURSOR
;
1907 if ((m_widget
) && (m_widget
->window
))
1908 gdk_window_set_cursor( m_widget
->window
, m_cursor
->GetCursor() );
1910 if ((m_wxwindow
) && (m_wxwindow
->window
))
1911 gdk_window_set_cursor( m_wxwindow
->window
, m_cursor
->GetCursor() );
1914 void wxWindow::Refresh( bool eraseBackground
, const wxRect
*rect
)
1916 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
1918 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
1921 gdk_window_clear_area( m_wxwindow
->window
,
1935 GetClientSize( &w
, &h
);
1937 GdkRectangle gdk_rect
;
1941 gdk_rect
.height
= h
;
1942 gtk_widget_draw( m_wxwindow
, &gdk_rect
);
1947 GdkRectangle gdk_rect
;
1948 gdk_rect
.x
= rect
->x
;
1949 gdk_rect
.y
= rect
->y
;
1950 gdk_rect
.width
= rect
->width
;
1951 gdk_rect
.height
= rect
->height
;
1954 gtk_widget_draw( m_wxwindow
, &gdk_rect
);
1956 gtk_widget_draw( m_widget
, &gdk_rect
);
1960 wxRegion
wxWindow::GetUpdateRegion() const
1962 return m_updateRegion
;
1965 bool wxWindow::IsExposed( int x
, int y
) const
1967 return (m_updateRegion
.Contains( x
, y
) != wxOutRegion
);
1970 bool wxWindow::IsExposed( int x
, int y
, int w
, int h
) const
1972 return (m_updateRegion
.Contains( x
, y
, w
, h
) != wxOutRegion
);
1975 bool wxWindow::IsExposed( const wxPoint
& pt
) const
1977 return (m_updateRegion
.Contains( pt
.x
, pt
.y
) != wxOutRegion
);
1980 bool wxWindow::IsExposed( const wxRect
& rect
) const
1982 return (m_updateRegion
.Contains( rect
.x
, rect
.y
, rect
.width
, rect
.height
) != wxOutRegion
);
1985 void wxWindow::Clear()
1987 wxCHECK_RET( m_widget
!= NULL
, "invalid window" );
1989 if (m_wxwindow
&& m_wxwindow
->window
) gdk_window_clear( m_wxwindow
->window
);
1992 wxColour
wxWindow::GetBackgroundColour() const
1994 return m_backgroundColour
;
1997 void wxWindow::SetBackgroundColour( const wxColour
&colour
)
1999 wxCHECK_RET( m_widget
!= NULL
, "invalid window" );
2001 m_backgroundColour
= colour
;
2002 if (!m_backgroundColour
.Ok()) return;
2006 GdkWindow
*window
= m_wxwindow
->window
;
2007 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( window
) );
2008 gdk_window_set_background( window
, m_backgroundColour
.GetColor() );
2009 gdk_window_clear( window
);
2015 wxColour
wxWindow::GetForegroundColour() const
2017 return m_foregroundColour
;
2020 void wxWindow::SetForegroundColour( const wxColour
&colour
)
2022 wxCHECK_RET( m_widget
!= NULL
, "invalid window" );
2024 m_foregroundColour
= colour
;
2025 if (!m_foregroundColour
.Ok()) return;
2030 GtkStyle
*wxWindow::GetWidgetStyle()
2032 if (m_widgetStyle
) gtk_style_unref( m_widgetStyle
);
2036 gtk_widget_get_style( m_widget
) );
2038 return m_widgetStyle
;
2041 void wxWindow::SetWidgetStyle()
2043 GtkStyle
*style
= GetWidgetStyle();
2045 gdk_font_unref( style
->font
);
2046 style
->font
= gdk_font_ref( m_font
.GetInternalFont( 1.0 ) );
2048 if (m_foregroundColour
.Ok())
2050 m_foregroundColour
.CalcPixel( gdk_window_get_colormap( m_widget
->window
) );
2051 style
->fg
[GTK_STATE_NORMAL
] = *m_foregroundColour
.GetColor();
2052 style
->fg
[GTK_STATE_PRELIGHT
] = *m_foregroundColour
.GetColor();
2053 style
->fg
[GTK_STATE_ACTIVE
] = *m_foregroundColour
.GetColor();
2056 if (m_backgroundColour
.Ok())
2058 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( m_widget
->window
) );
2059 style
->bg
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
2060 style
->base
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
2061 style
->bg
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
2062 style
->base
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
2063 style
->bg
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
2064 style
->base
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
2065 style
->bg
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
2066 style
->base
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
2070 void wxWindow::ApplyWidgetStyle()
2074 bool wxWindow::Validate()
2076 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, "invalid window" );
2078 wxNode
*node
= GetChildren()->First();
2081 wxWindow
*child
= (wxWindow
*)node
->Data();
2082 if (child
->GetValidator() && /* child->GetValidator()->Ok() && */ !child
->GetValidator()->Validate(this))
2084 node
= node
->Next();
2089 bool wxWindow::TransferDataToWindow()
2091 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, "invalid window" );
2093 wxNode
*node
= GetChildren()->First();
2096 wxWindow
*child
= (wxWindow
*)node
->Data();
2097 if (child
->GetValidator() && /* child->GetValidator()->Ok() && */
2098 !child
->GetValidator()->TransferToWindow() )
2100 wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK
|wxICON_EXCLAMATION
);
2103 node
= node
->Next();
2108 bool wxWindow::TransferDataFromWindow()
2110 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
2112 wxNode
*node
= GetChildren()->First();
2115 wxWindow
*child
= (wxWindow
*)node
->Data();
2116 if ( child
->GetValidator() && /* child->GetValidator()->Ok() && */ !child
->GetValidator()->TransferFromWindow() )
2118 node
= node
->Next();
2123 void wxWindow::SetAcceleratorTable( const wxAcceleratorTable
& accel
)
2125 m_acceleratorTable
= accel
;
2128 void wxWindow::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2130 TransferDataToWindow();
2133 void wxWindow::InitDialog()
2135 wxCHECK_RET( m_widget
!= NULL
, "invalid window" );
2137 wxInitDialogEvent
event(GetId());
2138 event
.SetEventObject( this );
2139 GetEventHandler()->ProcessEvent(event
);
2142 static void SetInvokingWindow( wxMenu
*menu
, wxWindow
*win
)
2144 menu
->SetInvokingWindow( win
);
2145 wxNode
*node
= menu
->m_items
.First();
2148 wxMenuItem
*menuitem
= (wxMenuItem
*)node
->Data();
2149 if (menuitem
->IsSubMenu())
2150 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
2151 node
= node
->Next();
2155 bool wxWindow::PopupMenu( wxMenu
*menu
, int WXUNUSED(x
), int WXUNUSED(y
) )
2157 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, "invalid window" );
2159 wxCHECK_MSG( menu
!= NULL
, FALSE
, "invalid popup-menu" );
2161 SetInvokingWindow( menu
, this );
2163 GTK_MENU(menu
->m_menu
),
2164 (GtkWidget
*)NULL
, // parent menu shell
2165 (GtkWidget
*)NULL
, // parent menu item
2166 (GtkMenuPositionFunc
)NULL
,
2167 NULL
, // client data
2168 0, // button used to activate it
2169 0//gs_timeLastClick // the time of activation
2174 void wxWindow::SetDropTarget( wxDropTarget
*dropTarget
)
2176 wxCHECK_RET( m_widget
!= NULL
, "invalid window" );
2178 GtkWidget
*dnd_widget
= GetConnectWidget();
2180 DisconnectDnDWidget( dnd_widget
);
2182 if (m_dropTarget
) delete m_dropTarget
;
2183 m_dropTarget
= dropTarget
;
2185 ConnectDnDWidget( dnd_widget
);
2188 wxDropTarget
*wxWindow::GetDropTarget() const
2190 return m_dropTarget
;
2193 void wxWindow::ConnectDnDWidget( GtkWidget
*widget
)
2195 if (!m_dropTarget
) return;
2197 m_dropTarget
->RegisterWidget( widget
);
2199 gtk_signal_connect( GTK_OBJECT(widget
), "drop_data_available_event",
2200 GTK_SIGNAL_FUNC(gtk_window_drop_callback
), (gpointer
)this );
2203 void wxWindow::DisconnectDnDWidget( GtkWidget
*widget
)
2205 if (!m_dropTarget
) return;
2207 gtk_signal_disconnect_by_func( GTK_OBJECT(widget
),
2208 GTK_SIGNAL_FUNC(gtk_window_drop_callback
), (gpointer
)this );
2210 m_dropTarget
->UnregisterWidget( widget
);
2213 GtkWidget
* wxWindow::GetConnectWidget()
2215 GtkWidget
*connect_widget
= m_widget
;
2216 if (m_wxwindow
) connect_widget
= m_wxwindow
;
2218 return connect_widget
;
2221 bool wxWindow::IsOwnGtkWindow( GdkWindow
*window
)
2223 if (m_wxwindow
) return (window
== m_wxwindow
->window
);
2224 return (window
== m_widget
->window
);
2227 void wxWindow::SetFont( const wxFont
&font
)
2229 wxCHECK_RET( m_widget
!= NULL
, "invalid window" );
2231 if (((wxFont
*)&font
)->Ok())
2234 m_font
= *wxSWISS_FONT
;
2239 wxFont
*wxWindow::GetFont()
2244 void wxWindow::SetWindowStyleFlag( long flag
)
2246 m_windowStyle
= flag
;
2249 long wxWindow::GetWindowStyleFlag() const
2251 return m_windowStyle
;
2254 void wxWindow::CaptureMouse()
2256 wxCHECK_RET( m_widget
!= NULL
, "invalid window" );
2258 wxCHECK_RET( g_capturing
== FALSE
, "CaptureMouse called twice" );
2260 GtkWidget
*connect_widget
= GetConnectWidget();
2261 gtk_grab_add( connect_widget
);
2262 gdk_pointer_grab ( connect_widget
->window
, FALSE
,
2264 (GDK_BUTTON_PRESS_MASK
|
2265 GDK_BUTTON_RELEASE_MASK
|
2266 GDK_POINTER_MOTION_MASK
),
2267 (GdkWindow
*) NULL
, (GdkCursor
*) NULL
, GDK_CURRENT_TIME
);
2271 void wxWindow::ReleaseMouse()
2273 wxCHECK_RET( m_widget
!= NULL
, "invalid window" );
2275 wxCHECK_RET( g_capturing
== TRUE
, "ReleaseMouse called twice" );
2277 GtkWidget
*connect_widget
= GetConnectWidget();
2278 gtk_grab_remove( connect_widget
);
2279 gdk_pointer_ungrab ( GDK_CURRENT_TIME
);
2280 g_capturing
= FALSE
;
2283 void wxWindow::SetTitle( const wxString
&WXUNUSED(title
) )
2287 wxString
wxWindow::GetTitle() const
2289 return (wxString
&)m_windowName
;
2292 wxString
wxWindow::GetLabel() const
2297 void wxWindow::SetName( const wxString
&name
)
2299 m_windowName
= name
;
2302 wxString
wxWindow::GetName() const
2304 return (wxString
&)m_windowName
;
2307 bool wxWindow::IsShown() const
2312 bool wxWindow::IsRetained()
2317 wxWindow
*wxWindow::FindWindow( long id
)
2319 if (id
== m_windowId
) return this;
2320 wxNode
*node
= m_children
.First();
2323 wxWindow
*child
= (wxWindow
*)node
->Data();
2324 wxWindow
*res
= child
->FindWindow( id
);
2325 if (res
) return res
;
2326 node
= node
->Next();
2328 return (wxWindow
*) NULL
;
2331 wxWindow
*wxWindow::FindWindow( const wxString
& name
)
2333 if (name
== m_windowName
) return this;
2334 wxNode
*node
= m_children
.First();
2337 wxWindow
*child
= (wxWindow
*)node
->Data();
2338 wxWindow
*res
= child
->FindWindow( name
);
2339 if (res
) return res
;
2340 node
= node
->Next();
2342 return (wxWindow
*) NULL
;
2345 void wxWindow::SetScrollbar( int orient
, int pos
, int thumbVisible
,
2346 int range
, bool refresh
)
2348 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
2350 wxASSERT_MSG( (m_wxwindow
!= NULL
), "window needs client area" );
2352 if (!m_wxwindow
) return;
2354 if (orient
== wxHORIZONTAL
)
2356 float fpos
= (float)pos
;
2357 float frange
= (float)range
;
2358 float fthumb
= (float)thumbVisible
;
2360 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
2361 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
2363 SetScrollPos( orient
, pos
, refresh
);
2367 m_oldHorizontalPos
= fpos
;
2369 m_hAdjust
->lower
= 0.0;
2370 m_hAdjust
->upper
= frange
;
2371 m_hAdjust
->value
= fpos
;
2372 m_hAdjust
->step_increment
= 1.0;
2373 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
2374 m_hAdjust
->page_size
= fthumb
;
2378 float fpos
= (float)pos
;
2379 float frange
= (float)range
;
2380 float fthumb
= (float)thumbVisible
;
2382 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
2383 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
2385 SetScrollPos( orient
, pos
, refresh
);
2389 m_oldVerticalPos
= fpos
;
2391 m_vAdjust
->lower
= 0.0;
2392 m_vAdjust
->upper
= frange
;
2393 m_vAdjust
->value
= fpos
;
2394 m_vAdjust
->step_increment
= 1.0;
2395 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
2396 m_vAdjust
->page_size
= fthumb
;
2399 if (m_wxwindow
->window
)
2401 if (orient
== wxHORIZONTAL
)
2402 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
2404 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
2406 gtk_widget_set_usize( m_widget
, m_width
, m_height
);
2410 void wxWindow::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
2412 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
2414 wxASSERT_MSG( (m_wxwindow
!= NULL
), "window needs client area" );
2416 if (!m_wxwindow
) return;
2418 if (orient
== wxHORIZONTAL
)
2420 float fpos
= (float)pos
;
2421 m_oldHorizontalPos
= fpos
;
2423 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
2424 m_hAdjust
->value
= fpos
;
2428 float fpos
= (float)pos
;
2429 m_oldVerticalPos
= fpos
;
2430 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
2431 m_vAdjust
->value
= fpos
;
2436 if (m_wxwindow
->window
)
2438 if (orient
== wxHORIZONTAL
)
2439 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
2441 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
2446 int wxWindow::GetScrollThumb( int orient
) const
2448 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
2450 wxASSERT_MSG( (m_wxwindow
!= NULL
), "window needs client area" );
2452 if (!m_wxwindow
) return 0;
2454 if (orient
== wxHORIZONTAL
)
2455 return (int)(m_hAdjust
->page_size
+0.5);
2457 return (int)(m_vAdjust
->page_size
+0.5);
2460 int wxWindow::GetScrollPos( int orient
) const
2462 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
2464 wxASSERT_MSG( (m_wxwindow
!= NULL
), "window needs client area" );
2466 if (!m_wxwindow
) return 0;
2468 if (orient
== wxHORIZONTAL
)
2469 return (int)(m_hAdjust
->value
+0.5);
2471 return (int)(m_vAdjust
->value
+0.5);
2474 int wxWindow::GetScrollRange( int orient
) const
2476 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
2478 wxASSERT_MSG( (m_wxwindow
!= NULL
), "window needs client area" );
2480 if (!m_wxwindow
) return 0;
2482 if (orient
== wxHORIZONTAL
)
2483 return (int)(m_hAdjust
->upper
+0.5);
2485 return (int)(m_vAdjust
->upper
+0.5);
2488 void wxWindow::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
2490 wxASSERT_MSG( (m_widget
!= NULL
), "invalid window" );
2492 wxASSERT_MSG( (m_wxwindow
!= NULL
), "window needs client area" );
2494 if (!m_wxwindow
) return;
2498 GetClientSize( &cw
, &ch
);
2500 int w
= cw
- abs(dx
);
2501 int h
= ch
- abs(dy
);
2502 if ((h
< 0) || (w
< 0))
2509 if (dx
< 0) s_x
= -dx
;
2510 if (dy
< 0) s_y
= -dy
;
2513 if (dx
> 0) d_x
= dx
;
2514 if (dy
> 0) d_y
= dy
;
2518 m_scrollGC
= gdk_gc_new( m_wxwindow
->window
);
2519 gdk_gc_set_exposures( m_scrollGC
, TRUE
);
2522 gdk_window_copy_area( m_wxwindow
->window
, m_scrollGC
, d_x
, d_y
,
2523 m_wxwindow
->window
, s_x
, s_y
, w
, h
);
2526 if (dx
< 0) rect
.x
= cw
+dx
; else rect
.x
= 0;
2527 if (dy
< 0) rect
.y
= ch
+dy
; else rect
.y
= 0;
2528 if (dy
!= 0) rect
.width
= cw
; else rect
.width
= abs(dx
);
2529 if (dx
!= 0) rect
.height
= ch
; else rect
.height
= abs(dy
);
2531 Refresh( TRUE
, &rect
);
2534 //-------------------------------------------------------------------------------------
2536 //-------------------------------------------------------------------------------------
2538 wxLayoutConstraints
*wxWindow::GetConstraints() const
2540 return m_constraints
;
2543 void wxWindow::SetConstraints( wxLayoutConstraints
*constraints
)
2547 UnsetConstraints(m_constraints
);
2548 delete m_constraints
;
2550 m_constraints
= constraints
;
2553 // Make sure other windows know they're part of a 'meaningful relationship'
2554 if (m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this))
2555 m_constraints
->left
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
2556 if (m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this))
2557 m_constraints
->top
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
2558 if (m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this))
2559 m_constraints
->right
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
2560 if (m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this))
2561 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
2562 if (m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this))
2563 m_constraints
->width
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
2564 if (m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this))
2565 m_constraints
->height
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
2566 if (m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this))
2567 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
2568 if (m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this))
2569 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
2575 void wxWindow::SetAutoLayout( bool autoLayout
)
2577 m_autoLayout
= autoLayout
;
2580 bool wxWindow::GetAutoLayout() const
2582 return m_autoLayout
;
2585 wxSizer
*wxWindow::GetSizer() const
2587 return m_windowSizer
;
2590 void wxWindow::SetSizerParent( wxWindow
*win
)
2592 m_sizerParent
= win
;
2595 wxWindow
*wxWindow::GetSizerParent() const
2597 return m_sizerParent
;
2600 // This removes any dangling pointers to this window
2601 // in other windows' constraintsInvolvedIn lists.
2602 void wxWindow::UnsetConstraints(wxLayoutConstraints
*c
)
2606 if (c
->left
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this))
2607 c
->left
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
2608 if (c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this))
2609 c
->top
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
2610 if (c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this))
2611 c
->right
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
2612 if (c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this))
2613 c
->bottom
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
2614 if (c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this))
2615 c
->width
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
2616 if (c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this))
2617 c
->height
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
2618 if (c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this))
2619 c
->centreX
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
2620 if (c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this))
2621 c
->centreY
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
2625 // Back-pointer to other windows we're involved with, so if we delete
2626 // this window, we must delete any constraints we're involved with.
2627 void wxWindow::AddConstraintReference(wxWindow
*otherWin
)
2629 if (!m_constraintsInvolvedIn
)
2630 m_constraintsInvolvedIn
= new wxList
;
2631 if (!m_constraintsInvolvedIn
->Member(otherWin
))
2632 m_constraintsInvolvedIn
->Append(otherWin
);
2635 // REMOVE back-pointer to other windows we're involved with.
2636 void wxWindow::RemoveConstraintReference(wxWindow
*otherWin
)
2638 if (m_constraintsInvolvedIn
)
2639 m_constraintsInvolvedIn
->DeleteObject(otherWin
);
2642 // Reset any constraints that mention this window
2643 void wxWindow::DeleteRelatedConstraints()
2645 if (m_constraintsInvolvedIn
)
2647 wxNode
*node
= m_constraintsInvolvedIn
->First();
2650 wxWindow
*win
= (wxWindow
*)node
->Data();
2651 wxNode
*next
= node
->Next();
2652 wxLayoutConstraints
*constr
= win
->GetConstraints();
2654 // Reset any constraints involving this window
2657 constr
->left
.ResetIfWin((wxWindow
*)this);
2658 constr
->top
.ResetIfWin((wxWindow
*)this);
2659 constr
->right
.ResetIfWin((wxWindow
*)this);
2660 constr
->bottom
.ResetIfWin((wxWindow
*)this);
2661 constr
->width
.ResetIfWin((wxWindow
*)this);
2662 constr
->height
.ResetIfWin((wxWindow
*)this);
2663 constr
->centreX
.ResetIfWin((wxWindow
*)this);
2664 constr
->centreY
.ResetIfWin((wxWindow
*)this);
2669 delete m_constraintsInvolvedIn
;
2670 m_constraintsInvolvedIn
= (wxList
*) NULL
;
2674 void wxWindow::SetSizer(wxSizer
*sizer
)
2676 m_windowSizer
= sizer
;
2678 sizer
->SetSizerParent((wxWindow
*)this);
2685 bool wxWindow::Layout()
2687 if (GetConstraints())
2690 GetClientSize(&w
, &h
);
2691 GetConstraints()->width
.SetValue(w
);
2692 GetConstraints()->height
.SetValue(h
);
2695 // If top level (one sizer), evaluate the sizer's constraints.
2699 GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated
2700 GetSizer()->LayoutPhase1(&noChanges
);
2701 GetSizer()->LayoutPhase2(&noChanges
);
2702 GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
2707 // Otherwise, evaluate child constraints
2708 ResetConstraints(); // Mark all constraints as unevaluated
2709 DoPhase(1); // Just one phase need if no sizers involved
2711 SetConstraintSizes(); // Recursively set the real window sizes
2717 // Do a phase of evaluating constraints:
2718 // the default behaviour. wxSizers may do a similar
2719 // thing, but also impose their own 'constraints'
2720 // and order the evaluation differently.
2721 bool wxWindow::LayoutPhase1(int *noChanges
)
2723 wxLayoutConstraints
*constr
= GetConstraints();
2726 return constr
->SatisfyConstraints((wxWindow
*)this, noChanges
);
2732 bool wxWindow::LayoutPhase2(int *noChanges
)
2742 // Do a phase of evaluating child constraints
2743 bool wxWindow::DoPhase(int phase
)
2745 int noIterations
= 0;
2746 int maxIterations
= 500;
2750 while ((noChanges
> 0) && (noIterations
< maxIterations
))
2754 wxNode
*node
= GetChildren()->First();
2757 wxWindow
*child
= (wxWindow
*)node
->Data();
2758 if (!child
->IsKindOf(CLASSINFO(wxFrame
)) && !child
->IsKindOf(CLASSINFO(wxDialog
)))
2760 wxLayoutConstraints
*constr
= child
->GetConstraints();
2763 if (succeeded
.Member(child
))
2768 int tempNoChanges
= 0;
2769 bool success
= ( (phase
== 1) ? child
->LayoutPhase1(&tempNoChanges
) : child
->LayoutPhase2(&tempNoChanges
) ) ;
2770 noChanges
+= tempNoChanges
;
2773 succeeded
.Append(child
);
2778 node
= node
->Next();
2785 void wxWindow::ResetConstraints()
2787 wxLayoutConstraints
*constr
= GetConstraints();
2790 constr
->left
.SetDone(FALSE
);
2791 constr
->top
.SetDone(FALSE
);
2792 constr
->right
.SetDone(FALSE
);
2793 constr
->bottom
.SetDone(FALSE
);
2794 constr
->width
.SetDone(FALSE
);
2795 constr
->height
.SetDone(FALSE
);
2796 constr
->centreX
.SetDone(FALSE
);
2797 constr
->centreY
.SetDone(FALSE
);
2799 wxNode
*node
= GetChildren()->First();
2802 wxWindow
*win
= (wxWindow
*)node
->Data();
2803 if (!win
->IsKindOf(CLASSINFO(wxFrame
)) && !win
->IsKindOf(CLASSINFO(wxDialog
)))
2804 win
->ResetConstraints();
2805 node
= node
->Next();
2809 // Need to distinguish between setting the 'fake' size for
2810 // windows and sizers, and setting the real values.
2811 void wxWindow::SetConstraintSizes(bool recurse
)
2813 wxLayoutConstraints
*constr
= GetConstraints();
2814 if (constr
&& constr
->left
.GetDone() && constr
->right
.GetDone() &&
2815 constr
->width
.GetDone() && constr
->height
.GetDone())
2817 int x
= constr
->left
.GetValue();
2818 int y
= constr
->top
.GetValue();
2819 int w
= constr
->width
.GetValue();
2820 int h
= constr
->height
.GetValue();
2822 // If we don't want to resize this window, just move it...
2823 if ((constr
->width
.GetRelationship() != wxAsIs
) ||
2824 (constr
->height
.GetRelationship() != wxAsIs
))
2826 // Calls Layout() recursively. AAAGH. How can we stop that.
2827 // Simply take Layout() out of non-top level OnSizes.
2828 SizerSetSize(x
, y
, w
, h
);
2837 char *windowClass
= this->GetClassInfo()->GetClassName();
2840 if (GetName() == "")
2841 winName
= _("unnamed");
2843 winName
= GetName();
2844 wxDebugMsg(_("Constraint(s) not satisfied for window of type %s, name %s:\n"), (const char *)windowClass
, (const char *)winName
);
2845 if (!constr
->left
.GetDone())
2846 wxDebugMsg(_(" unsatisfied 'left' constraint.\n"));
2847 if (!constr
->right
.GetDone())
2848 wxDebugMsg(_(" unsatisfied 'right' constraint.\n"));
2849 if (!constr
->width
.GetDone())
2850 wxDebugMsg(_(" unsatisfied 'width' constraint.\n"));
2851 if (!constr
->height
.GetDone())
2852 wxDebugMsg(_(" unsatisfied 'height' constraint.\n"));
2853 wxDebugMsg(_("Please check constraints: try adding AsIs() constraints.\n"));
2858 wxNode
*node
= GetChildren()->First();
2861 wxWindow
*win
= (wxWindow
*)node
->Data();
2862 if (!win
->IsKindOf(CLASSINFO(wxFrame
)) && !win
->IsKindOf(CLASSINFO(wxDialog
)))
2863 win
->SetConstraintSizes();
2864 node
= node
->Next();
2869 // This assumes that all sizers are 'on' the same
2870 // window, i.e. the parent of this window.
2871 void wxWindow::TransformSizerToActual(int *x
, int *y
) const
2873 if (!m_sizerParent
|| m_sizerParent
->IsKindOf(CLASSINFO(wxDialog
)) ||
2874 m_sizerParent
->IsKindOf(CLASSINFO(wxFrame
)) )
2878 m_sizerParent
->GetPosition(&xp
, &yp
);
2879 m_sizerParent
->TransformSizerToActual(&xp
, &yp
);
2884 void wxWindow::SizerSetSize(int x
, int y
, int w
, int h
)
2888 TransformSizerToActual(&xx
, &yy
);
2889 SetSize(xx
, yy
, w
, h
);
2892 void wxWindow::SizerMove(int x
, int y
)
2896 TransformSizerToActual(&xx
, &yy
);
2900 // Only set the size/position of the constraint (if any)
2901 void wxWindow::SetSizeConstraint(int x
, int y
, int w
, int h
)
2903 wxLayoutConstraints
*constr
= GetConstraints();
2908 constr
->left
.SetValue(x
);
2909 constr
->left
.SetDone(TRUE
);
2913 constr
->top
.SetValue(y
);
2914 constr
->top
.SetDone(TRUE
);
2918 constr
->width
.SetValue(w
);
2919 constr
->width
.SetDone(TRUE
);
2923 constr
->height
.SetValue(h
);
2924 constr
->height
.SetDone(TRUE
);
2929 void wxWindow::MoveConstraint(int x
, int y
)
2931 wxLayoutConstraints
*constr
= GetConstraints();
2936 constr
->left
.SetValue(x
);
2937 constr
->left
.SetDone(TRUE
);
2941 constr
->top
.SetValue(y
);
2942 constr
->top
.SetDone(TRUE
);
2947 void wxWindow::GetSizeConstraint(int *w
, int *h
) const
2949 wxLayoutConstraints
*constr
= GetConstraints();
2952 *w
= constr
->width
.GetValue();
2953 *h
= constr
->height
.GetValue();
2959 void wxWindow::GetClientSizeConstraint(int *w
, int *h
) const
2961 wxLayoutConstraints
*constr
= GetConstraints();
2964 *w
= constr
->width
.GetValue();
2965 *h
= constr
->height
.GetValue();
2968 GetClientSize(w
, h
);
2971 void wxWindow::GetPositionConstraint(int *x
, int *y
) const
2973 wxLayoutConstraints
*constr
= GetConstraints();
2976 *x
= constr
->left
.GetValue();
2977 *y
= constr
->top
.GetValue();
2983 bool wxWindow::AcceptsFocus() const
2985 return IsEnabled() && IsShown();
2988 void wxWindow::OnIdle(wxIdleEvent
& WXUNUSED(event
) )