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 printf( "OnKeyPress from " );
285 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
286 printf( win->GetClassInfo()->GetClassName() );
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
)
575 if (!win
->HasVMT()) return FALSE
;
576 if (g_blockEventsOnDrag
) return TRUE
;
577 if (g_blockEventsOnScroll
) return TRUE
;
579 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
583 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
) && !GTK_WIDGET_HAS_FOCUS (win
->m_wxwindow
) )
585 gtk_widget_grab_focus (win
->m_wxwindow
);
588 printf( "GrabFocus from " );
589 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
590 printf( win->GetClassInfo()->GetClassName() );
598 printf( "OnButtonPress from " );
599 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
600 printf( win->GetClassInfo()->GetClassName() );
604 wxEventType event_type
= wxEVT_LEFT_DOWN
;
606 if (gdk_event
->button
== 1)
608 switch (gdk_event
->type
)
610 case GDK_BUTTON_PRESS
: event_type
= wxEVT_LEFT_DOWN
; break;
611 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_LEFT_DCLICK
; break;
615 else if (gdk_event
->button
== 2)
617 switch (gdk_event
->type
)
619 case GDK_BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DOWN
; break;
620 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DCLICK
; break;
624 else if (gdk_event
->button
== 3)
626 switch (gdk_event
->type
)
628 case GDK_BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DOWN
; break;
629 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DCLICK
; break;
634 wxMouseEvent
event( event_type
);
635 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
636 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
637 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
638 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
639 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
640 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
641 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
643 event
.m_x
= (long)gdk_event
->x
;
644 event
.m_y
= (long)gdk_event
->y
;
646 // Some control don't have their own X window and thus cannot get
651 wxNode
*node
= win
->GetChildren().First();
654 wxWindow
*child
= (wxWindow
*)node
->Data();
656 if (child
->m_isStaticBox
)
658 // wxStaticBox is transparent in the box itself
661 int xx1
= child
->m_x
;
662 int yy1
= child
->m_y
;
663 int xx2
= child
->m_x
+ child
->m_width
;
664 int yy2
= child
->m_x
+ child
->m_height
;
667 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
669 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
671 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
673 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
676 event
.m_x
-= child
->m_x
;
677 event
.m_y
-= child
->m_y
;
684 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
685 (child
->m_x
<= event
.m_x
) &&
686 (child
->m_y
<= event
.m_y
) &&
687 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
688 (child
->m_y
+child
->m_height
>= event
.m_y
))
691 event
.m_x
-= child
->m_x
;
692 event
.m_y
-= child
->m_y
;
700 event
.SetEventObject( win
);
702 gs_timeLastClick
= gdk_event
->time
;
704 if (win
->GetEventHandler()->ProcessEvent( event
))
706 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
713 //-----------------------------------------------------------------------------
714 // "button_release_event"
715 //-----------------------------------------------------------------------------
717 static gint
gtk_window_button_release_callback( GtkWidget
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
719 if (!win
->HasVMT()) return FALSE
;
720 if (g_blockEventsOnDrag
) return FALSE
;
721 if (g_blockEventsOnScroll
) return FALSE
;
723 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
726 printf( "OnButtonRelease from " );
727 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
728 printf( win->GetClassInfo()->GetClassName() );
732 wxEventType event_type
= wxEVT_NULL
;
734 switch (gdk_event
->button
)
736 case 1: event_type
= wxEVT_LEFT_UP
; break;
737 case 2: event_type
= wxEVT_MIDDLE_UP
; break;
738 case 3: event_type
= wxEVT_RIGHT_UP
; break;
741 wxMouseEvent
event( event_type
);
742 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
743 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
744 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
745 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
746 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
747 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
748 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
749 event
.m_x
= (long)gdk_event
->x
;
750 event
.m_y
= (long)gdk_event
->y
;
752 // Some control don't have their own X window and thus cannot get
757 wxNode
*node
= win
->GetChildren().First();
760 wxWindow
*child
= (wxWindow
*)node
->Data();
762 if (child
->m_isStaticBox
)
764 // wxStaticBox is transparent in the box itself
767 int xx1
= child
->m_x
;
768 int yy1
= child
->m_y
;
769 int xx2
= child
->m_x
+ child
->m_width
;
770 int yy2
= child
->m_x
+ child
->m_height
;
773 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
775 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
777 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
779 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
782 event
.m_x
-= child
->m_x
;
783 event
.m_y
-= child
->m_y
;
790 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
791 (child
->m_x
<= event
.m_x
) &&
792 (child
->m_y
<= event
.m_y
) &&
793 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
794 (child
->m_y
+child
->m_height
>= event
.m_y
))
797 event
.m_x
-= child
->m_x
;
798 event
.m_y
-= child
->m_y
;
806 event
.SetEventObject( win
);
808 if (win
->GetEventHandler()->ProcessEvent( event
))
810 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
817 //-----------------------------------------------------------------------------
818 // "motion_notify_event"
819 //-----------------------------------------------------------------------------
821 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
, GdkEventMotion
*gdk_event
, wxWindow
*win
)
823 if (!win
->HasVMT()) return FALSE
;
824 if (g_blockEventsOnDrag
) return FALSE
;
825 if (g_blockEventsOnScroll
) return FALSE
;
827 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
829 if (gdk_event
->is_hint
)
833 GdkModifierType state
;
834 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
837 gdk_event
->state
= state
;
841 printf( "OnMotion from " );
842 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
843 printf( win->GetClassInfo()->GetClassName() );
847 wxMouseEvent
event( wxEVT_MOTION
);
848 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
849 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
850 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
851 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
852 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
853 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
854 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
856 event
.m_x
= (long)gdk_event
->x
;
857 event
.m_y
= (long)gdk_event
->y
;
859 // Some control don't have their own X window and thus cannot get
864 wxNode
*node
= win
->GetChildren().First();
867 wxWindow
*child
= (wxWindow
*)node
->Data();
869 if (child
->m_isStaticBox
)
871 // wxStaticBox is transparent in the box itself
874 int xx1
= child
->m_x
;
875 int yy1
= child
->m_y
;
876 int xx2
= child
->m_x
+ child
->m_width
;
877 int yy2
= child
->m_x
+ child
->m_height
;
880 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
882 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
884 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
886 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
889 event
.m_x
-= child
->m_x
;
890 event
.m_y
-= child
->m_y
;
897 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
898 (child
->m_x
<= event
.m_x
) &&
899 (child
->m_y
<= event
.m_y
) &&
900 (child
->m_x
+child
->m_width
>= event
.m_x
) &&
901 (child
->m_y
+child
->m_height
>= event
.m_y
))
904 event
.m_x
-= child
->m_x
;
905 event
.m_y
-= child
->m_y
;
913 event
.SetEventObject( win
);
915 if (win
->GetEventHandler()->ProcessEvent( event
))
917 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
924 //-----------------------------------------------------------------------------
926 //-----------------------------------------------------------------------------
928 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
930 if (!win
->HasVMT()) return FALSE
;
931 if (g_blockEventsOnDrag
) return FALSE
;
937 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
))
939 GTK_WIDGET_SET_FLAGS (win
->m_wxwindow
, GTK_HAS_FOCUS
);
941 printf( "SetFocus flag from " );
942 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
943 printf( win->GetClassInfo()->GetClassName() );
951 printf( "OnSetFocus from " );
952 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
953 printf( win->GetClassInfo()->GetClassName() );
955 printf( WXSTRINGCAST win->GetLabel() );
959 wxFocusEvent
event( wxEVT_SET_FOCUS
, win
->GetId() );
960 event
.SetEventObject( win
);
962 if (win
->GetEventHandler()->ProcessEvent( event
))
964 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
971 //-----------------------------------------------------------------------------
973 //-----------------------------------------------------------------------------
975 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
977 if (!win
->HasVMT()) return FALSE
;
978 if (g_blockEventsOnDrag
) return FALSE
;
982 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
))
983 GTK_WIDGET_UNSET_FLAGS (win
->m_wxwindow
, GTK_HAS_FOCUS
);
987 printf( "OnKillFocus from " );
988 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
989 printf( win->GetClassInfo()->GetClassName() );
993 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
994 event
.SetEventObject( win
);
996 if (win
->GetEventHandler()->ProcessEvent( event
))
998 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_out_event" );
1005 //-----------------------------------------------------------------------------
1006 // "enter_notify_event"
1007 //-----------------------------------------------------------------------------
1009 static gint
gtk_window_enter_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
1011 if (!win
->HasVMT()) return FALSE
;
1012 if (g_blockEventsOnDrag
) return FALSE
;
1014 if (widget
->window
!= gdk_event
->window
) return FALSE
;
1016 if ((widget
->window
) && (win
->m_cursor
))
1017 gdk_window_set_cursor( widget
->window
, win
->m_cursor
->GetCursor() );
1020 printf( "OnEnter from " );
1021 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1022 printf( win->GetClassInfo()->GetClassName() );
1026 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1027 event
.SetEventObject( win
);
1031 GdkModifierType state
= (GdkModifierType
)0;
1033 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1035 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
);
1036 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
);
1037 event
.m_altDown
= (state
& GDK_MOD1_MASK
);
1038 event
.m_metaDown
= (state
& GDK_MOD2_MASK
);
1039 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
);
1040 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
);
1041 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
);
1043 event
.m_x
= (long)x
;
1044 event
.m_y
= (long)y
;
1046 if (win
->GetEventHandler()->ProcessEvent( event
))
1048 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
1055 //-----------------------------------------------------------------------------
1056 // "leave_notify_event"
1057 //-----------------------------------------------------------------------------
1059 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
1061 if (!win
->HasVMT()) return FALSE
;
1062 if (g_blockEventsOnDrag
) return FALSE
;
1064 if (widget
->window
!= gdk_event
->window
) return FALSE
;
1066 if ((widget
->window
) && (win
->m_cursor
))
1067 gdk_window_set_cursor( widget
->window
, wxSTANDARD_CURSOR
->GetCursor() );
1070 printf( "OnLeave from " );
1071 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1072 printf( win->GetClassInfo()->GetClassName() );
1076 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1077 event
.SetEventObject( win
);
1081 GdkModifierType state
= (GdkModifierType
)0;
1083 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1085 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
);
1086 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
);
1087 event
.m_altDown
= (state
& GDK_MOD1_MASK
);
1088 event
.m_metaDown
= (state
& GDK_MOD2_MASK
);
1089 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
);
1090 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
);
1091 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
);
1093 event
.m_x
= (long)x
;
1094 event
.m_y
= (long)y
;
1096 if (win
->GetEventHandler()->ProcessEvent( event
))
1098 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
1105 //-----------------------------------------------------------------------------
1106 // "value_changed" from m_vAdjust
1107 //-----------------------------------------------------------------------------
1109 static void gtk_window_vscroll_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1111 if (g_blockEventsOnDrag
) return;
1114 printf( "OnVScroll from " );
1115 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1116 printf( win->GetClassInfo()->GetClassName() );
1120 if (!win
->HasVMT()) return;
1122 float diff
= win
->m_vAdjust
->value
- win
->m_oldVerticalPos
;
1123 if (fabs(diff
) < 0.2) return;
1124 win
->m_oldVerticalPos
= win
->m_vAdjust
->value
;
1126 wxEventType command
= wxEVT_NULL
;
1128 float line_step
= win
->m_vAdjust
->step_increment
;
1129 float page_step
= win
->m_vAdjust
->page_increment
;
1131 if (win
->m_isScrolling
)
1133 command
= wxEVT_SCROLL_THUMBTRACK
;
1137 if (fabs(win
->m_vAdjust
->value
-win
->m_vAdjust
->lower
) < 0.2) command
= wxEVT_SCROLL_BOTTOM
;
1138 else if (fabs(win
->m_vAdjust
->value
-win
->m_vAdjust
->upper
) < 0.2) command
= wxEVT_SCROLL_TOP
;
1139 else if (fabs(diff
-line_step
) < 0.2) command
= wxEVT_SCROLL_LINEDOWN
;
1140 else if (fabs(diff
+line_step
) < 0.2) command
= wxEVT_SCROLL_LINEUP
;
1141 else if (fabs(diff
-page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEDOWN
;
1142 else if (fabs(diff
+page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEUP
;
1143 else command
= wxEVT_SCROLL_THUMBTRACK
;
1146 int value
= (int)(win
->m_vAdjust
->value
+0.5);
1148 wxScrollEvent
event( command
, win
->GetId(), value
, wxVERTICAL
);
1149 event
.SetEventObject( win
);
1150 win
->GetEventHandler()->ProcessEvent( event
);
1153 //-----------------------------------------------------------------------------
1154 // "value_changed" from m_hAdjust
1155 //-----------------------------------------------------------------------------
1157 static void gtk_window_hscroll_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1159 if (g_blockEventsOnDrag
) return;
1162 printf( "OnHScroll from " );
1163 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1164 printf( win->GetClassInfo()->GetClassName() );
1168 if (!win
->HasVMT()) return;
1170 float diff
= win
->m_hAdjust
->value
- win
->m_oldHorizontalPos
;
1171 if (fabs(diff
) < 0.2) return;
1172 win
->m_oldHorizontalPos
= win
->m_hAdjust
->value
;
1174 wxEventType command
= wxEVT_NULL
;
1176 float line_step
= win
->m_hAdjust
->step_increment
;
1177 float page_step
= win
->m_hAdjust
->page_increment
;
1179 if (win
->m_isScrolling
)
1181 command
= wxEVT_SCROLL_THUMBTRACK
;
1185 if (fabs(win
->m_hAdjust
->value
-win
->m_hAdjust
->lower
) < 0.2) command
= wxEVT_SCROLL_BOTTOM
;
1186 else if (fabs(win
->m_hAdjust
->value
-win
->m_hAdjust
->upper
) < 0.2) command
= wxEVT_SCROLL_TOP
;
1187 else if (fabs(diff
-line_step
) < 0.2) command
= wxEVT_SCROLL_LINEDOWN
;
1188 else if (fabs(diff
+line_step
) < 0.2) command
= wxEVT_SCROLL_LINEUP
;
1189 else if (fabs(diff
-page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEDOWN
;
1190 else if (fabs(diff
+page_step
) < 0.2) command
= wxEVT_SCROLL_PAGEUP
;
1191 else command
= wxEVT_SCROLL_THUMBTRACK
;
1194 int value
= (int)(win
->m_hAdjust
->value
+0.5);
1196 wxScrollEvent
event( command
, win
->GetId(), value
, wxHORIZONTAL
);
1197 event
.SetEventObject( win
);
1198 win
->GetEventHandler()->ProcessEvent( event
);
1201 //-----------------------------------------------------------------------------
1202 // "changed" from m_vAdjust
1203 //-----------------------------------------------------------------------------
1205 static void gtk_window_vscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1207 if (g_blockEventsOnDrag
) return;
1210 printf( "OnVScroll change from " );
1211 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1212 printf( win->GetClassInfo()->GetClassName() );
1216 if (!win
->HasVMT()) return;
1218 wxEventType command
= wxEVT_SCROLL_THUMBTRACK
;
1219 int value
= (int)(win
->m_vAdjust
->value
+0.5);
1221 wxScrollEvent
event( command
, win
->GetId(), value
, wxVERTICAL
);
1222 event
.SetEventObject( win
);
1223 win
->GetEventHandler()->ProcessEvent( event
);
1226 //-----------------------------------------------------------------------------
1227 // "changed" from m_hAdjust
1228 //-----------------------------------------------------------------------------
1230 static void gtk_window_hscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1232 if (g_blockEventsOnDrag
) return;
1235 printf( "OnHScroll change from " );
1236 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1237 printf( win->GetClassInfo()->GetClassName() );
1241 if (!win
->HasVMT()) return;
1243 wxEventType command
= wxEVT_SCROLL_THUMBTRACK
;
1244 int value
= (int)(win
->m_hAdjust
->value
+0.5);
1246 wxScrollEvent
event( command
, win
->GetId(), value
, wxHORIZONTAL
);
1247 event
.SetEventObject( win
);
1248 win
->GetEventHandler()->ProcessEvent( event
);
1251 //-----------------------------------------------------------------------------
1252 // "button_press_event" from scrollbar
1253 //-----------------------------------------------------------------------------
1255 static gint
gtk_scrollbar_button_press_callback( GtkRange
*WXUNUSED(widget
),
1256 GdkEventButton
*WXUNUSED(gdk_event
),
1259 // don't test here as we can release the mouse while being over
1260 // a different window then the slider
1262 // if (gdk_event->window != widget->slider) return FALSE;
1264 win
->m_isScrolling
= TRUE
;
1265 g_blockEventsOnScroll
= TRUE
;
1270 //-----------------------------------------------------------------------------
1271 // "button_release_event" from scrollbar
1272 //-----------------------------------------------------------------------------
1274 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
,
1275 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 GtkScrolledWindow
*s_window
= GTK_SCROLLED_WINDOW(win
->m_widget
);
1286 if (widget
== GTK_RANGE(s_window
->vscrollbar
))
1287 gtk_signal_emit_by_name( GTK_OBJECT(win
->m_hAdjust
), "value_changed" );
1289 gtk_signal_emit_by_name( GTK_OBJECT(win
->m_vAdjust
), "value_changed" );
1291 win
->m_isScrolling
= FALSE
;
1292 g_blockEventsOnScroll
= FALSE
;
1297 //-----------------------------------------------------------------------------
1298 // "realize" from m_widget
1299 //-----------------------------------------------------------------------------
1301 /* we cannot set colours, fonts and cursors before the widget has
1302 been realized, so we do this directly after realization */
1305 gtk_window_realized_callback( GtkWidget
*widget
, wxWindow
*win
)
1307 if (win
->m_font
!= *wxSWISS_FONT
)
1309 wxFont
font( win
->m_font
);
1310 win
->m_font
= wxNullFont
;
1311 win
->SetFont( font
);
1314 if (win
->m_backgroundColour
!= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
))
1316 wxColour
bg( win
->m_backgroundColour
);
1317 win
->m_backgroundColour
= wxNullColour
;
1318 win
->SetBackgroundColour( bg
);
1321 if (win
->m_foregroundColour
!= *wxBLACK
)
1323 wxColour
fg( win
->m_foregroundColour
);
1324 win
->m_foregroundColour
= wxNullColour
;
1325 win
->SetForegroundColour( fg
);
1331 //-----------------------------------------------------------------------------
1332 // InsertChild for wxWindow.
1333 //-----------------------------------------------------------------------------
1335 /* Callback for wxWindow. This very strange beast has to be used because
1336 * C++ has no virtual methods in a constructor. We have to emulate a
1337 * virtual function here as wxNotebook requires a different way to insert
1338 * a child in it. I had opted for creating a wxNotebookPage window class
1339 * which would have made this superfluous (such in the MDI window system),
1340 * but no-one was listening to me... */
1342 static void wxInsertChildInWindow( wxWindow
* parent
, wxWindow
* child
)
1344 gtk_myfixed_put( GTK_MYFIXED(parent
->m_wxwindow
),
1345 GTK_WIDGET(child
->m_widget
),
1349 gtk_widget_set_usize( GTK_WIDGET(child
->m_widget
),
1353 if (parent
->m_windowStyle
& wxTAB_TRAVERSAL
)
1355 /* we now allow a window to get the focus as long as it
1356 doesn't have any children. */
1357 GTK_WIDGET_UNSET_FLAGS( parent
->m_wxwindow
, GTK_CAN_FOCUS
);
1361 //-----------------------------------------------------------------------------
1363 //-----------------------------------------------------------------------------
1365 wxWindow
* wxGetActiveWindow()
1367 return g_focusWindow
;
1370 //-----------------------------------------------------------------------------
1372 //-----------------------------------------------------------------------------
1374 IMPLEMENT_DYNAMIC_CLASS(wxWindow
,wxEvtHandler
)
1376 BEGIN_EVENT_TABLE(wxWindow
, wxEvtHandler
)
1377 EVT_SIZE(wxWindow::OnSize
)
1378 EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged
)
1379 EVT_INIT_DIALOG(wxWindow::OnInitDialog
)
1380 EVT_KEY_DOWN(wxWindow::OnKeyDown
)
1383 void wxWindow::Init()
1387 m_widget
= (GtkWidget
*) NULL
;
1388 m_wxwindow
= (GtkWidget
*) NULL
;
1389 m_parent
= (wxWindow
*) NULL
;
1390 m_children
.DeleteContents( FALSE
);
1403 m_eventHandler
= this;
1404 m_windowValidator
= (wxValidator
*) NULL
;
1408 m_cursor
= (wxCursor
*) NULL
;
1409 m_font
= *wxSWISS_FONT
;
1411 m_windowName
= "noname";
1413 m_constraints
= (wxLayoutConstraints
*) NULL
;
1414 m_constraintsInvolvedIn
= (wxList
*) NULL
;
1415 m_windowSizer
= (wxSizer
*) NULL
;
1416 m_sizerParent
= (wxWindow
*) NULL
;
1417 m_autoLayout
= FALSE
;
1421 m_needParent
= TRUE
;
1423 m_hasScrolling
= FALSE
;
1424 m_isScrolling
= FALSE
;
1425 m_hAdjust
= (GtkAdjustment
*) NULL
;
1426 m_vAdjust
= (GtkAdjustment
*) NULL
;
1427 m_oldHorizontalPos
= 0.0;
1428 m_oldVerticalPos
= 0.0;
1433 #if wxUSE_DRAG_AND_DROP
1434 m_dropTarget
= (wxDropTarget
*) NULL
;
1437 m_scrollGC
= (GdkGC
*) NULL
;
1438 m_widgetStyle
= (GtkStyle
*) NULL
;
1440 m_insertCallback
= wxInsertChildInWindow
;
1442 m_clientObject
= (wxClientData
*) NULL
;
1443 m_clientData
= NULL
;
1445 m_isStaticBox
= FALSE
;
1446 m_acceptsFocus
= FALSE
;
1449 m_toolTip
= (wxToolTip
*) NULL
;
1450 #endif // wxUSE_TOOLTIPS
1453 wxWindow::wxWindow()
1458 wxWindow::wxWindow( wxWindow
*parent
, wxWindowID id
,
1459 const wxPoint
&pos
, const wxSize
&size
,
1460 long style
, const wxString
&name
)
1464 Create( parent
, id
, pos
, size
, style
, name
);
1467 bool wxWindow::Create( wxWindow
*parent
, wxWindowID id
,
1468 const wxPoint
&pos
, const wxSize
&size
,
1469 long style
, const wxString
&name
)
1471 wxASSERT_MSG( m_isWindow
, _T("Init() must have been called before!") );
1473 PreCreation( parent
, id
, pos
, size
, style
, name
);
1475 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
1476 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
1478 GtkScrolledWindow
*s_window
= GTK_SCROLLED_WINDOW(m_widget
);
1480 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
1481 scroll_class
->scrollbar_spacing
= 0;
1483 gtk_scrolled_window_set_policy( s_window
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
1485 m_oldHorizontalPos
= 0.0;
1486 m_oldVerticalPos
= 0.0;
1488 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(s_window
->hscrollbar
) );
1489 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(s_window
->vscrollbar
) );
1491 m_wxwindow
= gtk_myfixed_new();
1493 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
1495 #if (GTK_MINOR_VERSION > 0)
1496 GtkMyFixed
*myfixed
= GTK_MYFIXED(m_wxwindow
);
1498 if (m_windowStyle
& wxRAISED_BORDER
)
1500 gtk_myfixed_set_shadow_type( myfixed
, GTK_SHADOW_OUT
);
1502 else if (m_windowStyle
& wxSUNKEN_BORDER
)
1504 gtk_myfixed_set_shadow_type( myfixed
, GTK_SHADOW_IN
);
1508 gtk_myfixed_set_shadow_type( myfixed
, GTK_SHADOW_NONE
);
1511 GtkViewport
*viewport
= GTK_VIEWPORT(s_window
->viewport
);
1513 if (m_windowStyle
& wxRAISED_BORDER
)
1515 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_OUT
);
1517 else if (m_windowStyle
& wxSUNKEN_BORDER
)
1519 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_IN
);
1523 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_NONE
);
1527 if (m_windowStyle
& wxTAB_TRAVERSAL
)
1529 /* we now allow a window to get the focus as long as it
1530 doesn't have any children. */
1531 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
1532 m_acceptsFocus
= FALSE
;
1536 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
1537 m_acceptsFocus
= TRUE
;
1540 #if (GTK_MINOR_VERSION == 0)
1541 // shut the viewport up
1542 gtk_viewport_set_hadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1543 gtk_viewport_set_vadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1546 // I _really_ don't want scrollbars in the beginning
1547 m_vAdjust
->lower
= 0.0;
1548 m_vAdjust
->upper
= 1.0;
1549 m_vAdjust
->value
= 0.0;
1550 m_vAdjust
->step_increment
= 1.0;
1551 m_vAdjust
->page_increment
= 1.0;
1552 m_vAdjust
->page_size
= 5.0;
1553 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
1554 m_hAdjust
->lower
= 0.0;
1555 m_hAdjust
->upper
= 1.0;
1556 m_hAdjust
->value
= 0.0;
1557 m_hAdjust
->step_increment
= 1.0;
1558 m_hAdjust
->page_increment
= 1.0;
1559 m_hAdjust
->page_size
= 5.0;
1560 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
1562 // these handlers block mouse events to any window during scrolling
1563 // such as motion events and prevent GTK and wxWindows from fighting
1564 // over where the slider should be
1566 gtk_signal_connect( GTK_OBJECT(s_window
->vscrollbar
), "button_press_event",
1567 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
1569 gtk_signal_connect( GTK_OBJECT(s_window
->hscrollbar
), "button_press_event",
1570 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
1572 gtk_signal_connect( GTK_OBJECT(s_window
->vscrollbar
), "button_release_event",
1573 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
1575 gtk_signal_connect( GTK_OBJECT(s_window
->hscrollbar
), "button_release_event",
1576 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
1578 // these handlers get notified when screen updates are required either when
1579 // scrolling or when the window size (and therefore scrollbar configuration)
1582 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
1583 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
1584 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
1585 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
1587 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "changed",
1588 (GtkSignalFunc
) gtk_window_hscroll_change_callback
, (gpointer
) this );
1589 gtk_signal_connect(GTK_OBJECT(m_vAdjust
), "changed",
1590 (GtkSignalFunc
) gtk_window_vscroll_change_callback
, (gpointer
) this );
1592 gtk_widget_show( m_wxwindow
);
1594 if (m_parent
) m_parent
->AddChild( this );
1596 (m_parent
->m_insertCallback
)( m_parent
, this );
1605 wxWindow::~wxWindow()
1609 #if wxUSE_DRAG_AND_DROP
1612 delete m_dropTarget
;
1613 m_dropTarget
= (wxDropTarget
*) NULL
;
1621 m_toolTip
= (wxToolTip
*) NULL
;
1623 #endif // wxUSE_TOOLTIPS
1625 if (m_widget
) Show( FALSE
);
1629 if (m_parent
) m_parent
->RemoveChild( this );
1631 if (m_widgetStyle
) gtk_style_unref( m_widgetStyle
);
1633 if (m_scrollGC
) gdk_gc_unref( m_scrollGC
);
1635 if (m_wxwindow
) gtk_widget_destroy( m_wxwindow
);
1637 if (m_widget
) gtk_widget_destroy( m_widget
);
1639 if (m_cursor
) delete m_cursor
;
1641 DeleteRelatedConstraints();
1644 /* This removes any dangling pointers to this window
1645 * in other windows' constraintsInvolvedIn lists. */
1646 UnsetConstraints(m_constraints
);
1647 delete m_constraints
;
1648 m_constraints
= (wxLayoutConstraints
*) NULL
;
1653 delete m_windowSizer
;
1654 m_windowSizer
= (wxSizer
*) NULL
;
1656 /* If this is a child of a sizer, remove self from parent */
1657 if (m_sizerParent
) m_sizerParent
->RemoveChild((wxWindow
*)this);
1659 /* Just in case the window has been Closed, but
1660 * we're then deleting immediately: don't leave
1661 * dangling pointers. */
1662 wxPendingDelete
.DeleteObject(this);
1664 /* Just in case we've loaded a top-level window via
1665 * wxWindow::LoadNativeDialog but we weren't a dialog
1667 wxTopLevelWindows
.DeleteObject(this);
1669 if (m_windowValidator
) delete m_windowValidator
;
1671 if (m_clientObject
) delete m_clientObject
;
1674 void wxWindow::PreCreation( wxWindow
*parent
, wxWindowID id
,
1675 const wxPoint
&pos
, const wxSize
&size
,
1676 long style
, const wxString
&name
)
1678 wxASSERT_MSG( (!m_needParent
) || (parent
), _T("Need complete parent.") );
1680 m_widget
= (GtkWidget
*) NULL
;
1681 m_wxwindow
= (GtkWidget
*) NULL
;
1684 m_children
.DeleteContents( FALSE
);
1687 if (m_width
== -1) m_width
= 20;
1689 if (m_height
== -1) m_height
= 20;
1694 if (!m_needParent
) /* some reasonable defaults */
1698 m_x
= (gdk_screen_width () - m_width
) / 2;
1699 if (m_x
< 10) m_x
= 10;
1703 m_y
= (gdk_screen_height () - m_height
) / 2;
1704 if (m_y
< 10) m_y
= 10;
1715 m_eventHandler
= this;
1717 m_windowId
= id
== -1 ? wxNewId() : id
;
1721 m_cursor
= new wxCursor( wxCURSOR_ARROW
);
1722 m_font
= *wxSWISS_FONT
;
1723 m_backgroundColour
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
1724 m_foregroundColour
= *wxBLACK
;
1725 m_windowStyle
= style
;
1726 m_windowName
= name
;
1728 m_constraints
= (wxLayoutConstraints
*) NULL
;
1729 m_constraintsInvolvedIn
= (wxList
*) NULL
;
1730 m_windowSizer
= (wxSizer
*) NULL
;
1731 m_sizerParent
= (wxWindow
*) NULL
;
1732 m_autoLayout
= FALSE
;
1734 m_hasScrolling
= FALSE
;
1735 m_isScrolling
= FALSE
;
1736 m_hAdjust
= (GtkAdjustment
*) NULL
;
1737 m_vAdjust
= (GtkAdjustment
*) NULL
;
1738 m_oldHorizontalPos
= 0.0;
1739 m_oldVerticalPos
= 0.0;
1744 #if wxUSE_DRAG_AND_DROP
1745 m_dropTarget
= (wxDropTarget
*) NULL
;
1748 m_windowValidator
= (wxValidator
*) NULL
;
1749 m_scrollGC
= (GdkGC
*) NULL
;
1750 m_widgetStyle
= (GtkStyle
*) NULL
;
1752 m_clientObject
= (wxClientData
*)NULL
;
1753 m_clientData
= NULL
;
1755 m_isStaticBox
= FALSE
;
1758 m_toolTip
= (wxToolTip
*) NULL
;
1759 #endif // wxUSE_TOOLTIPS
1762 void wxWindow::PostCreation()
1764 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
1768 /* these get reported to wxWindows -> wxPaintEvent */
1769 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
1770 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
1772 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
1773 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
1775 #if (GTK_MINOR_VERSION > 0)
1776 /* these are called when the "sunken" or "raised" borders are drawn */
1777 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
1778 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
1780 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
1781 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
1785 ConnectWidget( GetConnectWidget() );
1787 /* we cannot set colours, fonts and cursors before the widget has
1788 been realized, so we do this directly after realization */
1790 gtk_signal_connect( GTK_OBJECT(m_widget
), "realize",
1791 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
1796 void wxWindow::ConnectWidget( GtkWidget
*widget
)
1798 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
1799 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
1801 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
1802 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
1804 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
1805 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
1807 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
1808 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
1810 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
1811 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
1813 gtk_signal_connect( GTK_OBJECT(widget
), "focus_in_event",
1814 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
1816 gtk_signal_connect( GTK_OBJECT(widget
), "focus_out_event",
1817 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
1819 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
1820 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
1822 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
1823 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
1826 bool wxWindow::HasVMT()
1831 bool wxWindow::Close( bool force
)
1833 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
1835 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
1836 event
.SetEventObject(this);
1837 event
.SetCanVeto(!force
);
1839 /* return FALSE if window wasn't closed because the application vetoed the
1841 return GetEventHandler()->ProcessEvent(event
) && !event
.GetVeto();
1844 bool wxWindow::Destroy()
1846 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
1853 bool wxWindow::DestroyChildren()
1856 while ((node
= m_children
.First()) != (wxNode
*)NULL
)
1859 if ((child
= (wxWindow
*)node
->Data()) != (wxWindow
*)NULL
)
1862 if (m_children
.Member(child
)) delete node
;
1868 void wxWindow::PrepareDC( wxDC
&WXUNUSED(dc
) )
1870 // are we to set fonts here ?
1873 void wxWindow::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
1875 wxASSERT_MSG( (m_widget
!= NULL
), _T("invalid window") );
1876 wxASSERT_MSG( (m_parent
!= NULL
), _T("wxWindow::SetSize requires parent.\n") );
1878 if (m_resizing
) return; /* I don't like recursions */
1881 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
1883 /* don't set the size for children of wxNotebook, just take the values. */
1891 int old_width
= m_width
;
1892 int old_height
= m_height
;
1894 if ((sizeFlags
& wxSIZE_USE_EXISTING
) == wxSIZE_USE_EXISTING
)
1896 if (x
!= -1) m_x
= x
;
1897 if (y
!= -1) m_y
= y
;
1898 if (width
!= -1) m_width
= width
;
1899 if (height
!= -1) m_height
= height
;
1909 if ((sizeFlags
& wxSIZE_AUTO_WIDTH
) == wxSIZE_AUTO_WIDTH
)
1911 if (width
== -1) m_width
= 80;
1914 if ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) == wxSIZE_AUTO_HEIGHT
)
1916 if (height
== -1) m_height
= 26;
1919 if ((m_minWidth
!= -1) && (m_width
< m_minWidth
)) m_width
= m_minWidth
;
1920 if ((m_minHeight
!= -1) && (m_height
< m_minHeight
)) m_height
= m_minHeight
;
1921 if ((m_maxWidth
!= -1) && (m_width
> m_maxWidth
)) m_width
= m_maxWidth
;
1922 if ((m_maxHeight
!= -1) && (m_height
> m_maxHeight
)) m_height
= m_maxHeight
;
1924 if (GTK_WIDGET_HAS_DEFAULT(m_widget
))
1926 /* the default button has a border around it */
1929 gtk_myfixed_move( GTK_MYFIXED(m_parent
->m_wxwindow
), m_widget
, m_x
-border
, m_y
-border
);
1931 gtk_widget_set_usize( m_widget
, m_width
+2*border
, m_height
+2*border
);
1935 gtk_myfixed_move( GTK_MYFIXED(m_parent
->m_wxwindow
), m_widget
, m_x
, m_y
);
1937 if ((old_width
!= m_width
) || (old_height
!= m_height
))
1938 gtk_widget_set_usize( m_widget
, m_width
, m_height
);
1944 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
1945 event
.SetEventObject( this );
1946 GetEventHandler()->ProcessEvent( event
);
1951 void wxWindow::OnInternalIdle()
1956 void wxWindow::GetSize( int *width
, int *height
) const
1958 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
1960 if (width
) (*width
) = m_width
;
1961 if (height
) (*height
) = m_height
;
1964 void wxWindow::DoSetClientSize( int width
, int height
)
1966 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
1970 SetSize( width
, height
);
1977 if (!m_hasScrolling
)
1979 GtkStyleClass
*window_class
= m_wxwindow
->style
->klass
;
1981 if ((m_windowStyle
& wxRAISED_BORDER
) ||
1982 (m_windowStyle
& wxSUNKEN_BORDER
))
1984 dw
+= 2 * window_class
->xthickness
;
1985 dh
+= 2 * window_class
->ythickness
;
1990 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
1991 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
1993 #if (GTK_MINOR_VERSION == 0)
1994 GtkWidget
*viewport
= scroll_window
->viewport
;
1995 GtkStyleClass
*viewport_class
= viewport
->style
->klass
;
1997 if ((m_windowStyle
& wxRAISED_BORDER
) ||
1998 (m_windowStyle
& wxSUNKEN_BORDER
))
2000 dw
+= 2 * viewport_class
->xthickness
;
2001 dh
+= 2 * viewport_class
->ythickness
;
2006 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2007 GtkWidget *vscrollbar = scroll_window->vscrollbar;
2009 we use this instead: range.slider_width = 11 + 2*2pts edge
2012 if (scroll_window
->vscrollbar_visible
)
2014 dw
+= 15; /* dw += vscrollbar->allocation.width; */
2015 dw
+= scroll_class
->scrollbar_spacing
;
2018 if (scroll_window
->hscrollbar_visible
)
2020 dh
+= 15; /* dh += hscrollbar->allocation.height; */
2021 dw
+= scroll_class
->scrollbar_spacing
;
2025 SetSize( width
+dw
, height
+dh
);
2029 void wxWindow::GetClientSize( int *width
, int *height
) const
2031 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2035 if (width
) (*width
) = m_width
;
2036 if (height
) (*height
) = m_height
;
2043 if (!m_hasScrolling
)
2045 GtkStyleClass
*window_class
= m_wxwindow
->style
->klass
;
2047 if ((m_windowStyle
& wxRAISED_BORDER
) ||
2048 (m_windowStyle
& wxSUNKEN_BORDER
))
2050 dw
+= 2 * window_class
->xthickness
;
2051 dh
+= 2 * window_class
->ythickness
;
2056 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
2057 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
2059 #if (GTK_MINOR_VERSION == 0)
2060 GtkWidget
*viewport
= scroll_window
->viewport
;
2061 GtkStyleClass
*viewport_class
= viewport
->style
->klass
;
2063 if ((m_windowStyle
& wxRAISED_BORDER
) ||
2064 (m_windowStyle
& wxSUNKEN_BORDER
))
2066 dw
+= 2 * viewport_class
->xthickness
;
2067 dh
+= 2 * viewport_class
->ythickness
;
2071 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2072 GtkWidget *vscrollbar = scroll_window->vscrollbar;
2074 we use this instead: range.slider_width = 11 + 2*2pts edge
2077 if (scroll_window
->vscrollbar_visible
)
2079 dw
+= 15; /* dw += vscrollbar->allocation.width; */
2080 dw
+= scroll_class
->scrollbar_spacing
;
2083 if (scroll_window
->hscrollbar_visible
)
2085 dh
+= 15; /* dh += hscrollbar->allocation.height; */
2086 dh
+= scroll_class
->scrollbar_spacing
;
2090 if (width
) (*width
) = m_width
- dw
;
2091 if (height
) (*height
) = m_height
- dh
;
2095 void wxWindow::GetPosition( int *x
, int *y
) const
2097 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2103 void wxWindow::ClientToScreen( int *x
, int *y
)
2105 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2107 if (!m_widget
->window
) return;
2109 GdkWindow
*source
= (GdkWindow
*) NULL
;
2111 source
= m_wxwindow
->window
;
2113 source
= m_widget
->window
;
2117 gdk_window_get_origin( source
, &org_x
, &org_y
);
2121 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2123 org_x
+= m_widget
->allocation
.x
;
2124 org_y
+= m_widget
->allocation
.y
;
2132 void wxWindow::ScreenToClient( int *x
, int *y
)
2134 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2136 if (!m_widget
->window
) return;
2138 GdkWindow
*source
= (GdkWindow
*) NULL
;
2140 source
= m_wxwindow
->window
;
2142 source
= m_widget
->window
;
2146 gdk_window_get_origin( source
, &org_x
, &org_y
);
2150 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2152 org_x
+= m_widget
->allocation
.x
;
2153 org_y
+= m_widget
->allocation
.y
;
2161 void wxWindow::Centre( int direction
)
2163 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2172 m_parent
->GetSize( &p_w
, &p_h
);
2173 if (direction
& wxHORIZONTAL
== wxHORIZONTAL
) x
= (p_w
- m_width
) / 2;
2174 if (direction
& wxVERTICAL
== wxVERTICAL
) y
= (p_h
- m_height
) / 2;
2178 if (direction
& wxHORIZONTAL
== wxHORIZONTAL
) x
= (gdk_screen_width () - m_width
) / 2;
2179 if (direction
& wxVERTICAL
== wxVERTICAL
) y
= (gdk_screen_height () - m_height
) / 2;
2185 void wxWindow::Fit()
2187 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2191 wxNode
*node
= m_children
.First();
2194 wxWindow
*win
= (wxWindow
*)node
->Data();
2196 win
->GetPosition(&wx
, &wy
);
2197 win
->GetSize(&ww
, &wh
);
2198 if (wx
+ ww
> maxX
) maxX
= wx
+ ww
;
2199 if (wy
+ wh
> maxY
) maxY
= wy
+ wh
;
2201 node
= node
->Next();
2204 SetClientSize(maxX
+ 7, maxY
+ 14);
2207 void wxWindow::SetSizeHints( int minW
, int minH
, int maxW
, int maxH
, int WXUNUSED(incW
), int WXUNUSED(incH
) )
2209 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2217 void wxWindow::OnSize( wxSizeEvent
&WXUNUSED(event
) )
2219 // if (GetAutoLayout()) Layout();
2222 bool wxWindow::Show( bool show
)
2224 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, _T("invalid window") );
2226 if (show
== m_isShown
) return TRUE
;
2229 gtk_widget_show( m_widget
);
2231 gtk_widget_hide( m_widget
);
2238 void wxWindow::Enable( bool enable
)
2240 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2242 m_isEnabled
= enable
;
2244 gtk_widget_set_sensitive( m_widget
, enable
);
2245 if (m_wxwindow
) gtk_widget_set_sensitive( m_wxwindow
, enable
);
2248 int wxWindow::GetCharHeight() const
2250 wxCHECK_MSG( (m_widget
!= NULL
), 12, _T("invalid window") );
2252 wxCHECK_MSG( m_font
.Ok(), 12, _T("invalid font") );
2254 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
2256 return font
->ascent
+ font
->descent
;
2259 int wxWindow::GetCharWidth() const
2261 wxCHECK_MSG( (m_widget
!= NULL
), 8, _T("invalid window") );
2263 wxCHECK_MSG( m_font
.Ok(), 8, _T("invalid font") );
2265 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
2267 return gdk_string_width( font
, "H" );
2270 void wxWindow::GetTextExtent( const wxString
& string
, int *x
, int *y
,
2271 int *descent
, int *externalLeading
, const wxFont
*theFont
, bool WXUNUSED(use16
) ) const
2273 wxFont fontToUse
= m_font
;
2274 if (theFont
) fontToUse
= *theFont
;
2276 wxCHECK_RET( fontToUse
.Ok(), _T("invalid font") );
2278 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
2279 if (x
) (*x
) = gdk_string_width( font
, string
.mbc_str() );
2280 if (y
) (*y
) = font
->ascent
+ font
->descent
;
2281 if (descent
) (*descent
) = font
->descent
;
2282 if (externalLeading
) (*externalLeading
) = 0; // ??
2285 void wxWindow::MakeModal( bool modal
)
2289 // Disable all other windows
2290 if (this->IsKindOf(CLASSINFO(wxDialog
)) || this->IsKindOf(CLASSINFO(wxFrame
)))
2292 wxNode
*node
= wxTopLevelWindows
.First();
2295 wxWindow
*win
= (wxWindow
*)node
->Data();
2296 if (win
!= this) win
->Enable(!modal
);
2298 node
= node
->Next();
2303 void wxWindow::OnKeyDown( wxKeyEvent
&event
)
2305 event
.SetEventType( wxEVT_CHAR
);
2307 if (!GetEventHandler()->ProcessEvent( event
))
2313 void wxWindow::SetFocus()
2315 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2317 GtkWidget
*connect_widget
= GetConnectWidget();
2320 if (GTK_WIDGET_CAN_FOCUS(connect_widget
) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ )
2322 gtk_widget_grab_focus (connect_widget
);
2324 else if (GTK_IS_CONTAINER(connect_widget
))
2326 gtk_container_focus( GTK_CONTAINER(connect_widget
), GTK_DIR_TAB_FORWARD
);
2334 wxWindow
*wxWindow::FindFocus()
2336 return g_focusWindow
;
2339 bool wxWindow::AcceptsFocus() const
2341 return IsEnabled() && IsShown() && m_acceptsFocus
;
2344 void wxWindow::AddChild( wxWindow
*child
)
2346 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2347 wxCHECK_RET( (child
!= NULL
), _T("invalid child") );
2349 m_children
.Append( child
);
2352 wxWindow
*wxWindow::ReParent( wxWindow
*newParent
)
2354 wxCHECK_MSG( (m_widget
!= NULL
), (wxWindow
*) NULL
, _T("invalid window") );
2356 wxWindow
*oldParent
= GetParent();
2358 if (oldParent
) oldParent
->RemoveChild( this );
2360 gtk_widget_unparent( m_widget
);
2364 newParent
->AddChild( this );
2365 (newParent
->m_insertCallback
)( newParent
, this );
2371 void wxWindow::RemoveChild( wxWindow
*child
)
2373 m_children
.DeleteObject( child
);
2374 child
->m_parent
= (wxWindow
*) NULL
;
2377 void wxWindow::SetReturnCode( int retCode
)
2379 m_retCode
= retCode
;
2382 int wxWindow::GetReturnCode()
2387 void wxWindow::Raise()
2389 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2391 if (!m_widget
->window
) return;
2393 if (m_widget
) gdk_window_raise( m_widget
->window
);
2396 void wxWindow::Lower()
2398 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2400 if (!m_widget
->window
) return;
2402 if (m_widget
) gdk_window_lower( m_widget
->window
);
2405 wxEvtHandler
*wxWindow::GetEventHandler() const
2407 return m_eventHandler
;
2410 void wxWindow::SetEventHandler( wxEvtHandler
*handler
)
2412 m_eventHandler
= handler
;
2415 void wxWindow::PushEventHandler(wxEvtHandler
*handler
)
2417 handler
->SetNextHandler(GetEventHandler());
2418 SetEventHandler(handler
);
2421 wxEvtHandler
*wxWindow::PopEventHandler(bool deleteHandler
)
2423 if (GetEventHandler())
2425 wxEvtHandler
*handlerA
= GetEventHandler();
2426 wxEvtHandler
*handlerB
= handlerA
->GetNextHandler();
2427 handlerA
->SetNextHandler((wxEvtHandler
*) NULL
);
2428 SetEventHandler(handlerB
);
2432 return (wxEvtHandler
*) NULL
;
2438 return (wxEvtHandler
*) NULL
;
2441 wxValidator
*wxWindow::GetValidator()
2443 return m_windowValidator
;
2446 void wxWindow::SetValidator( const wxValidator
& validator
)
2448 if (m_windowValidator
) delete m_windowValidator
;
2449 m_windowValidator
= validator
.Clone();
2450 if (m_windowValidator
) m_windowValidator
->SetWindow(this);
2453 void wxWindow::SetClientObject( wxClientData
*data
)
2455 if (m_clientObject
) delete m_clientObject
;
2456 m_clientObject
= data
;
2459 wxClientData
*wxWindow::GetClientObject()
2461 return m_clientObject
;
2464 void wxWindow::SetClientData( void *data
)
2466 m_clientData
= data
;
2469 void *wxWindow::GetClientData()
2471 return m_clientData
;
2474 bool wxWindow::IsBeingDeleted()
2479 void wxWindow::SetId( wxWindowID id
)
2484 wxWindowID
wxWindow::GetId() const
2489 void wxWindow::SetCursor( const wxCursor
&cursor
)
2491 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2495 if (cursor
== *m_cursor
) return;
2500 *m_cursor
= *wxSTANDARD_CURSOR
;
2503 if (!m_widget
->window
) return;
2505 gdk_window_set_cursor( m_widget
->window
, m_cursor
->GetCursor() );
2507 if ((m_wxwindow
) && (m_wxwindow
->window
))
2508 gdk_window_set_cursor( m_wxwindow
->window
, m_cursor
->GetCursor() );
2511 void wxWindow::WarpPointer( int WXUNUSED(x
), int WXUNUSED(y
) )
2516 void wxWindow::Refresh( bool eraseBackground
, const wxRect
*rect
)
2518 wxCHECK_RET( (m_widget
!= NULL
), _T("invalid window") );
2520 if (!m_widget
->window
) return;
2522 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
2526 gdk_window_clear_area( m_wxwindow
->window
,
2528 rect
->width
, rect
->height
);
2532 gdk_window_clear( m_wxwindow
->window
);
2539 gtk_widget_draw( m_wxwindow
, (GdkRectangle
*) NULL
);
2541 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
2545 GdkRectangle gdk_rect
;
2546 gdk_rect
.x
= rect
->x
;
2547 gdk_rect
.y
= rect
->y
;
2548 gdk_rect
.width
= rect
->width
;
2549 gdk_rect
.height
= rect
->height
;
2552 gtk_widget_draw( m_wxwindow
, &gdk_rect
);
2554 gtk_widget_draw( m_widget
, &gdk_rect
);
2558 wxRegion
wxWindow::GetUpdateRegion() const
2560 return m_updateRegion
;
2563 bool wxWindow::IsExposed( int x
, int y
) const
2565 return (m_updateRegion
.Contains( x
, y
) != wxOutRegion
);
2568 bool wxWindow::IsExposed( int x
, int y
, int w
, int h
) const
2570 return (m_updateRegion
.Contains( x
, y
, w
, h
) != wxOutRegion
);
2573 bool wxWindow::IsExposed( const wxPoint
& pt
) const
2575 return (m_updateRegion
.Contains( pt
.x
, pt
.y
) != wxOutRegion
);
2578 bool wxWindow::IsExposed( const wxRect
& rect
) const
2580 return (m_updateRegion
.Contains( rect
.x
, rect
.y
, rect
.width
, rect
.height
) != wxOutRegion
);
2583 void wxWindow::Clear()
2585 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2587 if (!m_widget
->window
) return;
2589 if (m_wxwindow
&& m_wxwindow
->window
)
2591 gdk_window_clear( m_wxwindow
->window
);
2596 void wxWindow::SetToolTip( const wxString
&tip
)
2600 m_toolTip
->SetTip( tip
);
2604 SetToolTip( new wxToolTip( tip
) );
2607 // setting empty tooltip text does not remove the tooltip any more for
2608 // wxMSW compatibility - use SetToolTip((wxToolTip *)NULL) for this
2611 void wxWindow::SetToolTip( wxToolTip
*tip
)
2615 m_toolTip
->SetTip( (char*) NULL
);
2622 m_toolTip
->Apply( this );
2625 void wxWindow::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
2627 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxConv_current
->cWX2MB(tip
), (gchar
*) NULL
);
2629 #endif // wxUSE_TOOLTIPS
2631 wxColour
wxWindow::GetBackgroundColour() const
2633 return m_backgroundColour
;
2636 void wxWindow::SetBackgroundColour( const wxColour
&colour
)
2638 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2640 if (m_backgroundColour
== colour
) return;
2642 m_backgroundColour
= colour
;
2643 if (!m_backgroundColour
.Ok()) return;
2645 if (!m_widget
->window
) return;
2647 if (m_wxwindow
&& m_wxwindow
->window
)
2649 /* wxMSW doesn't clear the window here. I don't do that
2650 either to provide compatibility. call Clear() to do
2653 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( m_wxwindow
->window
) );
2654 gdk_window_set_background( m_wxwindow
->window
, m_backgroundColour
.GetColor() );
2657 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
2659 if (sysbg
.Red() == colour
.Red() &&
2660 sysbg
.Green() == colour
.Green() &&
2661 sysbg
.Blue() == colour
.Blue())
2663 m_backgroundColour
= wxNullColour
;
2665 m_backgroundColour
= sysbg
;
2673 wxColour
wxWindow::GetForegroundColour() const
2675 return m_foregroundColour
;
2678 void wxWindow::SetForegroundColour( const wxColour
&colour
)
2680 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2682 if (m_foregroundColour
== colour
) return;
2684 m_foregroundColour
= colour
;
2685 if (!m_foregroundColour
.Ok()) return;
2687 if (!m_widget
->window
) return;
2689 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
2690 if (sysbg
.Red() == colour
.Red() &&
2691 sysbg
.Green() == colour
.Green() &&
2692 sysbg
.Blue() == colour
.Blue())
2694 m_backgroundColour
= wxNullColour
;
2696 m_backgroundColour
= sysbg
;
2704 GtkStyle
*wxWindow::GetWidgetStyle()
2706 if (m_widgetStyle
) gtk_style_unref( m_widgetStyle
);
2710 gtk_widget_get_style( m_widget
) );
2712 return m_widgetStyle
;
2715 void wxWindow::SetWidgetStyle()
2717 GtkStyle
*style
= GetWidgetStyle();
2719 gdk_font_unref( style
->font
);
2720 style
->font
= gdk_font_ref( m_font
.GetInternalFont( 1.0 ) );
2722 if (m_foregroundColour
.Ok())
2724 m_foregroundColour
.CalcPixel( gdk_window_get_colormap( m_widget
->window
) );
2725 style
->fg
[GTK_STATE_NORMAL
] = *m_foregroundColour
.GetColor();
2726 style
->fg
[GTK_STATE_PRELIGHT
] = *m_foregroundColour
.GetColor();
2727 style
->fg
[GTK_STATE_ACTIVE
] = *m_foregroundColour
.GetColor();
2730 if (m_backgroundColour
.Ok())
2732 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( m_widget
->window
) );
2733 style
->bg
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
2734 style
->base
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
2735 style
->bg
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
2736 style
->base
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
2737 style
->bg
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
2738 style
->base
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
2739 style
->bg
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
2740 style
->base
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
2744 void wxWindow::ApplyWidgetStyle()
2748 bool wxWindow::Validate()
2750 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2752 wxNode
*node
= m_children
.First();
2755 wxWindow
*child
= (wxWindow
*)node
->Data();
2756 if (child
->GetValidator() && /* child->GetValidator()->Ok() && */ !child
->GetValidator()->Validate(this))
2760 node
= node
->Next();
2765 bool wxWindow::TransferDataToWindow()
2767 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2769 wxNode
*node
= m_children
.First();
2772 wxWindow
*child
= (wxWindow
*)node
->Data();
2773 if (child
->GetValidator() && /* child->GetValidator()->Ok() && */
2774 !child
->GetValidator()->TransferToWindow() )
2776 wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK
|wxICON_EXCLAMATION
);
2779 node
= node
->Next();
2784 bool wxWindow::TransferDataFromWindow()
2786 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2788 wxNode
*node
= m_children
.First();
2791 wxWindow
*child
= (wxWindow
*)node
->Data();
2792 if ( child
->GetValidator() && /* child->GetValidator()->Ok() && */ !child
->GetValidator()->TransferFromWindow() )
2796 node
= node
->Next();
2801 void wxWindow::SetAcceleratorTable( const wxAcceleratorTable
& accel
)
2803 m_acceleratorTable
= accel
;
2806 void wxWindow::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2808 TransferDataToWindow();
2811 void wxWindow::InitDialog()
2813 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2815 wxInitDialogEvent
event(GetId());
2816 event
.SetEventObject( this );
2817 GetEventHandler()->ProcessEvent(event
);
2820 static void SetInvokingWindow( wxMenu
*menu
, wxWindow
*win
)
2822 menu
->SetInvokingWindow( win
);
2823 wxNode
*node
= menu
->GetItems().First();
2826 wxMenuItem
*menuitem
= (wxMenuItem
*)node
->Data();
2827 if (menuitem
->IsSubMenu())
2829 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
2831 node
= node
->Next();
2835 static gint gs_pop_x
= 0;
2836 static gint gs_pop_y
= 0;
2838 static void pop_pos_callback( GtkMenu
*menu
, gint
*x
, gint
*y
, wxWindow
*win
)
2840 win
->ClientToScreen( &gs_pop_x
, &gs_pop_y
);
2845 bool wxWindow::PopupMenu( wxMenu
*menu
, int x
, int y
)
2847 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, _T("invalid window") );
2849 wxCHECK_MSG( menu
!= NULL
, FALSE
, _T("invalid popup-menu") );
2851 SetInvokingWindow( menu
, this );
2859 GTK_MENU(menu
->m_menu
),
2860 (GtkWidget
*) NULL
, // parent menu shell
2861 (GtkWidget
*) NULL
, // parent menu item
2862 (GtkMenuPositionFunc
) pop_pos_callback
,
2863 (gpointer
) this, // client data
2864 0, // button used to activate it
2865 0 //gs_timeLastClick // the time of activation
2870 #if wxUSE_DRAG_AND_DROP
2872 void wxWindow::SetDropTarget( wxDropTarget
*dropTarget
)
2874 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2876 GtkWidget
*dnd_widget
= GetConnectWidget();
2878 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
2880 if (m_dropTarget
) delete m_dropTarget
;
2881 m_dropTarget
= dropTarget
;
2883 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
2886 wxDropTarget
*wxWindow::GetDropTarget() const
2888 return m_dropTarget
;
2893 GtkWidget
* wxWindow::GetConnectWidget()
2895 GtkWidget
*connect_widget
= m_widget
;
2896 if (m_wxwindow
) connect_widget
= m_wxwindow
;
2898 return connect_widget
;
2901 bool wxWindow::IsOwnGtkWindow( GdkWindow
*window
)
2903 if (m_wxwindow
) return (window
== m_wxwindow
->window
);
2904 return (window
== m_widget
->window
);
2907 void wxWindow::SetFont( const wxFont
&font
)
2909 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2911 if (m_font
== font
) return;
2913 if (((wxFont
*)&font
)->Ok())
2916 m_font
= *wxSWISS_FONT
;
2918 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
2919 if (sysbg
.Red() == m_backgroundColour
.Red() &&
2920 sysbg
.Green() == m_backgroundColour
.Green() &&
2921 sysbg
.Blue() == m_backgroundColour
.Blue())
2923 m_backgroundColour
= wxNullColour
;
2925 m_backgroundColour
= sysbg
;
2933 void wxWindow::SetWindowStyleFlag( long flag
)
2935 m_windowStyle
= flag
;
2938 long wxWindow::GetWindowStyleFlag() const
2940 return m_windowStyle
;
2943 void wxWindow::CaptureMouse()
2945 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2947 wxCHECK_RET( g_capturing
== FALSE
, _T("CaptureMouse called twice") );
2949 if (!m_widget
->window
) return;
2951 GtkWidget
*connect_widget
= GetConnectWidget();
2952 gtk_grab_add( connect_widget
);
2953 gdk_pointer_grab( connect_widget
->window
, FALSE
,
2955 (GDK_BUTTON_PRESS_MASK
|
2956 GDK_BUTTON_RELEASE_MASK
|
2957 GDK_POINTER_MOTION_MASK
),
2964 void wxWindow::ReleaseMouse()
2966 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
2968 wxCHECK_RET( g_capturing
== TRUE
, _T("ReleaseMouse called twice") );
2970 if (!m_widget
->window
) return;
2972 GtkWidget
*connect_widget
= GetConnectWidget();
2973 gtk_grab_remove( connect_widget
);
2974 gdk_pointer_ungrab ( GDK_CURRENT_TIME
);
2975 g_capturing
= FALSE
;
2978 void wxWindow::SetTitle( const wxString
&WXUNUSED(title
) )
2982 wxString
wxWindow::GetTitle() const
2984 return (wxString
&)m_windowName
;
2987 wxString
wxWindow::GetLabel() const
2992 void wxWindow::SetName( const wxString
&name
)
2994 m_windowName
= name
;
2997 wxString
wxWindow::GetName() const
2999 return (wxString
&)m_windowName
;
3002 bool wxWindow::IsShown() const
3007 bool wxWindow::IsRetained()
3012 wxWindow
*wxWindow::FindWindow( long id
)
3014 if (id
== m_windowId
) return this;
3015 wxNode
*node
= m_children
.First();
3018 wxWindow
*child
= (wxWindow
*)node
->Data();
3019 wxWindow
*res
= child
->FindWindow( id
);
3020 if (res
) return res
;
3021 node
= node
->Next();
3023 return (wxWindow
*) NULL
;
3026 wxWindow
*wxWindow::FindWindow( const wxString
& name
)
3028 if (name
== m_windowName
) return this;
3029 wxNode
*node
= m_children
.First();
3032 wxWindow
*child
= (wxWindow
*)node
->Data();
3033 wxWindow
*res
= child
->FindWindow( name
);
3034 if (res
) return res
;
3035 node
= node
->Next();
3037 return (wxWindow
*) NULL
;
3040 void wxWindow::SetScrollbar( int orient
, int pos
, int thumbVisible
,
3041 int range
, bool refresh
)
3043 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
3045 wxCHECK_RET( m_wxwindow
!= NULL
, _T("window needs client area for scrolling") );
3047 m_hasScrolling
= TRUE
;
3049 if (orient
== wxHORIZONTAL
)
3051 float fpos
= (float)pos
;
3052 float frange
= (float)range
;
3053 float fthumb
= (float)thumbVisible
;
3054 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
3055 if (fpos
< 0.0) fpos
= 0.0;
3057 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
3058 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
3060 SetScrollPos( orient
, pos
, refresh
);
3064 m_oldHorizontalPos
= fpos
;
3066 m_hAdjust
->lower
= 0.0;
3067 m_hAdjust
->upper
= frange
;
3068 m_hAdjust
->value
= fpos
;
3069 m_hAdjust
->step_increment
= 1.0;
3070 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
3071 m_hAdjust
->page_size
= fthumb
;
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_vAdjust
->upper
) < 0.2) &&
3082 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
3084 SetScrollPos( orient
, pos
, refresh
);
3088 m_oldVerticalPos
= fpos
;
3090 m_vAdjust
->lower
= 0.0;
3091 m_vAdjust
->upper
= frange
;
3092 m_vAdjust
->value
= fpos
;
3093 m_vAdjust
->step_increment
= 1.0;
3094 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
3095 m_vAdjust
->page_size
= fthumb
;
3098 if (m_wxwindow
->window
)
3100 if (orient
== wxHORIZONTAL
)
3101 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
3103 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
3105 gtk_widget_set_usize( m_widget
, m_width
, m_height
);
3109 void wxWindow::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
3111 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
3113 wxCHECK_RET( m_wxwindow
!= NULL
, _T("window needs client area for scrolling") );
3115 if (orient
== wxHORIZONTAL
)
3117 float fpos
= (float)pos
;
3118 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
3119 if (fpos
< 0.0) fpos
= 0.0;
3120 m_oldHorizontalPos
= fpos
;
3122 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
3123 m_hAdjust
->value
= fpos
;
3127 float fpos
= (float)pos
;
3128 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
3129 if (fpos
< 0.0) fpos
= 0.0;
3130 m_oldVerticalPos
= fpos
;
3132 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
3133 m_vAdjust
->value
= fpos
;
3138 if (m_wxwindow
->window
)
3140 if (orient
== wxHORIZONTAL
)
3141 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
3143 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
3148 int wxWindow::GetScrollThumb( int orient
) const
3150 wxCHECK_MSG( m_widget
!= NULL
, 0, _T("invalid window") );
3152 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, _T("window needs client area for scrolling") );
3154 if (orient
== wxHORIZONTAL
)
3155 return (int)(m_hAdjust
->page_size
+0.5);
3157 return (int)(m_vAdjust
->page_size
+0.5);
3160 int wxWindow::GetScrollPos( int orient
) const
3162 wxCHECK_MSG( m_widget
!= NULL
, 0, _T("invalid window") );
3164 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, _T("window needs client area for scrolling") );
3166 if (orient
== wxHORIZONTAL
)
3167 return (int)(m_hAdjust
->value
+0.5);
3169 return (int)(m_vAdjust
->value
+0.5);
3172 int wxWindow::GetScrollRange( 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
->upper
+0.5);
3181 return (int)(m_vAdjust
->upper
+0.5);
3184 void wxWindow::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
3186 wxCHECK_RET( m_widget
!= NULL
, _T("invalid window") );
3188 wxCHECK_RET( m_wxwindow
!= NULL
, _T("window needs client area for scrolling") );
3190 wxNode
*node
= m_children
.First();
3193 wxWindow
*child
= (wxWindow
*) node
->Data();
3194 child
->Move( child
->m_x
+ dx
, child
->m_y
+ dy
);
3195 node
= node
->Next();
3200 GetClientSize( &cw
, &ch
);
3202 int w
= cw
- abs(dx
);
3203 int h
= ch
- abs(dy
);
3204 if ((h
< 0) || (w
< 0))
3211 if (dx
< 0) s_x
= -dx
;
3212 if (dy
< 0) s_y
= -dy
;
3215 if (dx
> 0) d_x
= dx
;
3216 if (dy
> 0) d_y
= dy
;
3220 m_scrollGC
= gdk_gc_new( m_wxwindow
->window
);
3221 gdk_gc_set_exposures( m_scrollGC
, TRUE
);
3224 gdk_window_copy_area( m_wxwindow
->window
, m_scrollGC
, d_x
, d_y
,
3225 m_wxwindow
->window
, s_x
, s_y
, w
, h
);
3228 if (dx
< 0) rect
.x
= cw
+dx
; else rect
.x
= 0;
3229 if (dy
< 0) rect
.y
= ch
+dy
; else rect
.y
= 0;
3230 if (dy
!= 0) rect
.width
= cw
; else rect
.width
= abs(dx
);
3231 if (dx
!= 0) rect
.height
= ch
; else rect
.height
= abs(dy
);
3233 Refresh( TRUE
, &rect
);
3236 //-------------------------------------------------------------------------------------
3238 //-------------------------------------------------------------------------------------
3240 wxLayoutConstraints
*wxWindow::GetConstraints() const
3242 return m_constraints
;
3245 void wxWindow::SetConstraints( wxLayoutConstraints
*constraints
)
3249 UnsetConstraints(m_constraints
);
3250 delete m_constraints
;
3252 m_constraints
= constraints
;
3255 // Make sure other windows know they're part of a 'meaningful relationship'
3256 if (m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this))
3257 m_constraints
->left
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3258 if (m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this))
3259 m_constraints
->top
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3260 if (m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this))
3261 m_constraints
->right
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3262 if (m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this))
3263 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3264 if (m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this))
3265 m_constraints
->width
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3266 if (m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this))
3267 m_constraints
->height
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3268 if (m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this))
3269 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3270 if (m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this))
3271 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference((wxWindow
*)this);
3277 void wxWindow::SetAutoLayout( bool autoLayout
)
3279 m_autoLayout
= autoLayout
;
3282 bool wxWindow::GetAutoLayout() const
3284 return m_autoLayout
;
3287 wxSizer
*wxWindow::GetSizer() const
3289 return m_windowSizer
;
3292 void wxWindow::SetSizerParent( wxWindow
*win
)
3294 m_sizerParent
= win
;
3297 wxWindow
*wxWindow::GetSizerParent() const
3299 return m_sizerParent
;
3302 // This removes any dangling pointers to this window
3303 // in other windows' constraintsInvolvedIn lists.
3304 void wxWindow::UnsetConstraints(wxLayoutConstraints
*c
)
3308 if (c
->left
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this))
3309 c
->left
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3310 if (c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this))
3311 c
->top
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3312 if (c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this))
3313 c
->right
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3314 if (c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this))
3315 c
->bottom
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3316 if (c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this))
3317 c
->width
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3318 if (c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this))
3319 c
->height
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3320 if (c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this))
3321 c
->centreX
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3322 if (c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this))
3323 c
->centreY
.GetOtherWindow()->RemoveConstraintReference((wxWindow
*)this);
3327 // Back-pointer to other windows we're involved with, so if we delete
3328 // this window, we must delete any constraints we're involved with.
3329 void wxWindow::AddConstraintReference(wxWindow
*otherWin
)
3331 if (!m_constraintsInvolvedIn
)
3332 m_constraintsInvolvedIn
= new wxList
;
3333 if (!m_constraintsInvolvedIn
->Member(otherWin
))
3334 m_constraintsInvolvedIn
->Append(otherWin
);
3337 // REMOVE back-pointer to other windows we're involved with.
3338 void wxWindow::RemoveConstraintReference(wxWindow
*otherWin
)
3340 if (m_constraintsInvolvedIn
)
3341 m_constraintsInvolvedIn
->DeleteObject(otherWin
);
3344 // Reset any constraints that mention this window
3345 void wxWindow::DeleteRelatedConstraints()
3347 if (m_constraintsInvolvedIn
)
3349 wxNode
*node
= m_constraintsInvolvedIn
->First();
3352 wxWindow
*win
= (wxWindow
*)node
->Data();
3353 wxNode
*next
= node
->Next();
3354 wxLayoutConstraints
*constr
= win
->GetConstraints();
3356 // Reset any constraints involving this window
3359 constr
->left
.ResetIfWin((wxWindow
*)this);
3360 constr
->top
.ResetIfWin((wxWindow
*)this);
3361 constr
->right
.ResetIfWin((wxWindow
*)this);
3362 constr
->bottom
.ResetIfWin((wxWindow
*)this);
3363 constr
->width
.ResetIfWin((wxWindow
*)this);
3364 constr
->height
.ResetIfWin((wxWindow
*)this);
3365 constr
->centreX
.ResetIfWin((wxWindow
*)this);
3366 constr
->centreY
.ResetIfWin((wxWindow
*)this);
3371 delete m_constraintsInvolvedIn
;
3372 m_constraintsInvolvedIn
= (wxList
*) NULL
;
3376 void wxWindow::SetSizer(wxSizer
*sizer
)
3378 m_windowSizer
= sizer
;
3380 sizer
->SetSizerParent((wxWindow
*)this);
3387 bool wxWindow::Layout()
3389 if (GetConstraints())
3392 GetClientSize(&w
, &h
);
3393 GetConstraints()->width
.SetValue(w
);
3394 GetConstraints()->height
.SetValue(h
);
3397 // If top level (one sizer), evaluate the sizer's constraints.
3401 GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated
3402 GetSizer()->LayoutPhase1(&noChanges
);
3403 GetSizer()->LayoutPhase2(&noChanges
);
3404 GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
3409 // Otherwise, evaluate child constraints
3410 ResetConstraints(); // Mark all constraints as unevaluated
3411 DoPhase(1); // Just one phase need if no sizers involved
3413 SetConstraintSizes(); // Recursively set the real window sizes
3419 // Do a phase of evaluating constraints:
3420 // the default behaviour. wxSizers may do a similar
3421 // thing, but also impose their own 'constraints'
3422 // and order the evaluation differently.
3423 bool wxWindow::LayoutPhase1(int *noChanges
)
3425 wxLayoutConstraints
*constr
= GetConstraints();
3428 return constr
->SatisfyConstraints((wxWindow
*)this, noChanges
);
3434 bool wxWindow::LayoutPhase2(int *noChanges
)
3444 // Do a phase of evaluating child constraints
3445 bool wxWindow::DoPhase(int phase
)
3447 int noIterations
= 0;
3448 int maxIterations
= 500;
3452 while ((noChanges
> 0) && (noIterations
< maxIterations
))
3456 wxNode
*node
= m_children
.First();
3459 wxWindow
*child
= (wxWindow
*)node
->Data();
3460 if (!child
->IsKindOf(CLASSINFO(wxFrame
)) && !child
->IsKindOf(CLASSINFO(wxDialog
)))
3462 wxLayoutConstraints
*constr
= child
->GetConstraints();
3465 if (succeeded
.Member(child
))
3470 int tempNoChanges
= 0;
3471 bool success
= ( (phase
== 1) ? child
->LayoutPhase1(&tempNoChanges
) : child
->LayoutPhase2(&tempNoChanges
) ) ;
3472 noChanges
+= tempNoChanges
;
3475 succeeded
.Append(child
);
3480 node
= node
->Next();
3487 void wxWindow::ResetConstraints()
3489 wxLayoutConstraints
*constr
= GetConstraints();
3492 constr
->left
.SetDone(FALSE
);
3493 constr
->top
.SetDone(FALSE
);
3494 constr
->right
.SetDone(FALSE
);
3495 constr
->bottom
.SetDone(FALSE
);
3496 constr
->width
.SetDone(FALSE
);
3497 constr
->height
.SetDone(FALSE
);
3498 constr
->centreX
.SetDone(FALSE
);
3499 constr
->centreY
.SetDone(FALSE
);
3501 wxNode
*node
= m_children
.First();
3504 wxWindow
*win
= (wxWindow
*)node
->Data();
3505 if (!win
->IsKindOf(CLASSINFO(wxFrame
)) && !win
->IsKindOf(CLASSINFO(wxDialog
)))
3506 win
->ResetConstraints();
3507 node
= node
->Next();
3511 // Need to distinguish between setting the 'fake' size for
3512 // windows and sizers, and setting the real values.
3513 void wxWindow::SetConstraintSizes(bool recurse
)
3515 wxLayoutConstraints
*constr
= GetConstraints();
3516 if (constr
&& constr
->left
.GetDone() && constr
->right
.GetDone() &&
3517 constr
->width
.GetDone() && constr
->height
.GetDone())
3519 int x
= constr
->left
.GetValue();
3520 int y
= constr
->top
.GetValue();
3521 int w
= constr
->width
.GetValue();
3522 int h
= constr
->height
.GetValue();
3524 // If we don't want to resize this window, just move it...
3525 if ((constr
->width
.GetRelationship() != wxAsIs
) ||
3526 (constr
->height
.GetRelationship() != wxAsIs
))
3528 // Calls Layout() recursively. AAAGH. How can we stop that.
3529 // Simply take Layout() out of non-top level OnSizes.
3530 SizerSetSize(x
, y
, w
, h
);
3539 wxChar
*windowClass
= this->GetClassInfo()->GetClassName();
3542 if (GetName() == _T(""))
3543 winName
= _T("unnamed");
3545 winName
= GetName();
3546 wxLogDebug( _T("Constraint(s) not satisfied for window of type %s, name %s:\n"),
3547 (const wxChar
*)windowClass
,
3548 (const wxChar
*)winName
);
3549 if (!constr
->left
.GetDone()) wxLogDebug( _T(" unsatisfied 'left' constraint.\n") );
3550 if (!constr
->right
.GetDone()) wxLogDebug( _T(" unsatisfied 'right' constraint.\n") );
3551 if (!constr
->width
.GetDone()) wxLogDebug( _T(" unsatisfied 'width' constraint.\n") );
3552 if (!constr
->height
.GetDone()) wxLogDebug( _T(" unsatisfied 'height' constraint.\n") );
3553 wxLogDebug( _T("Please check constraints: try adding AsIs() constraints.\n") );
3558 wxNode
*node
= m_children
.First();
3561 wxWindow
*win
= (wxWindow
*)node
->Data();
3562 if (!win
->IsKindOf(CLASSINFO(wxFrame
)) && !win
->IsKindOf(CLASSINFO(wxDialog
)))
3563 win
->SetConstraintSizes();
3564 node
= node
->Next();
3569 // This assumes that all sizers are 'on' the same
3570 // window, i.e. the parent of this window.
3571 void wxWindow::TransformSizerToActual(int *x
, int *y
) const
3573 if (!m_sizerParent
|| m_sizerParent
->IsKindOf(CLASSINFO(wxDialog
)) ||
3574 m_sizerParent
->IsKindOf(CLASSINFO(wxFrame
)) )
3578 m_sizerParent
->GetPosition(&xp
, &yp
);
3579 m_sizerParent
->TransformSizerToActual(&xp
, &yp
);
3584 void wxWindow::SizerSetSize(int x
, int y
, int w
, int h
)
3588 TransformSizerToActual(&xx
, &yy
);
3589 SetSize(xx
, yy
, w
, h
);
3592 void wxWindow::SizerMove(int x
, int y
)
3596 TransformSizerToActual(&xx
, &yy
);
3600 // Only set the size/position of the constraint (if any)
3601 void wxWindow::SetSizeConstraint(int x
, int y
, int w
, int h
)
3603 wxLayoutConstraints
*constr
= GetConstraints();
3608 constr
->left
.SetValue(x
);
3609 constr
->left
.SetDone(TRUE
);
3613 constr
->top
.SetValue(y
);
3614 constr
->top
.SetDone(TRUE
);
3618 constr
->width
.SetValue(w
);
3619 constr
->width
.SetDone(TRUE
);
3623 constr
->height
.SetValue(h
);
3624 constr
->height
.SetDone(TRUE
);
3629 void wxWindow::MoveConstraint(int x
, int y
)
3631 wxLayoutConstraints
*constr
= GetConstraints();
3636 constr
->left
.SetValue(x
);
3637 constr
->left
.SetDone(TRUE
);
3641 constr
->top
.SetValue(y
);
3642 constr
->top
.SetDone(TRUE
);
3647 void wxWindow::GetSizeConstraint(int *w
, int *h
) const
3649 wxLayoutConstraints
*constr
= GetConstraints();
3652 *w
= constr
->width
.GetValue();
3653 *h
= constr
->height
.GetValue();
3659 void wxWindow::GetClientSizeConstraint(int *w
, int *h
) const
3661 wxLayoutConstraints
*constr
= GetConstraints();
3664 *w
= constr
->width
.GetValue();
3665 *h
= constr
->height
.GetValue();
3668 GetClientSize(w
, h
);
3671 void wxWindow::GetPositionConstraint(int *x
, int *y
) const
3673 wxLayoutConstraints
*constr
= GetConstraints();
3676 *x
= constr
->left
.GetValue();
3677 *y
= constr
->top
.GetValue();