]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Added wxMenu::UpdateUI to wxMSW, wxGTK, wxMotif, wxStubs; rearranged/debugged
[wxWidgets.git] / src / gtk / window.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: window.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Id: $Id$
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10
11 #ifdef __GNUG__
12 #pragma implementation "window.h"
13 #endif
14
15 #include "wx/defs.h"
16 #include "wx/window.h"
17 #include "wx/dc.h"
18 #include "wx/frame.h"
19 #include "wx/app.h"
20 #include "wx/layout.h"
21 #include "wx/utils.h"
22 #include "wx/dialog.h"
23 #include "wx/msgdlg.h"
24 #if wxUSE_DRAG_AND_DROP
25 #include "wx/dnd.h"
26 #endif
27 #include "wx/tooltip.h"
28 #include "wx/menu.h"
29 #include "wx/statusbr.h"
30 #include "wx/intl.h"
31 #include "wx/settings.h"
32 #include "wx/log.h"
33
34 #include <math.h>
35
36 #include "gdk/gdk.h"
37 #include "gtk/gtk.h"
38 #include "gdk/gdkprivate.h"
39 #include "gdk/gdkkeysyms.h"
40 #include "wx/gtk/win_gtk.h"
41
42 //-----------------------------------------------------------------------------
43 // documentation on internals
44 //-----------------------------------------------------------------------------
45
46 /*
47 I have been asked several times about writing some documentation about
48 the GTK port of wxWindows, especially its internal structures. Obviously,
49 you cannot understand wxGTK without knowing a little about the GTK, but
50 some more information about what the wxWindow, which is the base class
51 for all other window classes, does seems required as well.
52
53 What does wxWindow do? It contains the common interface for the following
54 jobs of its descendants:
55
56 1) Define the rudimentary behaviour common to all window classes, such as
57 resizing, intercepting user input (so as to make it possible to use these
58 events for special purposes in a derived class), window names etc.
59
60 2) Provide the possibility to contain and manage children, if the derived
61 class is allowed to contain children, which holds true for those window
62 classes which do not display a native GTK widget. To name them, these
63 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
64 work classes are a special case and are handled a bit differently from
65 the rest. The same holds true for the wxNotebook class.
66
67 3) Provide the possibility to draw into a client area of a window. This,
68 too, only holds true for classes that do not display a native GTK widget
69 as above.
70
71 4) Provide the entire mechanism for scrolling widgets. This actual inter-
72 face for this is usually in wxScrolledWindow, but the GTK implementation
73 is in this class.
74
75 5) A multitude of helper or extra methods for special purposes, such as
76 Drag'n'Drop, managing validators etc.
77
78 Normally one might expect, that one wxWindows window would always correspond
79 to one GTK widget. Under GTK, there is no such allround widget that has all
80 the functionality. Moreover, the GTK defines a client area as a different
81 widget from the actual widget you are handling. Last but not least some
82 special classes (e.g. wxFrame) handle different categories of widgets and
83 still have the possibility to draw something in the client area.
84 It was therefore required to write a special purpose GTK widget, that would
85 represent a client area in the sense of wxWindows capable to do the jobs
86 2), 3) and 4). I have written this class and it resides in win_gtk.c of
87 this directory.
88
89 All windows must have a widget, with which they interact with other under-
90 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
91 thw wxWindow class has a member variable called m_widget which holds a
92 pointer to this widget. When the window class represents a GTK native widget,
93 this is (in most cases) the only GTK widget the class manages. E.g. the
94 wxStatitText class handles only a GtkLabel widget a pointer to which you
95 can find in m_widget (defined in wxWindow)
96
97 When the class has a client area for drawing into and for containing children
98 it has to handle the client area widget (of the type GtkMyFixed, defined in
99 win_gtk.c), but there could be any number of widgets, handled by a class
100 The common rule for all windows is only, that the widget that interacts with
101 the rest of GTK must be referenced in m_widget and all other widgets must be
102 children of this widget on the GTK level. The top-most widget, which also
103 represents the client area, must be in the m_wxwindow field and must be of
104 the type GtkMyFixed.
105
106 As I said, the window classes that display a GTK native widget only have
107 one widget, so in the case of e.g. the wxButton class m_widget holds a
108 pointer to a GtkButton widget. But windows with client areas (for drawing
109 and children) have a m_widget field that is a pointer to a GtkScrolled-
110 Window and a m_wxwindow field that is pointer to a GtkMyFixed and this
111 one is (in the GTK sense) a child of the GtkScrolledWindow.
112
113 If the m_wxwindow field is set, then all input to this widget is inter-
114 cepted and sent to the wxWindows class. If not, all input to the widget
115 that gets pointed to by m_widget gets intercepted and sent to the class.
116
117 */
118
119 //-------------------------------------------------------------------------
120 // conditional compilation
121 //-------------------------------------------------------------------------
122
123 #if (GTK_MINOR_VERSION == 1)
124 #if (GTK_MICRO_VERSION >= 5)
125 #define NEW_GTK_SCROLL_CODE
126 #endif
127 #endif
128
129 //-----------------------------------------------------------------------------
130 // (debug)
131 //-----------------------------------------------------------------------------
132
133 #ifdef __WXDEBUG__
134
135 static gint gtk_debug_focus_in_callback( GtkWidget *WXUNUSED(widget),
136 GdkEvent *WXUNUSED(event),
137 const char *name )
138 {
139 printf( "FOCUS NOW AT: " );
140 printf( name );
141 printf( "\n" );
142
143 return FALSE;
144 }
145
146 void debug_focus_in( GtkWidget* widget, const char* name, const char *window )
147 {
148 return;
149
150 wxString tmp = name;
151 tmp += " FROM ";
152 tmp += window;
153
154 char *s = new char[tmp.Length()+1];
155
156 strcpy( s, WXSTRINGCAST tmp );
157
158 gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
159 GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback), (gpointer)s );
160 }
161
162 #endif
163
164 //-----------------------------------------------------------------------------
165 // data
166 //-----------------------------------------------------------------------------
167
168 extern wxList wxPendingDelete;
169 extern wxList wxTopLevelWindows;
170 extern bool g_blockEventsOnDrag;
171 extern bool g_blockEventsOnScroll;
172 static bool g_capturing = FALSE;
173 static wxWindow *g_focusWindow = (wxWindow*) NULL;
174
175 // hack: we need something to pass to gtk_menu_popup, so we store the time of
176 // the last click here
177 static guint32 gs_timeLastClick = 0;
178
179 //-----------------------------------------------------------------------------
180 // "expose_event" (of m_wxwindow, not of m_widget)
181 //-----------------------------------------------------------------------------
182
183 static void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
184 {
185 if (!win->HasVMT()) return;
186
187 win->m_updateRegion.Union( gdk_event->area.x,
188 gdk_event->area.y,
189 gdk_event->area.width,
190 gdk_event->area.height );
191
192 if (gdk_event->count > 0) return;
193
194 /*
195 printf( "OnExpose from " );
196 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
197 printf( win->GetClassInfo()->GetClassName() );
198 printf( ".\n" );
199 */
200
201 wxPaintEvent event( win->GetId() );
202 event.SetEventObject( win );
203 win->GetEventHandler()->ProcessEvent( event );
204
205 win->m_updateRegion.Clear();
206 }
207
208 //-----------------------------------------------------------------------------
209 // "draw" (of m_wxwindow, not of m_widget)
210 //-----------------------------------------------------------------------------
211
212 static void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
213 {
214 if (!win->HasVMT()) return;
215
216 win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
217
218 wxPaintEvent event( win->GetId() );
219 event.SetEventObject( win );
220 win->GetEventHandler()->ProcessEvent( event );
221
222 win->m_updateRegion.Clear();
223 }
224
225 //-----------------------------------------------------------------------------
226 // "key_press_event" from any window
227 //-----------------------------------------------------------------------------
228
229 static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
230 {
231 if (!win->HasVMT()) return FALSE;
232 if (g_blockEventsOnDrag) return FALSE;
233
234 /*
235 printf( "OnKeyPress from " );
236 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
237 printf( win->GetClassInfo()->GetClassName() );
238 printf( ".\n" );
239 */
240
241 long key_code = 0;
242 switch (gdk_event->keyval)
243 {
244 case GDK_BackSpace: key_code = WXK_BACK; break;
245 case GDK_Tab: key_code = WXK_TAB; break;
246 case GDK_Linefeed: key_code = WXK_RETURN; break;
247 case GDK_Clear: key_code = WXK_CLEAR; break;
248 case GDK_Return: key_code = WXK_RETURN; break;
249 case GDK_Pause: key_code = WXK_PAUSE; break;
250 case GDK_Scroll_Lock: key_code = WXK_SCROLL; break;
251 case GDK_Escape: key_code = WXK_ESCAPE; break;
252 case GDK_Delete: key_code = WXK_DELETE; break;
253 case GDK_Home: key_code = WXK_HOME; break;
254 case GDK_Left: key_code = WXK_LEFT; break;
255 case GDK_Up: key_code = WXK_UP; break;
256 case GDK_Right: key_code = WXK_RIGHT; break;
257 case GDK_Down: key_code = WXK_DOWN; break;
258 case GDK_Prior: key_code = WXK_PRIOR; break;
259 // case GDK_Page_Up: key_code = WXK_PAGEUP; break;
260 case GDK_Next: key_code = WXK_NEXT; break;
261 // case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
262 case GDK_End: key_code = WXK_END; break;
263 case GDK_Begin: key_code = WXK_HOME; break;
264 case GDK_Select: key_code = WXK_SELECT; break;
265 case GDK_Print: key_code = WXK_PRINT; break;
266 case GDK_Execute: key_code = WXK_EXECUTE; break;
267 case GDK_Insert: key_code = WXK_INSERT; break;
268 case GDK_Num_Lock: key_code = WXK_NUMLOCK; break;
269 case GDK_KP_Tab: key_code = WXK_TAB; break;
270 case GDK_KP_Enter: key_code = WXK_RETURN; break;
271 case GDK_KP_Home: key_code = WXK_HOME; break;
272 case GDK_KP_Left: key_code = WXK_LEFT; break;
273 case GDK_KP_Up: key_code = WXK_UP; break;
274 case GDK_KP_Right: key_code = WXK_RIGHT; break;
275 case GDK_KP_Down: key_code = WXK_DOWN; break;
276 case GDK_KP_Prior: key_code = WXK_PRIOR; break;
277 // case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
278 case GDK_KP_Next: key_code = WXK_NEXT; break;
279 // case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
280 case GDK_KP_End: key_code = WXK_END; break;
281 case GDK_KP_Begin: key_code = WXK_HOME; break;
282 case GDK_KP_Insert: key_code = WXK_INSERT; break;
283 case GDK_KP_Delete: key_code = WXK_DELETE; break;
284 case GDK_KP_Multiply: key_code = WXK_MULTIPLY; break;
285 case GDK_KP_Add: key_code = WXK_ADD; break;
286 case GDK_KP_Separator: key_code = WXK_SEPARATOR; break;
287 case GDK_KP_Subtract: key_code = WXK_SUBTRACT; break;
288 case GDK_KP_Decimal: key_code = WXK_DECIMAL; break;
289 case GDK_KP_Divide: key_code = WXK_DIVIDE; break;
290 case GDK_KP_0: key_code = WXK_NUMPAD0; break;
291 case GDK_KP_1: key_code = WXK_NUMPAD1; break;
292 case GDK_KP_2: key_code = WXK_NUMPAD2; break;
293 case GDK_KP_3: key_code = WXK_NUMPAD3; break;
294 case GDK_KP_4: key_code = WXK_NUMPAD4; break;
295 case GDK_KP_5: key_code = WXK_NUMPAD5; break;
296 case GDK_KP_6: key_code = WXK_NUMPAD6; break;
297 case GDK_KP_7: key_code = WXK_NUMPAD7; break;
298 case GDK_KP_8: key_code = WXK_NUMPAD7; break;
299 case GDK_KP_9: key_code = WXK_NUMPAD9; break;
300 case GDK_F1: key_code = WXK_F1; break;
301 case GDK_F2: key_code = WXK_F2; break;
302 case GDK_F3: key_code = WXK_F3; break;
303 case GDK_F4: key_code = WXK_F4; break;
304 case GDK_F5: key_code = WXK_F5; break;
305 case GDK_F6: key_code = WXK_F6; break;
306 case GDK_F7: key_code = WXK_F7; break;
307 case GDK_F8: key_code = WXK_F8; break;
308 case GDK_F9: key_code = WXK_F9; break;
309 case GDK_F10: key_code = WXK_F10; break;
310 case GDK_F11: key_code = WXK_F11; break;
311 case GDK_F12: key_code = WXK_F12; break;
312 default:
313 {
314 if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
315 key_code = gdk_event->keyval;
316 }
317 }
318
319 if (!key_code) return FALSE;
320
321 wxKeyEvent event( wxEVT_KEY_DOWN );
322 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
323 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
324 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
325 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
326 event.m_keyCode = key_code;
327 event.m_x = 0;
328 event.m_y = 0;
329 event.SetEventObject( win );
330
331 bool ret = win->GetEventHandler()->ProcessEvent( event );
332
333 if (!ret)
334 {
335 wxWindow *ancestor = win;
336 while (ancestor)
337 {
338 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
339 if (command != -1)
340 {
341 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
342 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
343 break;
344 }
345 ancestor = ancestor->GetParent();
346 }
347 }
348
349 // win is a control: tab can be propagated up
350 if ((!ret) && (gdk_event->keyval == GDK_Tab) && ((win->m_windowStyle & wxTE_PROCESS_TAB) == 0))
351 {
352 wxNavigationKeyEvent new_event;
353 new_event.SetDirection( !(gdk_event->state & GDK_SHIFT_MASK) );
354 new_event.SetWindowChange( FALSE );
355 new_event.SetCurrentFocus( win );
356 ret = win->GetEventHandler()->ProcessEvent( new_event );
357 }
358
359 /*
360 // win is a panel: up can be propagated to the panel
361 if ((!ret) && (win->m_wxwindow) && (win->m_parent) && (win->m_parent->AcceptsFocus()) &&
362 (gdk_event->keyval == GDK_Up))
363 {
364 win->m_parent->SetFocus();
365 ret = TRUE;
366 }
367
368 // win is a panel: left/right can be propagated to the panel
369 if ((!ret) && (win->m_wxwindow) &&
370 ((gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Left) ||
371 (gdk_event->keyval == GDK_Up) || (gdk_event->keyval == GDK_Down)))
372 {
373 wxNavigationKeyEvent new_event;
374 new_event.SetDirection( (gdk_event->keyval == GDK_Right) || (gdk_event->keyval == GDK_Down) );
375 new_event.SetCurrentFocus( win );
376 ret = win->GetEventHandler()->ProcessEvent( new_event );
377 }
378 */
379
380 if (ret)
381 {
382 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
383 }
384
385 return ret;
386 }
387
388 //-----------------------------------------------------------------------------
389 // "key_release_event" from any window
390 //-----------------------------------------------------------------------------
391
392 static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win )
393 {
394 if (!win->HasVMT()) return FALSE;
395 if (g_blockEventsOnDrag) return FALSE;
396
397 /*
398 printf( "OnKeyRelease from " );
399 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
400 printf( win->GetClassInfo()->GetClassName() );
401 printf( ".\n" );
402 */
403
404 long key_code = 0;
405 switch (gdk_event->keyval)
406 {
407 case GDK_BackSpace: key_code = WXK_BACK; break;
408 case GDK_Tab: key_code = WXK_TAB; break;
409 case GDK_Linefeed: key_code = WXK_RETURN; break;
410 case GDK_Clear: key_code = WXK_CLEAR; break;
411 case GDK_Return: key_code = WXK_RETURN; break;
412 case GDK_Pause: key_code = WXK_PAUSE; break;
413 case GDK_Scroll_Lock: key_code = WXK_SCROLL; break;
414 case GDK_Escape: key_code = WXK_ESCAPE; break;
415 case GDK_Delete: key_code = WXK_DELETE; break;
416 case GDK_Home: key_code = WXK_HOME; break;
417 case GDK_Left: key_code = WXK_LEFT; break;
418 case GDK_Up: key_code = WXK_UP; break;
419 case GDK_Right: key_code = WXK_RIGHT; break;
420 case GDK_Down: key_code = WXK_DOWN; break;
421 case GDK_Prior: key_code = WXK_PRIOR; break;
422 // case GDK_Page_Up: key_code = WXK_PAGEUP; break;
423 case GDK_Next: key_code = WXK_NEXT; break;
424 // case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
425 case GDK_End: key_code = WXK_END; break;
426 case GDK_Begin: key_code = WXK_HOME; break;
427 case GDK_Select: key_code = WXK_SELECT; break;
428 case GDK_Print: key_code = WXK_PRINT; break;
429 case GDK_Execute: key_code = WXK_EXECUTE; break;
430 case GDK_Insert: key_code = WXK_INSERT; break;
431 case GDK_Num_Lock: key_code = WXK_NUMLOCK; break;
432 case GDK_KP_Tab: key_code = WXK_TAB; break;
433 case GDK_KP_Enter: key_code = WXK_RETURN; break;
434 case GDK_KP_Home: key_code = WXK_HOME; break;
435 case GDK_KP_Left: key_code = WXK_LEFT; break;
436 case GDK_KP_Up: key_code = WXK_UP; break;
437 case GDK_KP_Right: key_code = WXK_RIGHT; break;
438 case GDK_KP_Down: key_code = WXK_DOWN; break;
439 case GDK_KP_Prior: key_code = WXK_PRIOR; break;
440 // case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
441 case GDK_KP_Next: key_code = WXK_NEXT; break;
442 // case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
443 case GDK_KP_End: key_code = WXK_END; break;
444 case GDK_KP_Begin: key_code = WXK_HOME; break;
445 case GDK_KP_Insert: key_code = WXK_INSERT; break;
446 case GDK_KP_Delete: key_code = WXK_DELETE; break;
447 case GDK_KP_Multiply: key_code = WXK_MULTIPLY; break;
448 case GDK_KP_Add: key_code = WXK_ADD; break;
449 case GDK_KP_Separator: key_code = WXK_SEPARATOR; break;
450 case GDK_KP_Subtract: key_code = WXK_SUBTRACT; break;
451 case GDK_KP_Decimal: key_code = WXK_DECIMAL; break;
452 case GDK_KP_Divide: key_code = WXK_DIVIDE; break;
453 case GDK_KP_0: key_code = WXK_NUMPAD0; break;
454 case GDK_KP_1: key_code = WXK_NUMPAD1; break;
455 case GDK_KP_2: key_code = WXK_NUMPAD2; break;
456 case GDK_KP_3: key_code = WXK_NUMPAD3; break;
457 case GDK_KP_4: key_code = WXK_NUMPAD4; break;
458 case GDK_KP_5: key_code = WXK_NUMPAD5; break;
459 case GDK_KP_6: key_code = WXK_NUMPAD6; break;
460 case GDK_KP_7: key_code = WXK_NUMPAD7; break;
461 case GDK_KP_8: key_code = WXK_NUMPAD7; break;
462 case GDK_KP_9: key_code = WXK_NUMPAD9; break;
463 case GDK_F1: key_code = WXK_F1; break;
464 case GDK_F2: key_code = WXK_F2; break;
465 case GDK_F3: key_code = WXK_F3; break;
466 case GDK_F4: key_code = WXK_F4; break;
467 case GDK_F5: key_code = WXK_F5; break;
468 case GDK_F6: key_code = WXK_F6; break;
469 case GDK_F7: key_code = WXK_F7; break;
470 case GDK_F8: key_code = WXK_F8; break;
471 case GDK_F9: key_code = WXK_F9; break;
472 case GDK_F10: key_code = WXK_F10; break;
473 case GDK_F11: key_code = WXK_F11; break;
474 case GDK_F12: key_code = WXK_F12; break;
475 default:
476 {
477 if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
478 key_code = gdk_event->keyval;
479 }
480 }
481
482 if (!key_code) return FALSE;
483
484 wxKeyEvent event( wxEVT_KEY_UP );
485 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
486 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
487 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
488 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
489 event.m_keyCode = key_code;
490 event.m_x = 0;
491 event.m_y = 0;
492 event.SetEventObject( win );
493
494 bool ret = win->GetEventHandler()->ProcessEvent( event );
495
496 if (ret)
497 {
498 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
499 }
500
501 return ret;
502 }
503
504 //-----------------------------------------------------------------------------
505 // "button_press_event"
506 //-----------------------------------------------------------------------------
507
508 static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
509 {
510 if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
511
512 if (g_blockEventsOnDrag) return TRUE;
513 if (g_blockEventsOnScroll) return TRUE;
514
515 if (win->m_wxwindow)
516 {
517 if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (win->m_wxwindow) )
518 {
519 gtk_widget_grab_focus (win->m_wxwindow);
520
521 /*
522 printf( "GrabFocus from " );
523 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
524 printf( win->GetClassInfo()->GetClassName() );
525 printf( ".\n" );
526 */
527
528 }
529 }
530
531 if (!win->HasVMT()) return TRUE;
532
533 /*
534 printf( "OnButtonPress from " );
535 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
536 printf( win->GetClassInfo()->GetClassName() );
537 printf( ".\n" );
538 */
539
540 wxEventType event_type = wxEVT_LEFT_DOWN;
541
542 if (gdk_event->button == 1)
543 {
544 switch (gdk_event->type)
545 {
546 case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
547 case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
548 default: break;
549 }
550 }
551 else if (gdk_event->button == 2)
552 {
553 switch (gdk_event->type)
554 {
555 case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
556 case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
557 default: break;
558 }
559 }
560 else if (gdk_event->button == 3)
561 {
562 switch (gdk_event->type)
563 {
564 case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
565 case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
566 default: break;
567 }
568 }
569
570 wxMouseEvent event( event_type );
571 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
572 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
573 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
574 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
575 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
576 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
577 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
578
579 event.m_x = (long)gdk_event->x;
580 event.m_y = (long)gdk_event->y;
581
582 // Some control don't have their own X window and thus cannot get
583 // any events.
584
585 if (!g_capturing)
586 {
587 wxNode *node = win->GetChildren().First();
588 while (node)
589 {
590 wxWindow *child = (wxWindow*)node->Data();
591
592 if (child->m_isStaticBox)
593 {
594 // wxStaticBox is transparent in the box itself
595 int x = event.m_x;
596 int y = event.m_y;
597 int xx1 = child->m_x;
598 int yy1 = child->m_y;
599 int xx2 = child->m_x + child->m_width;
600 int yy2 = child->m_x + child->m_height;
601
602 // left
603 if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
604 // right
605 ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
606 // top
607 ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
608 // bottom
609 ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
610 {
611 win = child;
612 event.m_x -= child->m_x;
613 event.m_y -= child->m_y;
614 break;
615 }
616
617 }
618 else
619 {
620 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
621 (child->m_x <= event.m_x) &&
622 (child->m_y <= event.m_y) &&
623 (child->m_x+child->m_width >= event.m_x) &&
624 (child->m_y+child->m_height >= event.m_y))
625 {
626 win = child;
627 event.m_x -= child->m_x;
628 event.m_y -= child->m_y;
629 break;
630 }
631 }
632 node = node->Next();
633 }
634 }
635
636 wxPoint pt(win->GetClientAreaOrigin());
637 event.m_x -= pt.x;
638 event.m_y -= pt.y;
639
640 event.SetEventObject( win );
641
642 gs_timeLastClick = gdk_event->time;
643
644 if (win->GetEventHandler()->ProcessEvent( event ))
645 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
646
647 return TRUE;
648 }
649
650 //-----------------------------------------------------------------------------
651 // "button_release_event"
652 //-----------------------------------------------------------------------------
653
654 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
655 {
656 if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
657
658 if (g_blockEventsOnDrag) return TRUE;
659 if (g_blockEventsOnScroll) return TRUE;
660
661 if (!win->HasVMT()) return TRUE;
662
663 /*
664 printf( "OnButtonRelease from " );
665 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
666 printf( win->GetClassInfo()->GetClassName() );
667 printf( ".\n" );
668 */
669
670 wxEventType event_type = wxEVT_NULL;
671
672 switch (gdk_event->button)
673 {
674 case 1: event_type = wxEVT_LEFT_UP; break;
675 case 2: event_type = wxEVT_MIDDLE_UP; break;
676 case 3: event_type = wxEVT_RIGHT_UP; break;
677 }
678
679 wxMouseEvent event( event_type );
680 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
681 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
682 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
683 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
684 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
685 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
686 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
687 event.m_x = (long)gdk_event->x;
688 event.m_y = (long)gdk_event->y;
689
690 // Some control don't have their own X window and thus cannot get
691 // any events.
692
693 if (!g_capturing)
694 {
695 wxNode *node = win->GetChildren().First();
696 while (node)
697 {
698 wxWindow *child = (wxWindow*)node->Data();
699
700 if (child->m_isStaticBox)
701 {
702 // wxStaticBox is transparent in the box itself
703 int x = event.m_x;
704 int y = event.m_y;
705 int xx1 = child->m_x;
706 int yy1 = child->m_y;
707 int xx2 = child->m_x + child->m_width;
708 int yy2 = child->m_x + child->m_height;
709
710 // left
711 if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
712 // right
713 ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
714 // top
715 ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
716 // bottom
717 ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
718 {
719 win = child;
720 event.m_x -= child->m_x;
721 event.m_y -= child->m_y;
722 break;
723 }
724
725 }
726 else
727 {
728 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
729 (child->m_x <= event.m_x) &&
730 (child->m_y <= event.m_y) &&
731 (child->m_x+child->m_width >= event.m_x) &&
732 (child->m_y+child->m_height >= event.m_y))
733 {
734 win = child;
735 event.m_x -= child->m_x;
736 event.m_y -= child->m_y;
737 break;
738 }
739 }
740 node = node->Next();
741 }
742 }
743
744 wxPoint pt(win->GetClientAreaOrigin());
745 event.m_x -= pt.x;
746 event.m_y -= pt.y;
747
748 event.SetEventObject( win );
749
750 if (win->GetEventHandler()->ProcessEvent( event ))
751 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
752
753 return TRUE;
754 }
755
756 //-----------------------------------------------------------------------------
757 // "motion_notify_event"
758 //-----------------------------------------------------------------------------
759
760 static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
761 {
762 if (gdk_event->is_hint)
763 {
764 int x = 0;
765 int y = 0;
766 GdkModifierType state;
767 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
768 gdk_event->x = x;
769 gdk_event->y = y;
770 gdk_event->state = state;
771 }
772
773 if (!win->IsOwnGtkWindow( gdk_event->window )) return TRUE;
774
775 if (g_blockEventsOnDrag) return TRUE;
776 if (g_blockEventsOnScroll) return TRUE;
777
778 if (!win->HasVMT()) return TRUE;
779
780 /*
781 printf( "OnMotion from " );
782 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
783 printf( win->GetClassInfo()->GetClassName() );
784 printf( ".\n" );
785 */
786
787 wxMouseEvent event( wxEVT_MOTION );
788 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
789 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
790 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
791 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
792 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
793 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
794 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
795
796 event.m_x = (long)gdk_event->x;
797 event.m_y = (long)gdk_event->y;
798
799 // Some control don't have their own X window and thus cannot get
800 // any events.
801
802 if (!g_capturing)
803 {
804 wxNode *node = win->GetChildren().First();
805 while (node)
806 {
807 wxWindow *child = (wxWindow*)node->Data();
808
809 if (child->m_isStaticBox)
810 {
811 // wxStaticBox is transparent in the box itself
812 int x = event.m_x;
813 int y = event.m_y;
814 int xx1 = child->m_x;
815 int yy1 = child->m_y;
816 int xx2 = child->m_x + child->m_width;
817 int yy2 = child->m_x + child->m_height;
818
819 // left
820 if (((x >= xx1) && (x <= xx1+10) && (y >= yy1) && (y <= yy2)) ||
821 // right
822 ((x >= xx2-10) && (x <= xx2) && (y >= yy1) && (y <= yy2)) ||
823 // top
824 ((x >= xx1) && (x <= xx2) && (y >= yy1) && (y <= yy1+10)) ||
825 // bottom
826 ((x >= xx1) && (x <= xx2) && (y >= yy2-1) && (y <= yy2)))
827 {
828 win = child;
829 event.m_x -= child->m_x;
830 event.m_y -= child->m_y;
831 break;
832 }
833
834 }
835 else
836 {
837 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
838 (child->m_x <= event.m_x) &&
839 (child->m_y <= event.m_y) &&
840 (child->m_x+child->m_width >= event.m_x) &&
841 (child->m_y+child->m_height >= event.m_y))
842 {
843 win = child;
844 event.m_x -= child->m_x;
845 event.m_y -= child->m_y;
846 break;
847 }
848 }
849 node = node->Next();
850 }
851 }
852
853 wxPoint pt(win->GetClientAreaOrigin());
854 event.m_x -= pt.x;
855 event.m_y -= pt.y;
856
857 event.SetEventObject( win );
858
859 if (win->GetEventHandler()->ProcessEvent( event ))
860 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
861
862 return TRUE;
863 }
864
865 //-----------------------------------------------------------------------------
866 // "focus_in_event"
867 //-----------------------------------------------------------------------------
868
869 static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
870 {
871 if (g_blockEventsOnDrag) return TRUE;
872
873 g_focusWindow = win;
874
875 if (win->m_wxwindow)
876 {
877 if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
878 {
879 GTK_WIDGET_SET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
880 /*
881 printf( "SetFocus flag from " );
882 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
883 printf( win->GetClassInfo()->GetClassName() );
884 printf( ".\n" );
885 */
886 }
887 }
888
889 if (!win->HasVMT()) return TRUE;
890
891 /*
892 printf( "OnSetFocus from " );
893 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
894 printf( win->GetClassInfo()->GetClassName() );
895 printf( " " );
896 printf( WXSTRINGCAST win->GetLabel() );
897 printf( ".\n" );
898 */
899
900 wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
901 event.SetEventObject( win );
902
903 if (win->GetEventHandler()->ProcessEvent( event ))
904 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
905
906 return TRUE;
907 }
908
909 //-----------------------------------------------------------------------------
910 // "focus_out_event"
911 //-----------------------------------------------------------------------------
912
913 static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win )
914 {
915 if (g_blockEventsOnDrag) return TRUE;
916 if (win->m_wxwindow)
917 {
918 if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
919 GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
920 }
921
922 if (!win->HasVMT()) return TRUE;
923
924 /*
925 printf( "OnKillFocus from " );
926 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
927 printf( win->GetClassInfo()->GetClassName() );
928 printf( ".\n" );
929 */
930
931 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
932 event.SetEventObject( win );
933
934 if (win->GetEventHandler()->ProcessEvent( event ))
935 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
936
937 return TRUE;
938 }
939
940 //-----------------------------------------------------------------------------
941 // "enter_notify_event"
942 //-----------------------------------------------------------------------------
943
944 static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
945 {
946 if (g_blockEventsOnDrag) return TRUE;
947
948 if ((widget->window) && (win->m_cursor))
949 gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
950
951 if (widget->window != gdk_event->window) return TRUE;
952
953 if (!win->HasVMT()) return TRUE;
954
955 /*
956 printf( "OnEnter from " );
957 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
958 printf( win->GetClassInfo()->GetClassName() );
959 printf( ".\n" );
960 */
961
962 wxMouseEvent event( wxEVT_ENTER_WINDOW );
963 event.SetEventObject( win );
964
965 int x = 0;
966 int y = 0;
967 GdkModifierType state = (GdkModifierType)0;
968
969 gdk_window_get_pointer( widget->window, &x, &y, &state );
970
971 event.m_shiftDown = (state & GDK_SHIFT_MASK);
972 event.m_controlDown = (state & GDK_CONTROL_MASK);
973 event.m_altDown = (state & GDK_MOD1_MASK);
974 event.m_metaDown = (state & GDK_MOD2_MASK);
975 event.m_leftDown = (state & GDK_BUTTON1_MASK);
976 event.m_middleDown = (state & GDK_BUTTON2_MASK);
977 event.m_rightDown = (state & GDK_BUTTON3_MASK);
978
979 event.m_x = (long)x;
980 event.m_y = (long)y;
981
982 wxPoint pt(win->GetClientAreaOrigin());
983 event.m_x -= pt.x;
984 event.m_y -= pt.y;
985
986 if (win->GetEventHandler()->ProcessEvent( event ))
987 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
988
989 return TRUE;
990 }
991
992 //-----------------------------------------------------------------------------
993 // "leave_notify_event"
994 //-----------------------------------------------------------------------------
995
996 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
997 {
998 if (g_blockEventsOnDrag) return TRUE;
999
1000 if ((widget->window) && (win->m_cursor))
1001 gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
1002
1003 if (widget->window != gdk_event->window) return TRUE;
1004
1005 if (!win->HasVMT()) return TRUE;
1006
1007 /*
1008 printf( "OnLeave from " );
1009 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1010 printf( win->GetClassInfo()->GetClassName() );
1011 printf( ".\n" );
1012 */
1013
1014 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1015 event.SetEventObject( win );
1016
1017 int x = 0;
1018 int y = 0;
1019 GdkModifierType state = (GdkModifierType)0;
1020
1021 gdk_window_get_pointer( widget->window, &x, &y, &state );
1022
1023 event.m_shiftDown = (state & GDK_SHIFT_MASK);
1024 event.m_controlDown = (state & GDK_CONTROL_MASK);
1025 event.m_altDown = (state & GDK_MOD1_MASK);
1026 event.m_metaDown = (state & GDK_MOD2_MASK);
1027 event.m_leftDown = (state & GDK_BUTTON1_MASK);
1028 event.m_middleDown = (state & GDK_BUTTON2_MASK);
1029 event.m_rightDown = (state & GDK_BUTTON3_MASK);
1030
1031 event.m_x = (long)x;
1032 event.m_y = (long)y;
1033
1034 wxPoint pt(win->GetClientAreaOrigin());
1035 event.m_x -= pt.x;
1036 event.m_y -= pt.y;
1037
1038 if (win->GetEventHandler()->ProcessEvent( event ))
1039 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
1040
1041 return TRUE;
1042 }
1043
1044 //-----------------------------------------------------------------------------
1045 // "value_changed" from m_vAdjust
1046 //-----------------------------------------------------------------------------
1047
1048 static void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1049 {
1050 if (g_blockEventsOnDrag) return;
1051
1052 /*
1053 printf( "OnVScroll from " );
1054 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1055 printf( win->GetClassInfo()->GetClassName() );
1056 printf( ".\n" );
1057 */
1058
1059 if (!win->HasVMT()) return;
1060
1061 float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
1062 if (fabs(diff) < 0.2) return;
1063
1064 wxEventType command = wxEVT_NULL;
1065
1066 float line_step = win->m_vAdjust->step_increment;
1067 float page_step = win->m_vAdjust->page_increment;
1068
1069 if (win->m_isScrolling)
1070 {
1071 command = wxEVT_SCROLL_THUMBTRACK;
1072 }
1073 else
1074 {
1075 if (fabs(win->m_vAdjust->value-win->m_vAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM;
1076 else if (fabs(win->m_vAdjust->value-win->m_vAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP;
1077 else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
1078 else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
1079 else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
1080 else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
1081 else command = wxEVT_SCROLL_THUMBTRACK;
1082 }
1083
1084 int value = (int)(win->m_vAdjust->value+0.5);
1085
1086 wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
1087 event.SetEventObject( win );
1088 win->GetEventHandler()->ProcessEvent( event );
1089 }
1090
1091 //-----------------------------------------------------------------------------
1092 // "value_changed" from m_hAdjust
1093 //-----------------------------------------------------------------------------
1094
1095 static void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1096 {
1097 if (g_blockEventsOnDrag) return;
1098
1099 /*
1100 printf( "OnHScroll from " );
1101 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1102 printf( win->GetClassInfo()->GetClassName() );
1103 printf( ".\n" );
1104 */
1105
1106 if (!win->HasVMT()) return;
1107
1108 float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
1109 if (fabs(diff) < 0.2) return;
1110
1111 wxEventType command = wxEVT_NULL;
1112
1113 float line_step = win->m_hAdjust->step_increment;
1114 float page_step = win->m_hAdjust->page_increment;
1115
1116 if (win->m_isScrolling)
1117 {
1118 command = wxEVT_SCROLL_THUMBTRACK;
1119 }
1120 else
1121 {
1122 if (fabs(win->m_hAdjust->value-win->m_hAdjust->lower) < 0.2) command = wxEVT_SCROLL_BOTTOM;
1123 else if (fabs(win->m_hAdjust->value-win->m_hAdjust->upper) < 0.2) command = wxEVT_SCROLL_TOP;
1124 else if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
1125 else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
1126 else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
1127 else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
1128 else command = wxEVT_SCROLL_THUMBTRACK;
1129 }
1130
1131 int value = (int)(win->m_hAdjust->value+0.5);
1132
1133 wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
1134 event.SetEventObject( win );
1135 win->GetEventHandler()->ProcessEvent( event );
1136 }
1137
1138 //-----------------------------------------------------------------------------
1139 // "changed" from m_vAdjust
1140 //-----------------------------------------------------------------------------
1141
1142 static void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1143 {
1144 if (g_blockEventsOnDrag) return;
1145
1146 /*
1147 printf( "OnVScroll change from " );
1148 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1149 printf( win->GetClassInfo()->GetClassName() );
1150 printf( ".\n" );
1151 */
1152
1153 if (!win->HasVMT()) return;
1154
1155 wxEventType command = wxEVT_SCROLL_THUMBTRACK;
1156 int value = (int)(win->m_vAdjust->value+0.5);
1157
1158 wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
1159 event.SetEventObject( win );
1160 win->GetEventHandler()->ProcessEvent( event );
1161 }
1162
1163 //-----------------------------------------------------------------------------
1164 // "changed" from m_hAdjust
1165 //-----------------------------------------------------------------------------
1166
1167 static void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
1168 {
1169 if (g_blockEventsOnDrag) return;
1170
1171 /*
1172 printf( "OnHScroll change from " );
1173 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1174 printf( win->GetClassInfo()->GetClassName() );
1175 printf( ".\n" );
1176 */
1177
1178 if (!win->HasVMT()) return;
1179
1180 wxEventType command = wxEVT_SCROLL_THUMBTRACK;
1181 int value = (int)(win->m_hAdjust->value+0.5);
1182
1183 wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
1184 event.SetEventObject( win );
1185 win->GetEventHandler()->ProcessEvent( event );
1186 }
1187
1188 //-----------------------------------------------------------------------------
1189 // "button_press_event" from scrollbar
1190 //-----------------------------------------------------------------------------
1191
1192 static gint gtk_scrollbar_button_press_callback( GtkRange *WXUNUSED(widget),
1193 GdkEventButton *WXUNUSED(gdk_event),
1194 wxWindow *win )
1195 {
1196 // don't test here as we can release the mouse while being over
1197 // a different window then the slider
1198 //
1199 // if (gdk_event->window != widget->slider) return FALSE;
1200
1201 win->m_isScrolling = TRUE;
1202 g_blockEventsOnScroll = TRUE;
1203
1204 return FALSE;
1205 }
1206
1207 //-----------------------------------------------------------------------------
1208 // "button_release_event" from scrollbar
1209 //-----------------------------------------------------------------------------
1210
1211 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
1212 GdkEventButton *WXUNUSED(gdk_event),
1213 wxWindow *win )
1214 {
1215
1216 // don't test here as we can release the mouse while being over
1217 // a different window then the slider
1218 //
1219 // if (gdk_event->window != widget->slider) return FALSE;
1220
1221 GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(win->m_widget);
1222
1223 if (widget == GTK_RANGE(s_window->vscrollbar))
1224 gtk_signal_emit_by_name( GTK_OBJECT(win->m_hAdjust), "value_changed" );
1225 else
1226 gtk_signal_emit_by_name( GTK_OBJECT(win->m_vAdjust), "value_changed" );
1227
1228 win->m_isScrolling = FALSE;
1229 g_blockEventsOnScroll = FALSE;
1230
1231 return FALSE;
1232 }
1233
1234 //-----------------------------------------------------------------------------
1235 // InsertChild for wxWindow.
1236 //-----------------------------------------------------------------------------
1237
1238 /* Callback for wxWindow. This very strange beast has to be used because
1239 * C++ has no virtual methods in a constructor. We have to emulate a
1240 * virtual function here as wxNotebook requires a different way to insert
1241 * a child in it. I had opted for creating a wxNotebookPage window class
1242 * which would have made this superfluous (such in the MDI window system),
1243 * but no-one was listening to me... */
1244
1245 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
1246 {
1247 gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
1248 GTK_WIDGET(child->m_widget),
1249 child->m_x,
1250 child->m_y );
1251
1252 gtk_widget_set_usize( GTK_WIDGET(child->m_widget),
1253 child->m_width,
1254 child->m_height );
1255
1256 if (wxIS_KIND_OF(parent,wxFrame))
1257 {
1258 parent->m_sizeSet = FALSE;
1259 }
1260
1261 if (parent->m_windowStyle & wxTAB_TRAVERSAL)
1262 {
1263 /* we now allow a window to get the focus as long as it
1264 doesn't have any children. */
1265 GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );
1266 }
1267 }
1268
1269 //-----------------------------------------------------------------------------
1270 // global functions
1271 //-----------------------------------------------------------------------------
1272
1273 wxWindow* wxGetActiveWindow()
1274 {
1275 return g_focusWindow;
1276 }
1277
1278 //-----------------------------------------------------------------------------
1279 // wxWindow
1280 //-----------------------------------------------------------------------------
1281
1282 IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
1283
1284 BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
1285 EVT_SIZE(wxWindow::OnSize)
1286 EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
1287 EVT_INIT_DIALOG(wxWindow::OnInitDialog)
1288 EVT_KEY_DOWN(wxWindow::OnKeyDown)
1289 END_EVENT_TABLE()
1290
1291 wxWindow::wxWindow()
1292 {
1293 m_widget = (GtkWidget *) NULL;
1294 m_wxwindow = (GtkWidget *) NULL;
1295 m_parent = (wxWindow *) NULL;
1296 m_children.DeleteContents( FALSE );
1297
1298 m_x = 0;
1299 m_y = 0;
1300 m_width = 0;
1301 m_height = 0;
1302 m_minWidth = -1;
1303 m_minHeight = -1;
1304 m_maxWidth = -1;
1305 m_maxHeight = -1;
1306
1307 m_retCode = 0;
1308
1309 m_eventHandler = this;
1310 m_windowValidator = (wxValidator *) NULL;
1311
1312 m_windowId = -1;
1313
1314 m_cursor = (wxCursor *) NULL;
1315 m_font = *wxSWISS_FONT;
1316 m_windowStyle = 0;
1317 m_windowName = "noname";
1318
1319 m_constraints = (wxLayoutConstraints *) NULL;
1320 m_constraintsInvolvedIn = (wxList *) NULL;
1321 m_windowSizer = (wxSizer *) NULL;
1322 m_sizerParent = (wxWindow *) NULL;
1323 m_autoLayout = FALSE;
1324
1325 m_sizeSet = FALSE;
1326 m_hasVMT = FALSE;
1327 m_needParent = TRUE;
1328
1329 m_hasScrolling = FALSE;
1330 m_isScrolling = FALSE;
1331 m_hAdjust = (GtkAdjustment*) NULL;
1332 m_vAdjust = (GtkAdjustment*) NULL;
1333 m_oldHorizontalPos = 0.0;
1334 m_oldVerticalPos = 0.0;
1335
1336 m_isShown = FALSE;
1337 m_isEnabled = TRUE;
1338
1339 #if wxUSE_DRAG_AND_DROP
1340 m_dropTarget = (wxDropTarget*) NULL;
1341 #endif
1342 m_resizing = FALSE;
1343 m_scrollGC = (GdkGC*) NULL;
1344 m_widgetStyle = (GtkStyle*) NULL;
1345
1346 m_insertCallback = wxInsertChildInWindow;
1347
1348 m_clientObject = (wxClientData*) NULL;
1349 m_clientData = NULL;
1350
1351 m_isStaticBox = FALSE;
1352 m_acceptsFocus = FALSE;
1353
1354 #if wxUSE_TOOLTIPS
1355 m_toolTip = (wxToolTip*) NULL;
1356 #endif // wxUSE_TOOLTIPS
1357 }
1358
1359 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
1360 const wxPoint &pos, const wxSize &size,
1361 long style, const wxString &name )
1362 {
1363 m_insertCallback = wxInsertChildInWindow;
1364 Create( parent, id, pos, size, style, name );
1365 }
1366
1367 bool wxWindow::Create( wxWindow *parent, wxWindowID id,
1368 const wxPoint &pos, const wxSize &size,
1369 long style, const wxString &name )
1370 {
1371 m_isShown = FALSE;
1372 m_isEnabled = TRUE;
1373 m_needParent = TRUE;
1374
1375 PreCreation( parent, id, pos, size, style, name );
1376
1377 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
1378 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
1379
1380 #ifdef __WXDEBUG__
1381 debug_focus_in( m_widget, "wxWindow::m_widget", name );
1382 #endif
1383
1384 GtkScrolledWindow *s_window = GTK_SCROLLED_WINDOW(m_widget);
1385
1386 #ifdef __WXDEBUG__
1387 debug_focus_in( s_window->hscrollbar, "wxWindow::hsrcollbar", name );
1388 debug_focus_in( s_window->vscrollbar, "wxWindow::vsrcollbar", name );
1389 #endif
1390
1391 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1392 scroll_class->scrollbar_spacing = 0;
1393
1394 gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
1395
1396 m_oldHorizontalPos = 0.0;
1397 m_oldVerticalPos = 0.0;
1398
1399 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) );
1400 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
1401
1402 m_wxwindow = gtk_myfixed_new();
1403
1404 #ifdef __WXDEBUG__
1405 debug_focus_in( m_wxwindow, "wxWindow::m_wxwindow", name );
1406 #endif
1407
1408 #ifdef NEW_GTK_SCROLL_CODE
1409 gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(m_widget), m_wxwindow );
1410 GtkViewport *viewport = GTK_VIEWPORT(s_window->child);
1411 #else
1412 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
1413 GtkViewport *viewport = GTK_VIEWPORT(s_window->viewport);
1414 #endif
1415
1416 #ifdef __WXDEBUG__
1417 debug_focus_in( GTK_WIDGET(viewport), "wxWindow::viewport", name );
1418 #endif
1419
1420 if (m_windowStyle & wxRAISED_BORDER)
1421 {
1422 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
1423 }
1424 else if (m_windowStyle & wxSUNKEN_BORDER)
1425 {
1426 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
1427 }
1428 else
1429 {
1430 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
1431 }
1432
1433 if (m_windowStyle & wxTAB_TRAVERSAL)
1434 {
1435 /* we now allow a window to get the focus as long as it
1436 doesn't have any children. */
1437 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
1438 m_acceptsFocus = FALSE;
1439 }
1440 else
1441 {
1442 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
1443 m_acceptsFocus = TRUE;
1444 }
1445
1446 // shut the viewport up
1447 gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1448 gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1449
1450 // I _really_ don't want scrollbars in the beginning
1451 m_vAdjust->lower = 0.0;
1452 m_vAdjust->upper = 1.0;
1453 m_vAdjust->value = 0.0;
1454 m_vAdjust->step_increment = 1.0;
1455 m_vAdjust->page_increment = 1.0;
1456 m_vAdjust->page_size = 5.0;
1457 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
1458 m_hAdjust->lower = 0.0;
1459 m_hAdjust->upper = 1.0;
1460 m_hAdjust->value = 0.0;
1461 m_hAdjust->step_increment = 1.0;
1462 m_hAdjust->page_increment = 1.0;
1463 m_hAdjust->page_size = 5.0;
1464 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
1465
1466 // these handlers block mouse events to any window during scrolling
1467 // such as motion events and prevent GTK and wxWindows from fighting
1468 // over where the slider should be
1469
1470 gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_press_event",
1471 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1472
1473 gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_press_event",
1474 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1475
1476 gtk_signal_connect( GTK_OBJECT(s_window->vscrollbar), "button_release_event",
1477 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1478
1479 gtk_signal_connect( GTK_OBJECT(s_window->hscrollbar), "button_release_event",
1480 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1481
1482 // these handers het notified when screen updates are required either when
1483 // scrolling or when the window size (and therefore scrollbar configuration)
1484 // has changed
1485
1486 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
1487 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
1488 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
1489 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
1490
1491 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed",
1492 (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
1493 gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
1494 (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
1495
1496 gtk_widget_show( m_wxwindow );
1497
1498 if (m_parent) m_parent->AddChild( this );
1499
1500 (m_parent->m_insertCallback)( m_parent, this );
1501
1502 PostCreation();
1503
1504 Show( TRUE );
1505
1506 return TRUE;
1507 }
1508
1509 wxWindow::~wxWindow()
1510 {
1511 m_hasVMT = FALSE;
1512
1513 #if wxUSE_DRAG_AND_DROP
1514 wxDELETE(m_dropTarget);
1515 #endif
1516
1517 #if wxUSE_TOOLTIPS
1518 wxDELETE(m_toolTip);
1519 #endif // wxUSE_TOOLTIPS
1520
1521 if (m_parent) m_parent->RemoveChild( this );
1522 if (m_widget) Show( FALSE );
1523
1524 DestroyChildren();
1525
1526 if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
1527
1528 if (m_scrollGC) gdk_gc_unref( m_scrollGC );
1529
1530 if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
1531
1532 if (m_widget) gtk_widget_destroy( m_widget );
1533
1534 if (m_cursor) delete m_cursor;
1535
1536 DeleteRelatedConstraints();
1537 if (m_constraints)
1538 {
1539 // This removes any dangling pointers to this window
1540 // in other windows' constraintsInvolvedIn lists.
1541 UnsetConstraints(m_constraints);
1542 delete m_constraints;
1543 m_constraints = (wxLayoutConstraints *) NULL;
1544 }
1545 if (m_windowSizer)
1546 {
1547 delete m_windowSizer;
1548 m_windowSizer = (wxSizer *) NULL;
1549 }
1550 // If this is a child of a sizer, remove self from parent
1551 if (m_sizerParent) m_sizerParent->RemoveChild((wxWindow *)this);
1552
1553 // Just in case the window has been Closed, but
1554 // we're then deleting immediately: don't leave
1555 // dangling pointers.
1556 wxPendingDelete.DeleteObject(this);
1557
1558 // Just in case we've loaded a top-level window via
1559 // wxWindow::LoadNativeDialog but we weren't a dialog
1560 // class
1561 wxTopLevelWindows.DeleteObject(this);
1562
1563 if (m_windowValidator) delete m_windowValidator;
1564
1565 if (m_clientObject) delete m_clientObject;
1566 }
1567
1568 void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
1569 const wxPoint &pos, const wxSize &size,
1570 long style, const wxString &name )
1571 {
1572 wxASSERT_MSG( (!m_needParent) || (parent), "Need complete parent." );
1573
1574 m_widget = (GtkWidget*) NULL;
1575 m_wxwindow = (GtkWidget*) NULL;
1576 m_hasVMT = FALSE;
1577 m_parent = parent;
1578 m_children.DeleteContents( FALSE );
1579
1580 m_width = size.x;
1581 if (m_width == -1) m_width = 20;
1582 m_height = size.y;
1583 if (m_height == -1) m_height = 20;
1584
1585 m_x = (int)pos.x;
1586 m_y = (int)pos.y;
1587
1588 if (!m_needParent) // some reasonable defaults
1589 {
1590 if (m_x == -1)
1591 {
1592 m_x = (gdk_screen_width () - m_width) / 2;
1593 if (m_x < 10) m_x = 10;
1594 }
1595 if (m_y == -1)
1596 {
1597 m_y = (gdk_screen_height () - m_height) / 2;
1598 if (m_y < 10) m_y = 10;
1599 }
1600 }
1601
1602 m_minWidth = -1;
1603 m_minHeight = -1;
1604 m_maxWidth = -1;
1605 m_maxHeight = -1;
1606
1607 m_retCode = 0;
1608
1609 m_eventHandler = this;
1610
1611 m_windowId = id == -1 ? wxNewId() : id;
1612
1613 m_sizeSet = FALSE;
1614
1615 m_cursor = new wxCursor( wxCURSOR_ARROW );
1616 m_font = *wxSWISS_FONT;
1617 m_backgroundColour = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
1618 m_foregroundColour = *wxBLACK;
1619 m_windowStyle = style;
1620 m_windowName = name;
1621
1622 m_constraints = (wxLayoutConstraints *) NULL;
1623 m_constraintsInvolvedIn = (wxList *) NULL;
1624 m_windowSizer = (wxSizer *) NULL;
1625 m_sizerParent = (wxWindow *) NULL;
1626 m_autoLayout = FALSE;
1627
1628 m_hasScrolling = FALSE;
1629 m_isScrolling = FALSE;
1630 m_hAdjust = (GtkAdjustment *) NULL;
1631 m_vAdjust = (GtkAdjustment *) NULL;
1632 m_oldHorizontalPos = 0.0;
1633 m_oldVerticalPos = 0.0;
1634
1635 m_isShown = FALSE;
1636 m_isEnabled = TRUE;
1637
1638 #if wxUSE_DRAG_AND_DROP
1639 m_dropTarget = (wxDropTarget *) NULL;
1640 #endif
1641 m_resizing = FALSE;
1642 m_windowValidator = (wxValidator *) NULL;
1643 m_scrollGC = (GdkGC*) NULL;
1644 m_widgetStyle = (GtkStyle*) NULL;
1645
1646 m_clientObject = (wxClientData*)NULL;
1647 m_clientData = NULL;
1648
1649 m_isStaticBox = FALSE;
1650
1651 #if wxUSE_TOOLTIPS
1652 m_toolTip = (wxToolTip*) NULL;
1653 #endif // wxUSE_TOOLTIPS
1654 }
1655
1656 void wxWindow::PostCreation()
1657 {
1658 if (m_wxwindow)
1659 {
1660 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
1661 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
1662
1663 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
1664 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
1665 }
1666
1667 ConnectWidget( GetConnectWidget() );
1668
1669 if (m_widget && m_parent) gtk_widget_realize( m_widget );
1670
1671 if (m_wxwindow) gtk_widget_realize( m_wxwindow );
1672
1673 SetCursor( *wxSTANDARD_CURSOR );
1674
1675 m_hasVMT = TRUE;
1676 }
1677
1678 void wxWindow::ConnectWidget( GtkWidget *widget )
1679 {
1680 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
1681 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
1682
1683 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
1684 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
1685
1686 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
1687 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
1688
1689 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
1690 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
1691
1692 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
1693 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
1694
1695 gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
1696 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
1697
1698 gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
1699 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
1700
1701 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
1702 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
1703
1704 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
1705 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
1706 }
1707
1708 bool wxWindow::HasVMT()
1709 {
1710 return m_hasVMT;
1711 }
1712
1713 bool wxWindow::Close( bool force )
1714 {
1715 wxASSERT_MSG( (m_widget != NULL), "invalid window" );
1716
1717 wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
1718 event.SetEventObject(this);
1719 event.SetCanVeto(!force);
1720
1721 // return FALSE if window wasn't closed because the application vetoed the
1722 // close event
1723 return GetEventHandler()->ProcessEvent(event) && !event.GetVeto();
1724 }
1725
1726 bool wxWindow::Destroy()
1727 {
1728 wxASSERT_MSG( (m_widget != NULL), "invalid window" );
1729
1730 m_hasVMT = FALSE;
1731 delete this;
1732 return TRUE;
1733 }
1734
1735 bool wxWindow::DestroyChildren()
1736 {
1737 wxNode *node;
1738 while ((node = m_children.First()) != (wxNode *)NULL)
1739 {
1740 wxWindow *child;
1741 if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
1742 {
1743 delete child;
1744 if (m_children.Member(child)) delete node;
1745 }
1746 }
1747 return TRUE;
1748 }
1749
1750 void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
1751 {
1752 // are we to set fonts here ?
1753 }
1754
1755 wxPoint wxWindow::GetClientAreaOrigin() const
1756 {
1757 return wxPoint(0,0);
1758 }
1759
1760 void wxWindow::AdjustForParentClientOrigin( int& x, int& y, int sizeFlags )
1761 {
1762 if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent())
1763 {
1764 wxPoint pt(GetParent()->GetClientAreaOrigin());
1765 x += pt.x;
1766 y += pt.y;
1767 }
1768 }
1769
1770 void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
1771 {
1772 wxASSERT_MSG( (m_widget != NULL), "invalid window" );
1773 wxASSERT_MSG( (m_parent != NULL), "wxWindow::SetSize requires parent.\n" );
1774
1775 if (m_resizing) return; // I don't like recursions
1776 m_resizing = TRUE;
1777
1778 if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
1779 {
1780 // don't set the size for children of wxNotebook, just take the values.
1781 m_x = x;
1782 m_y = y;
1783 m_width = width;
1784 m_height = height;
1785 }
1786 else
1787 {
1788 int old_width = m_width;
1789 int old_height = m_height;
1790
1791 if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
1792 {
1793 if (x != -1) m_x = x;
1794 if (y != -1) m_y = y;
1795 if (width != -1) m_width = width;
1796 if (height != -1) m_height = height;
1797 }
1798 else
1799 {
1800 m_x = x;
1801 m_y = y;
1802 m_width = width;
1803 m_height = height;
1804 }
1805
1806 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
1807 {
1808 if (width == -1) m_width = 80;
1809 }
1810
1811 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
1812 {
1813 if (height == -1) m_height = 26;
1814 }
1815
1816 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
1817 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
1818 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
1819 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
1820
1821 wxPoint pt( m_parent->GetClientAreaOrigin() );
1822 gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x+pt.x, m_y+pt.y );
1823
1824 if ((old_width != m_width) || (old_height != m_height))
1825 gtk_widget_set_usize( m_widget, m_width, m_height );
1826 }
1827
1828 m_sizeSet = TRUE;
1829
1830 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1831 event.SetEventObject( this );
1832 GetEventHandler()->ProcessEvent( event );
1833
1834 m_resizing = FALSE;
1835 }
1836
1837 void wxWindow::OnInternalIdle()
1838 {
1839 UpdateWindowUI();
1840 }
1841
1842 void wxWindow::SetSize( int width, int height )
1843 {
1844 SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
1845 }
1846
1847 void wxWindow::Move( int x, int y )
1848 {
1849 SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
1850 }
1851
1852 void wxWindow::GetSize( int *width, int *height ) const
1853 {
1854 wxCHECK_RET( (m_widget != NULL), "invalid window" );
1855
1856 if (width) (*width) = m_width;
1857 if (height) (*height) = m_height;
1858 }
1859
1860 void wxWindow::SetClientSize( int width, int height )
1861 {
1862 wxCHECK_RET( (m_widget != NULL), "invalid window" );
1863
1864 if (!m_wxwindow)
1865 {
1866 SetSize( width, height );
1867 }
1868 else
1869 {
1870 int dw = 0;
1871 int dh = 0;
1872
1873 if (!m_hasScrolling)
1874 {
1875 GtkStyleClass *window_class = m_wxwindow->style->klass;
1876
1877 if ((m_windowStyle & wxRAISED_BORDER) ||
1878 (m_windowStyle & wxSUNKEN_BORDER))
1879 {
1880 dw += 2 * window_class->xthickness;
1881 dh += 2 * window_class->ythickness;
1882 }
1883 }
1884 else
1885 {
1886 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1887 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1888
1889 #ifdef NEW_GTK_SCROLL_CODE
1890 GtkWidget *viewport = scroll_window->child;
1891 #else
1892 GtkWidget *viewport = scroll_window->viewport;
1893 #endif
1894
1895 GtkStyleClass *viewport_class = viewport->style->klass;
1896
1897 GtkWidget *hscrollbar = scroll_window->hscrollbar;
1898 GtkWidget *vscrollbar = scroll_window->vscrollbar;
1899
1900 if ((m_windowStyle & wxRAISED_BORDER) ||
1901 (m_windowStyle & wxSUNKEN_BORDER))
1902 {
1903 dw += 2 * viewport_class->xthickness;
1904 dh += 2 * viewport_class->ythickness;
1905 }
1906
1907 if (scroll_window->vscrollbar_visible)
1908 {
1909 dw += vscrollbar->allocation.width;
1910 dw += scroll_class->scrollbar_spacing;
1911 }
1912
1913 if (scroll_window->hscrollbar_visible)
1914 {
1915 dh += hscrollbar->allocation.height;
1916 dw += scroll_class->scrollbar_spacing;
1917 }
1918 }
1919
1920 SetSize( width+dw, height+dh );
1921 }
1922 }
1923
1924 void wxWindow::GetClientSize( int *width, int *height ) const
1925 {
1926 wxCHECK_RET( (m_widget != NULL), "invalid window" );
1927
1928 if (!m_wxwindow)
1929 {
1930 if (width) (*width) = m_width;
1931 if (height) (*height) = m_height;
1932 }
1933 else
1934 {
1935 int dw = 0;
1936 int dh = 0;
1937
1938 if (!m_hasScrolling)
1939 {
1940 GtkStyleClass *window_class = m_wxwindow->style->klass;
1941
1942 if ((m_windowStyle & wxRAISED_BORDER) ||
1943 (m_windowStyle & wxSUNKEN_BORDER))
1944 {
1945 dw += 2 * window_class->xthickness;
1946 dh += 2 * window_class->ythickness;
1947 }
1948 }
1949 else
1950 {
1951 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1952 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1953
1954 #ifdef NEW_GTK_SCROLL_CODE
1955 GtkWidget *viewport = scroll_window->child;
1956 #else
1957 GtkWidget *viewport = scroll_window->viewport;
1958 #endif
1959
1960 GtkStyleClass *viewport_class = viewport->style->klass;
1961
1962 if ((m_windowStyle & wxRAISED_BORDER) ||
1963 (m_windowStyle & wxSUNKEN_BORDER))
1964 {
1965 dw += 2 * viewport_class->xthickness;
1966 dh += 2 * viewport_class->ythickness;
1967 }
1968
1969 if (scroll_window->vscrollbar_visible)
1970 {
1971 // dw += vscrollbar->allocation.width;
1972 dw += 15; // range.slider_width = 11 + 2*2pts edge
1973 dw += scroll_class->scrollbar_spacing;
1974 }
1975
1976 if (scroll_window->hscrollbar_visible)
1977 {
1978 // dh += hscrollbar->allocation.height;
1979 dh += 15;
1980 dh += scroll_class->scrollbar_spacing;
1981 }
1982 }
1983
1984 if (width) (*width) = m_width - dw;
1985 if (height) (*height) = m_height - dh;
1986 }
1987 }
1988
1989 void wxWindow::GetPosition( int *x, int *y ) const
1990 {
1991 wxCHECK_RET( (m_widget != NULL), "invalid window" );
1992
1993 if (x) (*x) = m_x;
1994 if (y) (*y) = m_y;
1995 }
1996
1997 void wxWindow::ClientToScreen( int *x, int *y )
1998 {
1999 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2000
2001 GdkWindow *source = (GdkWindow *) NULL;
2002 if (m_wxwindow)
2003 source = m_wxwindow->window;
2004 else
2005 source = m_widget->window;
2006
2007 int org_x = 0;
2008 int org_y = 0;
2009 gdk_window_get_origin( source, &org_x, &org_y );
2010
2011 if (!m_wxwindow)
2012 {
2013 if (GTK_WIDGET_NO_WINDOW (m_widget))
2014 {
2015 org_x += m_widget->allocation.x;
2016 org_y += m_widget->allocation.y;
2017 }
2018 }
2019
2020 wxPoint pt(GetClientAreaOrigin());
2021 org_x += pt.x;
2022 org_y += pt.y;
2023
2024 if (x) *x += org_x;
2025 if (y) *y += org_y;
2026 }
2027
2028 void wxWindow::ScreenToClient( int *x, int *y )
2029 {
2030 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2031
2032 GdkWindow *source = (GdkWindow *) NULL;
2033 if (m_wxwindow)
2034 source = m_wxwindow->window;
2035 else
2036 source = m_widget->window;
2037
2038 int org_x = 0;
2039 int org_y = 0;
2040 gdk_window_get_origin( source, &org_x, &org_y );
2041
2042 if (!m_wxwindow)
2043 {
2044 if (GTK_WIDGET_NO_WINDOW (m_widget))
2045 {
2046 org_x += m_widget->allocation.x;
2047 org_y += m_widget->allocation.y;
2048 }
2049 }
2050
2051 wxPoint pt(GetClientAreaOrigin());
2052 org_x -= pt.x;
2053 org_y -= pt.y;
2054
2055 if (x) *x -= org_x;
2056 if (y) *y -= org_y;
2057 }
2058
2059 void wxWindow::Centre( int direction )
2060 {
2061 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2062
2063 int x = m_x;
2064 int y = m_y;
2065
2066 if (m_parent)
2067 {
2068 int p_w = 0;
2069 int p_h = 0;
2070 m_parent->GetSize( &p_w, &p_h );
2071 if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2;
2072 if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2;
2073 }
2074 else
2075 {
2076 if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
2077 if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
2078 }
2079
2080 Move( x, y );
2081 }
2082
2083 void wxWindow::Fit()
2084 {
2085 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2086
2087 int maxX = 0;
2088 int maxY = 0;
2089 wxNode *node = m_children.First();
2090 while (node)
2091 {
2092 wxWindow *win = (wxWindow *)node->Data();
2093 int wx, wy, ww, wh;
2094 win->GetPosition(&wx, &wy);
2095 win->GetSize(&ww, &wh);
2096 if (wx + ww > maxX) maxX = wx + ww;
2097 if (wy + wh > maxY) maxY = wy + wh;
2098
2099 node = node->Next();
2100 }
2101
2102 SetClientSize(maxX + 7, maxY + 14);
2103 }
2104
2105 void wxWindow::SetSizeHints( int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH) )
2106 {
2107 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2108
2109 m_minWidth = minW;
2110 m_minHeight = minH;
2111 m_maxWidth = maxW;
2112 m_maxHeight = maxH;
2113 }
2114
2115 void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
2116 {
2117 // if (GetAutoLayout()) Layout();
2118 }
2119
2120 bool wxWindow::Show( bool show )
2121 {
2122 wxCHECK_MSG( (m_widget != NULL), FALSE, "invalid window" );
2123
2124 if (show)
2125 gtk_widget_show( m_widget );
2126 else
2127 gtk_widget_hide( m_widget );
2128
2129 m_isShown = show;
2130
2131 return TRUE;
2132 }
2133
2134 void wxWindow::Enable( bool enable )
2135 {
2136 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2137
2138 m_isEnabled = enable;
2139
2140 gtk_widget_set_sensitive( m_widget, enable );
2141 if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
2142 }
2143
2144 int wxWindow::GetCharHeight() const
2145 {
2146 wxCHECK_MSG( (m_widget != NULL), 12, "invalid window" );
2147
2148 wxCHECK_MSG( m_font.Ok(), 12, "invalid font" );
2149
2150 GdkFont *font = m_font.GetInternalFont( 1.0 );
2151
2152 return font->ascent + font->descent;
2153 }
2154
2155 int wxWindow::GetCharWidth() const
2156 {
2157 wxCHECK_MSG( (m_widget != NULL), 8, "invalid window" );
2158
2159 wxCHECK_MSG( m_font.Ok(), 8, "invalid font" );
2160
2161 GdkFont *font = m_font.GetInternalFont( 1.0 );
2162
2163 return gdk_string_width( font, "H" );
2164 }
2165
2166 void wxWindow::GetTextExtent( const wxString& string, int *x, int *y,
2167 int *descent, int *externalLeading, const wxFont *theFont, bool WXUNUSED(use16) ) const
2168 {
2169 wxFont fontToUse = m_font;
2170 if (theFont) fontToUse = *theFont;
2171
2172 wxCHECK_RET( fontToUse.Ok(), "invalid font" );
2173
2174 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
2175 if (x) (*x) = gdk_string_width( font, string );
2176 if (y) (*y) = font->ascent + font->descent;
2177 if (descent) (*descent) = font->descent;
2178 if (externalLeading) (*externalLeading) = 0; // ??
2179 }
2180
2181 void wxWindow::MakeModal( bool modal )
2182 {
2183 return;
2184
2185 // Disable all other windows
2186 if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
2187 {
2188 wxNode *node = wxTopLevelWindows.First();
2189 while (node)
2190 {
2191 wxWindow *win = (wxWindow *)node->Data();
2192 if (win != this) win->Enable(!modal);
2193
2194 node = node->Next();
2195 }
2196 }
2197 }
2198
2199 void wxWindow::OnKeyDown( wxKeyEvent &event )
2200 {
2201 event.SetEventType( wxEVT_CHAR );
2202
2203 if (!GetEventHandler()->ProcessEvent( event ))
2204 {
2205 event.Skip();
2206 }
2207 }
2208
2209 void wxWindow::SetFocus()
2210 {
2211 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2212
2213 GtkWidget *connect_widget = GetConnectWidget();
2214 if (connect_widget)
2215 {
2216 if (GTK_WIDGET_CAN_FOCUS(connect_widget) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ )
2217 {
2218 gtk_widget_grab_focus (connect_widget);
2219 }
2220 else if (GTK_IS_CONTAINER(connect_widget))
2221 {
2222 gtk_container_focus( GTK_CONTAINER(connect_widget), GTK_DIR_TAB_FORWARD );
2223 }
2224 else
2225 {
2226 }
2227 }
2228 }
2229
2230 wxWindow *wxWindow::FindFocus()
2231 {
2232 return g_focusWindow;
2233 }
2234
2235 bool wxWindow::AcceptsFocus() const
2236 {
2237 return IsEnabled() && IsShown() && m_acceptsFocus;
2238 }
2239
2240 void wxWindow::AddChild( wxWindow *child )
2241 {
2242 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2243 wxCHECK_RET( (child != NULL), "invalid child" );
2244
2245 m_children.Append( child );
2246 }
2247
2248 wxWindow *wxWindow::ReParent( wxWindow *newParent )
2249 {
2250 wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, "invalid window" );
2251
2252 wxWindow *oldParent = GetParent();
2253
2254 if (oldParent) oldParent->RemoveChild( this );
2255
2256 gtk_widget_unparent( m_widget );
2257
2258 if (newParent)
2259 {
2260 newParent->AddChild( this );
2261 (newParent->m_insertCallback)( newParent, this );
2262 }
2263
2264 return oldParent;
2265 }
2266
2267 void wxWindow::RemoveChild( wxWindow *child )
2268 {
2269 m_children.DeleteObject( child );
2270 child->m_parent = (wxWindow *) NULL;
2271 }
2272
2273 void wxWindow::SetReturnCode( int retCode )
2274 {
2275 m_retCode = retCode;
2276 }
2277
2278 int wxWindow::GetReturnCode()
2279 {
2280 return m_retCode;
2281 }
2282
2283 void wxWindow::Raise()
2284 {
2285 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2286
2287 if (m_widget) gdk_window_raise( m_widget->window );
2288 }
2289
2290 void wxWindow::Lower()
2291 {
2292 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2293
2294 if (m_widget) gdk_window_lower( m_widget->window );
2295 }
2296
2297 wxEvtHandler *wxWindow::GetEventHandler() const
2298 {
2299 return m_eventHandler;
2300 }
2301
2302 void wxWindow::SetEventHandler( wxEvtHandler *handler )
2303 {
2304 m_eventHandler = handler;
2305 }
2306
2307 void wxWindow::PushEventHandler(wxEvtHandler *handler)
2308 {
2309 handler->SetNextHandler(GetEventHandler());
2310 SetEventHandler(handler);
2311 }
2312
2313 wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler)
2314 {
2315 if (GetEventHandler())
2316 {
2317 wxEvtHandler *handlerA = GetEventHandler();
2318 wxEvtHandler *handlerB = handlerA->GetNextHandler();
2319 handlerA->SetNextHandler((wxEvtHandler *) NULL);
2320 SetEventHandler(handlerB);
2321 if (deleteHandler)
2322 {
2323 delete handlerA;
2324 return (wxEvtHandler*) NULL;
2325 }
2326 else
2327 return handlerA;
2328 }
2329 else
2330 return (wxEvtHandler *) NULL;
2331 }
2332
2333 wxValidator *wxWindow::GetValidator()
2334 {
2335 return m_windowValidator;
2336 }
2337
2338 void wxWindow::SetValidator( const wxValidator& validator )
2339 {
2340 if (m_windowValidator) delete m_windowValidator;
2341 m_windowValidator = validator.Clone();
2342 if (m_windowValidator) m_windowValidator->SetWindow(this);
2343 }
2344
2345 void wxWindow::SetClientObject( wxClientData *data )
2346 {
2347 if (m_clientObject) delete m_clientObject;
2348 m_clientObject = data;
2349 }
2350
2351 wxClientData *wxWindow::GetClientObject()
2352 {
2353 return m_clientObject;
2354 }
2355
2356 void wxWindow::SetClientData( void *data )
2357 {
2358 m_clientData = data;
2359 }
2360
2361 void *wxWindow::GetClientData()
2362 {
2363 return m_clientData;
2364 }
2365
2366 bool wxWindow::IsBeingDeleted()
2367 {
2368 return FALSE;
2369 }
2370
2371 void wxWindow::SetId( wxWindowID id )
2372 {
2373 m_windowId = id;
2374 }
2375
2376 wxWindowID wxWindow::GetId() const
2377 {
2378 return m_windowId;
2379 }
2380
2381 void wxWindow::SetCursor( const wxCursor &cursor )
2382 {
2383 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2384
2385 if (cursor.Ok())
2386 {
2387 if (cursor == *m_cursor) return;
2388 *m_cursor = cursor;
2389 }
2390 else
2391 {
2392 *m_cursor = *wxSTANDARD_CURSOR;
2393 }
2394
2395 if ((m_widget) && (m_widget->window))
2396 gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
2397
2398 if ((m_wxwindow) && (m_wxwindow->window))
2399 gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
2400 }
2401
2402 void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
2403 {
2404 // TODO
2405 }
2406
2407 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
2408 {
2409 wxCHECK_RET( (m_widget != NULL), "invalid window" );
2410
2411 if (eraseBackground && m_wxwindow && m_wxwindow->window)
2412 {
2413 if (rect)
2414 {
2415 gdk_window_clear_area( m_wxwindow->window,
2416 rect->x, rect->y,
2417 rect->width,
2418 rect->height );
2419 }
2420 else
2421 {
2422 Clear();
2423 }
2424 }
2425
2426 if (!rect)
2427 {
2428 if (m_wxwindow)
2429 gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
2430 else
2431 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
2432 }
2433 else
2434 {
2435 GdkRectangle gdk_rect;
2436 gdk_rect.x = rect->x;
2437 gdk_rect.y = rect->y;
2438 gdk_rect.width = rect->width;
2439 gdk_rect.height = rect->height;
2440
2441 if (m_wxwindow)
2442 gtk_widget_draw( m_wxwindow, &gdk_rect );
2443 else
2444 gtk_widget_draw( m_widget, &gdk_rect );
2445 }
2446 }
2447
2448 wxRegion wxWindow::GetUpdateRegion() const
2449 {
2450 return m_updateRegion;
2451 }
2452
2453 bool wxWindow::IsExposed( int x, int y) const
2454 {
2455 return (m_updateRegion.Contains( x, y ) != wxOutRegion );
2456 }
2457
2458 bool wxWindow::IsExposed( int x, int y, int w, int h ) const
2459 {
2460 return (m_updateRegion.Contains( x, y, w, h ) != wxOutRegion );
2461 }
2462
2463 bool wxWindow::IsExposed( const wxPoint& pt ) const
2464 {
2465 return (m_updateRegion.Contains( pt.x, pt.y ) != wxOutRegion );
2466 }
2467
2468 bool wxWindow::IsExposed( const wxRect& rect ) const
2469 {
2470 return (m_updateRegion.Contains( rect.x, rect.y, rect.width, rect.height ) != wxOutRegion );
2471 }
2472
2473 void wxWindow::Clear()
2474 {
2475 wxCHECK_RET( m_widget != NULL, "invalid window" );
2476
2477 if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
2478 }
2479
2480 #if wxUSE_TOOLTIPS
2481 void wxWindow::SetToolTip( const wxString &tip )
2482 {
2483 if (m_toolTip)
2484 {
2485 m_toolTip->SetTip( tip );
2486 }
2487 else
2488 {
2489 SetToolTip( new wxToolTip( tip ) );
2490 }
2491
2492 // setting empty tooltip text does not remove the tooltip any more for
2493 // wxMSW compatibility - use SetToolTip((wxToolTip *)NULL) for this
2494 }
2495
2496 void wxWindow::SetToolTip( wxToolTip *tip )
2497 {
2498 if (m_toolTip)
2499 {
2500 m_toolTip->SetTip( (char*) NULL );
2501 delete m_toolTip;
2502 }
2503
2504 m_toolTip = tip;
2505
2506 if (m_toolTip)
2507 m_toolTip->Apply( this );
2508 }
2509
2510 void wxWindow::ApplyToolTip( GtkTooltips *tips, const char *tip )
2511 {
2512 gtk_tooltips_set_tip( tips, GetConnectWidget(), tip, (gchar*) NULL );
2513 }
2514 #endif // wxUSE_TOOLTIPS
2515
2516 wxColour wxWindow::GetBackgroundColour() const
2517 {
2518 return m_backgroundColour;
2519 }
2520
2521 void wxWindow::SetBackgroundColour( const wxColour &colour )
2522 {
2523 wxCHECK_RET( m_widget != NULL, "invalid window" );
2524
2525 if (m_backgroundColour == colour) return;
2526
2527 m_backgroundColour = colour;
2528 if (!m_backgroundColour.Ok()) return;
2529
2530 if (m_wxwindow)
2531 {
2532 GdkWindow *window = m_wxwindow->window;
2533 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
2534 gdk_window_set_background( window, m_backgroundColour.GetColor() );
2535 }
2536
2537 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2538 if (sysbg.Red() == colour.Red() &&
2539 sysbg.Green() == colour.Green() &&
2540 sysbg.Blue() == colour.Blue())
2541 {
2542 m_backgroundColour = wxNullColour;
2543 ApplyWidgetStyle();
2544 m_backgroundColour = sysbg;
2545 }
2546 else
2547 {
2548 ApplyWidgetStyle();
2549 }
2550 }
2551
2552 wxColour wxWindow::GetForegroundColour() const
2553 {
2554 return m_foregroundColour;
2555 }
2556
2557 void wxWindow::SetForegroundColour( const wxColour &colour )
2558 {
2559 wxCHECK_RET( m_widget != NULL, "invalid window" );
2560
2561 if (m_foregroundColour == colour) return;
2562
2563 m_foregroundColour = colour;
2564 if (!m_foregroundColour.Ok()) return;
2565
2566 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2567 if (sysbg.Red() == colour.Red() &&
2568 sysbg.Green() == colour.Green() &&
2569 sysbg.Blue() == colour.Blue())
2570 {
2571 m_backgroundColour = wxNullColour;
2572 ApplyWidgetStyle();
2573 m_backgroundColour = sysbg;
2574 }
2575 else
2576 {
2577 ApplyWidgetStyle();
2578 }
2579 }
2580
2581 GtkStyle *wxWindow::GetWidgetStyle()
2582 {
2583 if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
2584
2585 m_widgetStyle =
2586 gtk_style_copy(
2587 gtk_widget_get_style( m_widget ) );
2588
2589 return m_widgetStyle;
2590 }
2591
2592 void wxWindow::SetWidgetStyle()
2593 {
2594 GtkStyle *style = GetWidgetStyle();
2595
2596 gdk_font_unref( style->font );
2597 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
2598
2599 if (m_foregroundColour.Ok())
2600 {
2601 m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
2602 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
2603 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
2604 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
2605 }
2606
2607 if (m_backgroundColour.Ok())
2608 {
2609 m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
2610 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2611 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2612 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2613 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2614 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2615 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2616 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2617 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2618 }
2619 }
2620
2621 void wxWindow::ApplyWidgetStyle()
2622 {
2623 }
2624
2625 bool wxWindow::Validate()
2626 {
2627 wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2628
2629 wxNode *node = m_children.First();
2630 while (node)
2631 {
2632 wxWindow *child = (wxWindow *)node->Data();
2633 if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
2634 {
2635 return FALSE;
2636 }
2637 node = node->Next();
2638 }
2639 return TRUE;
2640 }
2641
2642 bool wxWindow::TransferDataToWindow()
2643 {
2644 wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2645
2646 wxNode *node = m_children.First();
2647 while (node)
2648 {
2649 wxWindow *child = (wxWindow *)node->Data();
2650 if (child->GetValidator() && /* child->GetValidator()->Ok() && */
2651 !child->GetValidator()->TransferToWindow() )
2652 {
2653 wxMessageBox( _("Application Error"), _("Could not transfer data to window"), wxOK|wxICON_EXCLAMATION );
2654 return FALSE;
2655 }
2656 node = node->Next();
2657 }
2658 return TRUE;
2659 }
2660
2661 bool wxWindow::TransferDataFromWindow()
2662 {
2663 wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2664
2665 wxNode *node = m_children.First();
2666 while (node)
2667 {
2668 wxWindow *child = (wxWindow *)node->Data();
2669 if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
2670 {
2671 return FALSE;
2672 }
2673 node = node->Next();
2674 }
2675 return TRUE;
2676 }
2677
2678 void wxWindow::SetAcceleratorTable( const wxAcceleratorTable& accel )
2679 {
2680 m_acceleratorTable = accel;
2681 }
2682
2683 void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
2684 {
2685 TransferDataToWindow();
2686 }
2687
2688 void wxWindow::InitDialog()
2689 {
2690 wxCHECK_RET( m_widget != NULL, "invalid window" );
2691
2692 wxInitDialogEvent event(GetId());
2693 event.SetEventObject( this );
2694 GetEventHandler()->ProcessEvent(event);
2695 }
2696
2697 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
2698 {
2699 menu->SetInvokingWindow( win );
2700 wxNode *node = menu->m_items.First();
2701 while (node)
2702 {
2703 wxMenuItem *menuitem = (wxMenuItem*)node->Data();
2704 if (menuitem->IsSubMenu())
2705 {
2706 SetInvokingWindow( menuitem->GetSubMenu(), win );
2707 }
2708 node = node->Next();
2709 }
2710 }
2711
2712 static gint gs_pop_x = 0;
2713 static gint gs_pop_y = 0;
2714
2715 static void pop_pos_callback( GtkMenu *menu, gint *x, gint *y, wxWindow *win )
2716 {
2717 win->ClientToScreen( &gs_pop_x, &gs_pop_y );
2718 *x = gs_pop_x;
2719 *y = gs_pop_y;
2720 }
2721
2722 bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
2723 {
2724 wxCHECK_MSG( m_widget != NULL, FALSE, "invalid window" );
2725
2726 wxCHECK_MSG( menu != NULL, FALSE, "invalid popup-menu" );
2727
2728 SetInvokingWindow( menu, this );
2729
2730 menu->UpdateUI();
2731
2732 gs_pop_x = x;
2733 gs_pop_y = y;
2734
2735 gtk_menu_popup(
2736 GTK_MENU(menu->m_menu),
2737 (GtkWidget *) NULL, // parent menu shell
2738 (GtkWidget *) NULL, // parent menu item
2739 (GtkMenuPositionFunc) pop_pos_callback,
2740 (gpointer) this, // client data
2741 0, // button used to activate it
2742 0 //gs_timeLastClick // the time of activation
2743 );
2744 return TRUE;
2745 }
2746
2747 #if wxUSE_DRAG_AND_DROP
2748
2749 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
2750 {
2751 wxCHECK_RET( m_widget != NULL, "invalid window" );
2752
2753 GtkWidget *dnd_widget = GetConnectWidget();
2754
2755 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
2756
2757 if (m_dropTarget) delete m_dropTarget;
2758 m_dropTarget = dropTarget;
2759
2760 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
2761 }
2762
2763 wxDropTarget *wxWindow::GetDropTarget() const
2764 {
2765 return m_dropTarget;
2766 }
2767
2768 #endif
2769
2770 GtkWidget* wxWindow::GetConnectWidget()
2771 {
2772 GtkWidget *connect_widget = m_widget;
2773 if (m_wxwindow) connect_widget = m_wxwindow;
2774
2775 return connect_widget;
2776 }
2777
2778 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
2779 {
2780 if (m_wxwindow) return (window == m_wxwindow->window);
2781 return (window == m_widget->window);
2782 }
2783
2784 void wxWindow::SetFont( const wxFont &font )
2785 {
2786 wxCHECK_RET( m_widget != NULL, "invalid window" );
2787
2788 if (((wxFont*)&font)->Ok())
2789 m_font = font;
2790 else
2791 m_font = *wxSWISS_FONT;
2792
2793 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2794 if (sysbg.Red() == m_backgroundColour.Red() &&
2795 sysbg.Green() == m_backgroundColour.Green() &&
2796 sysbg.Blue() == m_backgroundColour.Blue())
2797 {
2798 m_backgroundColour = wxNullColour;
2799 ApplyWidgetStyle();
2800 m_backgroundColour = sysbg;
2801 }
2802 else
2803 {
2804 ApplyWidgetStyle();
2805 }
2806 }
2807
2808 void wxWindow::SetWindowStyleFlag( long flag )
2809 {
2810 m_windowStyle = flag;
2811 }
2812
2813 long wxWindow::GetWindowStyleFlag() const
2814 {
2815 return m_windowStyle;
2816 }
2817
2818 void wxWindow::CaptureMouse()
2819 {
2820 wxCHECK_RET( m_widget != NULL, "invalid window" );
2821
2822 wxCHECK_RET( g_capturing == FALSE, "CaptureMouse called twice" );
2823
2824 GtkWidget *connect_widget = GetConnectWidget();
2825 gtk_grab_add( connect_widget );
2826 gdk_pointer_grab( connect_widget->window, FALSE,
2827 (GdkEventMask)
2828 (GDK_BUTTON_PRESS_MASK |
2829 GDK_BUTTON_RELEASE_MASK |
2830 GDK_POINTER_MOTION_MASK),
2831 (GdkWindow *) NULL,
2832 (GdkCursor *) NULL,
2833 GDK_CURRENT_TIME );
2834 g_capturing = TRUE;
2835 }
2836
2837 void wxWindow::ReleaseMouse()
2838 {
2839 wxCHECK_RET( m_widget != NULL, "invalid window" );
2840
2841 wxCHECK_RET( g_capturing == TRUE, "ReleaseMouse called twice" );
2842
2843 GtkWidget *connect_widget = GetConnectWidget();
2844 gtk_grab_remove( connect_widget );
2845 gdk_pointer_ungrab ( GDK_CURRENT_TIME );
2846 g_capturing = FALSE;
2847 }
2848
2849 void wxWindow::SetTitle( const wxString &WXUNUSED(title) )
2850 {
2851 }
2852
2853 wxString wxWindow::GetTitle() const
2854 {
2855 return (wxString&)m_windowName;
2856 }
2857
2858 wxString wxWindow::GetLabel() const
2859 {
2860 return GetTitle();
2861 }
2862
2863 void wxWindow::SetName( const wxString &name )
2864 {
2865 m_windowName = name;
2866 }
2867
2868 wxString wxWindow::GetName() const
2869 {
2870 return (wxString&)m_windowName;
2871 }
2872
2873 bool wxWindow::IsShown() const
2874 {
2875 return m_isShown;
2876 }
2877
2878 bool wxWindow::IsRetained()
2879 {
2880 return FALSE;
2881 }
2882
2883 wxWindow *wxWindow::FindWindow( long id )
2884 {
2885 if (id == m_windowId) return this;
2886 wxNode *node = m_children.First();
2887 while (node)
2888 {
2889 wxWindow *child = (wxWindow*)node->Data();
2890 wxWindow *res = child->FindWindow( id );
2891 if (res) return res;
2892 node = node->Next();
2893 }
2894 return (wxWindow *) NULL;
2895 }
2896
2897 wxWindow *wxWindow::FindWindow( const wxString& name )
2898 {
2899 if (name == m_windowName) return this;
2900 wxNode *node = m_children.First();
2901 while (node)
2902 {
2903 wxWindow *child = (wxWindow*)node->Data();
2904 wxWindow *res = child->FindWindow( name );
2905 if (res) return res;
2906 node = node->Next();
2907 }
2908 return (wxWindow *) NULL;
2909 }
2910
2911 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
2912 int range, bool refresh )
2913 {
2914 wxCHECK_RET( m_widget != NULL, "invalid window" );
2915
2916 wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
2917
2918 m_hasScrolling = TRUE;
2919
2920 if (orient == wxHORIZONTAL)
2921 {
2922 float fpos = (float)pos;
2923 float frange = (float)range;
2924 float fthumb = (float)thumbVisible;
2925 if (fpos > frange-fthumb) fpos = frange-fthumb;
2926 if (fpos < 0.0) fpos = 0.0;
2927
2928 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
2929 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
2930 {
2931 SetScrollPos( orient, pos, refresh );
2932 return;
2933 }
2934
2935 m_oldHorizontalPos = fpos;
2936
2937 m_hAdjust->lower = 0.0;
2938 m_hAdjust->upper = frange;
2939 m_hAdjust->value = fpos;
2940 m_hAdjust->step_increment = 1.0;
2941 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
2942 m_hAdjust->page_size = fthumb;
2943 }
2944 else
2945 {
2946 float fpos = (float)pos;
2947 float frange = (float)range;
2948 float fthumb = (float)thumbVisible;
2949 if (fpos > frange-fthumb) fpos = frange-fthumb;
2950 if (fpos < 0.0) fpos = 0.0;
2951
2952 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
2953 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
2954 {
2955 SetScrollPos( orient, pos, refresh );
2956 return;
2957 }
2958
2959 m_oldVerticalPos = fpos;
2960
2961 m_vAdjust->lower = 0.0;
2962 m_vAdjust->upper = frange;
2963 m_vAdjust->value = fpos;
2964 m_vAdjust->step_increment = 1.0;
2965 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
2966 m_vAdjust->page_size = fthumb;
2967 }
2968
2969 if (m_wxwindow->window)
2970 {
2971 if (orient == wxHORIZONTAL)
2972 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2973 else
2974 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2975
2976 gtk_widget_set_usize( m_widget, m_width, m_height );
2977 }
2978 }
2979
2980 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
2981 {
2982 wxCHECK_RET( m_widget != NULL, "invalid window" );
2983
2984 wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
2985
2986 if (orient == wxHORIZONTAL)
2987 {
2988 float fpos = (float)pos;
2989 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
2990 if (fpos < 0.0) fpos = 0.0;
2991 m_oldHorizontalPos = fpos;
2992
2993 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
2994 m_hAdjust->value = fpos;
2995 }
2996 else
2997 {
2998 float fpos = (float)pos;
2999 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
3000 if (fpos < 0.0) fpos = 0.0;
3001 m_oldVerticalPos = fpos;
3002
3003 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
3004 m_vAdjust->value = fpos;
3005 }
3006
3007 if (!m_isScrolling)
3008 {
3009 if (m_wxwindow->window)
3010 {
3011 if (orient == wxHORIZONTAL)
3012 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
3013 else
3014 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
3015 }
3016 }
3017 }
3018
3019 int wxWindow::GetScrollThumb( int orient ) const
3020 {
3021 wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
3022
3023 wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
3024
3025 if (orient == wxHORIZONTAL)
3026 return (int)(m_hAdjust->page_size+0.5);
3027 else
3028 return (int)(m_vAdjust->page_size+0.5);
3029 }
3030
3031 int wxWindow::GetScrollPos( int orient ) const
3032 {
3033 wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
3034
3035 wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
3036
3037 if (orient == wxHORIZONTAL)
3038 return (int)(m_hAdjust->value+0.5);
3039 else
3040 return (int)(m_vAdjust->value+0.5);
3041 }
3042
3043 int wxWindow::GetScrollRange( int orient ) const
3044 {
3045 wxCHECK_MSG( m_widget != NULL, 0, "invalid window" );
3046
3047 wxCHECK_MSG( m_wxwindow != NULL, 0, "window needs client area for scrolling" );
3048
3049 if (orient == wxHORIZONTAL)
3050 return (int)(m_hAdjust->upper+0.5);
3051 else
3052 return (int)(m_vAdjust->upper+0.5);
3053 }
3054
3055 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
3056 {
3057 wxCHECK_RET( m_widget != NULL, "invalid window" );
3058
3059 wxCHECK_RET( m_wxwindow != NULL, "window needs client area for scrolling" );
3060
3061 int cw = 0;
3062 int ch = 0;
3063 GetClientSize( &cw, &ch );
3064
3065 int w = cw - abs(dx);
3066 int h = ch - abs(dy);
3067 if ((h < 0) || (w < 0))
3068 {
3069 Refresh();
3070 return;
3071 }
3072 int s_x = 0;
3073 int s_y = 0;
3074 if (dx < 0) s_x = -dx;
3075 if (dy < 0) s_y = -dy;
3076 int d_x = 0;
3077 int d_y = 0;
3078 if (dx > 0) d_x = dx;
3079 if (dy > 0) d_y = dy;
3080
3081 if (!m_scrollGC)
3082 {
3083 m_scrollGC = gdk_gc_new( m_wxwindow->window );
3084 gdk_gc_set_exposures( m_scrollGC, TRUE );
3085 }
3086
3087 gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
3088 m_wxwindow->window, s_x, s_y, w, h );
3089
3090 wxRect rect;
3091 if (dx < 0) rect.x = cw+dx; else rect.x = 0;
3092 if (dy < 0) rect.y = ch+dy; else rect.y = 0;
3093 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
3094 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
3095
3096 Refresh( TRUE, &rect );
3097 }
3098
3099 //-------------------------------------------------------------------------------------
3100 // Layout
3101 //-------------------------------------------------------------------------------------
3102
3103 wxLayoutConstraints *wxWindow::GetConstraints() const
3104 {
3105 return m_constraints;
3106 }
3107
3108 void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
3109 {
3110 if (m_constraints)
3111 {
3112 UnsetConstraints(m_constraints);
3113 delete m_constraints;
3114 }
3115 m_constraints = constraints;
3116 if (m_constraints)
3117 {
3118 // Make sure other windows know they're part of a 'meaningful relationship'
3119 if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
3120 m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3121 if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
3122 m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3123 if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
3124 m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3125 if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
3126 m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3127 if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
3128 m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3129 if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
3130 m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3131 if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
3132 m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3133 if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
3134 m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
3135 }
3136 ;
3137 }
3138 ;
3139
3140 void wxWindow::SetAutoLayout( bool autoLayout )
3141 {
3142 m_autoLayout = autoLayout;
3143 }
3144
3145 bool wxWindow::GetAutoLayout() const
3146 {
3147 return m_autoLayout;
3148 }
3149
3150 wxSizer *wxWindow::GetSizer() const
3151 {
3152 return m_windowSizer;
3153 }
3154
3155 void wxWindow::SetSizerParent( wxWindow *win )
3156 {
3157 m_sizerParent = win;
3158 }
3159
3160 wxWindow *wxWindow::GetSizerParent() const
3161 {
3162 return m_sizerParent;
3163 }
3164
3165 // This removes any dangling pointers to this window
3166 // in other windows' constraintsInvolvedIn lists.
3167 void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
3168 {
3169 if (c)
3170 {
3171 if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
3172 c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3173 if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
3174 c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3175 if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
3176 c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3177 if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
3178 c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3179 if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
3180 c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3181 if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
3182 c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3183 if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
3184 c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3185 if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
3186 c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
3187 }
3188 }
3189
3190 // Back-pointer to other windows we're involved with, so if we delete
3191 // this window, we must delete any constraints we're involved with.
3192 void wxWindow::AddConstraintReference(wxWindow *otherWin)
3193 {
3194 if (!m_constraintsInvolvedIn)
3195 m_constraintsInvolvedIn = new wxList;
3196 if (!m_constraintsInvolvedIn->Member(otherWin))
3197 m_constraintsInvolvedIn->Append(otherWin);
3198 }
3199
3200 // REMOVE back-pointer to other windows we're involved with.
3201 void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
3202 {
3203 if (m_constraintsInvolvedIn)
3204 m_constraintsInvolvedIn->DeleteObject(otherWin);
3205 }
3206
3207 // Reset any constraints that mention this window
3208 void wxWindow::DeleteRelatedConstraints()
3209 {
3210 if (m_constraintsInvolvedIn)
3211 {
3212 wxNode *node = m_constraintsInvolvedIn->First();
3213 while (node)
3214 {
3215 wxWindow *win = (wxWindow *)node->Data();
3216 wxNode *next = node->Next();
3217 wxLayoutConstraints *constr = win->GetConstraints();
3218
3219 // Reset any constraints involving this window
3220 if (constr)
3221 {
3222 constr->left.ResetIfWin((wxWindow *)this);
3223 constr->top.ResetIfWin((wxWindow *)this);
3224 constr->right.ResetIfWin((wxWindow *)this);
3225 constr->bottom.ResetIfWin((wxWindow *)this);
3226 constr->width.ResetIfWin((wxWindow *)this);
3227 constr->height.ResetIfWin((wxWindow *)this);
3228 constr->centreX.ResetIfWin((wxWindow *)this);
3229 constr->centreY.ResetIfWin((wxWindow *)this);
3230 }
3231 delete node;
3232 node = next;
3233 }
3234 delete m_constraintsInvolvedIn;
3235 m_constraintsInvolvedIn = (wxList *) NULL;
3236 }
3237 }
3238
3239 void wxWindow::SetSizer(wxSizer *sizer)
3240 {
3241 m_windowSizer = sizer;
3242 if (sizer)
3243 sizer->SetSizerParent((wxWindow *)this);
3244 }
3245
3246 /*
3247 * New version
3248 */
3249
3250 bool wxWindow::Layout()
3251 {
3252 if (GetConstraints())
3253 {
3254 int w, h;
3255 GetClientSize(&w, &h);
3256 GetConstraints()->width.SetValue(w);
3257 GetConstraints()->height.SetValue(h);
3258 }
3259
3260 // If top level (one sizer), evaluate the sizer's constraints.
3261 if (GetSizer())
3262 {
3263 int noChanges;
3264 GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated
3265 GetSizer()->LayoutPhase1(&noChanges);
3266 GetSizer()->LayoutPhase2(&noChanges);
3267 GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
3268 return TRUE;
3269 }
3270 else
3271 {
3272 // Otherwise, evaluate child constraints
3273 ResetConstraints(); // Mark all constraints as unevaluated
3274 DoPhase(1); // Just one phase need if no sizers involved
3275 DoPhase(2);
3276 SetConstraintSizes(); // Recursively set the real window sizes
3277 }
3278 return TRUE;
3279 }
3280
3281
3282 // Do a phase of evaluating constraints:
3283 // the default behaviour. wxSizers may do a similar
3284 // thing, but also impose their own 'constraints'
3285 // and order the evaluation differently.
3286 bool wxWindow::LayoutPhase1(int *noChanges)
3287 {
3288 wxLayoutConstraints *constr = GetConstraints();
3289 if (constr)
3290 {
3291 return constr->SatisfyConstraints((wxWindow *)this, noChanges);
3292 }
3293 else
3294 return TRUE;
3295 }
3296
3297 bool wxWindow::LayoutPhase2(int *noChanges)
3298 {
3299 *noChanges = 0;
3300
3301 // Layout children
3302 DoPhase(1);
3303 DoPhase(2);
3304 return TRUE;
3305 }
3306
3307 // Do a phase of evaluating child constraints
3308 bool wxWindow::DoPhase(int phase)
3309 {
3310 int noIterations = 0;
3311 int maxIterations = 500;
3312 int noChanges = 1;
3313 int noFailures = 0;
3314 wxList succeeded;
3315 while ((noChanges > 0) && (noIterations < maxIterations))
3316 {
3317 noChanges = 0;
3318 noFailures = 0;
3319 wxNode *node = m_children.First();
3320 while (node)
3321 {
3322 wxWindow *child = (wxWindow *)node->Data();
3323 if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
3324 {
3325 wxLayoutConstraints *constr = child->GetConstraints();
3326 if (constr)
3327 {
3328 if (succeeded.Member(child))
3329 {
3330 }
3331 else
3332 {
3333 int tempNoChanges = 0;
3334 bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
3335 noChanges += tempNoChanges;
3336 if (success)
3337 {
3338 succeeded.Append(child);
3339 }
3340 }
3341 }
3342 }
3343 node = node->Next();
3344 }
3345 noIterations ++;
3346 }
3347 return TRUE;
3348 }
3349
3350 void wxWindow::ResetConstraints()
3351 {
3352 wxLayoutConstraints *constr = GetConstraints();
3353 if (constr)
3354 {
3355 constr->left.SetDone(FALSE);
3356 constr->top.SetDone(FALSE);
3357 constr->right.SetDone(FALSE);
3358 constr->bottom.SetDone(FALSE);
3359 constr->width.SetDone(FALSE);
3360 constr->height.SetDone(FALSE);
3361 constr->centreX.SetDone(FALSE);
3362 constr->centreY.SetDone(FALSE);
3363 }
3364 wxNode *node = m_children.First();
3365 while (node)
3366 {
3367 wxWindow *win = (wxWindow *)node->Data();
3368 if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
3369 win->ResetConstraints();
3370 node = node->Next();
3371 }
3372 }
3373
3374 // Need to distinguish between setting the 'fake' size for
3375 // windows and sizers, and setting the real values.
3376 void wxWindow::SetConstraintSizes(bool recurse)
3377 {
3378 wxLayoutConstraints *constr = GetConstraints();
3379 if (constr && constr->left.GetDone() && constr->right.GetDone() &&
3380 constr->width.GetDone() && constr->height.GetDone())
3381 {
3382 int x = constr->left.GetValue();
3383 int y = constr->top.GetValue();
3384 int w = constr->width.GetValue();
3385 int h = constr->height.GetValue();
3386
3387 // If we don't want to resize this window, just move it...
3388 if ((constr->width.GetRelationship() != wxAsIs) ||
3389 (constr->height.GetRelationship() != wxAsIs))
3390 {
3391 // Calls Layout() recursively. AAAGH. How can we stop that.
3392 // Simply take Layout() out of non-top level OnSizes.
3393 SizerSetSize(x, y, w, h);
3394 }
3395 else
3396 {
3397 SizerMove(x, y);
3398 }
3399 }
3400 else if (constr)
3401 {
3402 char *windowClass = this->GetClassInfo()->GetClassName();
3403
3404 wxString winName;
3405 if (GetName() == "")
3406 winName = "unnamed";
3407 else
3408 winName = GetName();
3409 wxLogDebug( "Constraint(s) not satisfied for window of type %s, name %s:\n",
3410 (const char *)windowClass,
3411 (const char *)winName);
3412 if (!constr->left.GetDone()) wxLogDebug( " unsatisfied 'left' constraint.\n" );
3413 if (!constr->right.GetDone()) wxLogDebug( " unsatisfied 'right' constraint.\n" );
3414 if (!constr->width.GetDone()) wxLogDebug( " unsatisfied 'width' constraint.\n" );
3415 if (!constr->height.GetDone()) wxLogDebug( " unsatisfied 'height' constraint.\n" );
3416 wxLogDebug( "Please check constraints: try adding AsIs() constraints.\n" );
3417 }
3418
3419 if (recurse)
3420 {
3421 wxNode *node = m_children.First();
3422 while (node)
3423 {
3424 wxWindow *win = (wxWindow *)node->Data();
3425 if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
3426 win->SetConstraintSizes();
3427 node = node->Next();
3428 }
3429 }
3430 }
3431
3432 // This assumes that all sizers are 'on' the same
3433 // window, i.e. the parent of this window.
3434 void wxWindow::TransformSizerToActual(int *x, int *y) const
3435 {
3436 if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
3437 m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
3438 return;
3439
3440 int xp, yp;
3441 m_sizerParent->GetPosition(&xp, &yp);
3442 m_sizerParent->TransformSizerToActual(&xp, &yp);
3443 *x += xp;
3444 *y += yp;
3445 }
3446
3447 void wxWindow::SizerSetSize(int x, int y, int w, int h)
3448 {
3449 int xx = x;
3450 int yy = y;
3451 TransformSizerToActual(&xx, &yy);
3452 SetSize(xx, yy, w, h);
3453 }
3454
3455 void wxWindow::SizerMove(int x, int y)
3456 {
3457 int xx = x;
3458 int yy = y;
3459 TransformSizerToActual(&xx, &yy);
3460 Move(xx, yy);
3461 }
3462
3463 // Only set the size/position of the constraint (if any)
3464 void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
3465 {
3466 wxLayoutConstraints *constr = GetConstraints();
3467 if (constr)
3468 {
3469 if (x != -1)
3470 {
3471 constr->left.SetValue(x);
3472 constr->left.SetDone(TRUE);
3473 }
3474 if (y != -1)
3475 {
3476 constr->top.SetValue(y);
3477 constr->top.SetDone(TRUE);
3478 }
3479 if (w != -1)
3480 {
3481 constr->width.SetValue(w);
3482 constr->width.SetDone(TRUE);
3483 }
3484 if (h != -1)
3485 {
3486 constr->height.SetValue(h);
3487 constr->height.SetDone(TRUE);
3488 }
3489 }
3490 }
3491
3492 void wxWindow::MoveConstraint(int x, int y)
3493 {
3494 wxLayoutConstraints *constr = GetConstraints();
3495 if (constr)
3496 {
3497 if (x != -1)
3498 {
3499 constr->left.SetValue(x);
3500 constr->left.SetDone(TRUE);
3501 }
3502 if (y != -1)
3503 {
3504 constr->top.SetValue(y);
3505 constr->top.SetDone(TRUE);
3506 }
3507 }
3508 }
3509
3510 void wxWindow::GetSizeConstraint(int *w, int *h) const
3511 {
3512 wxLayoutConstraints *constr = GetConstraints();
3513 if (constr)
3514 {
3515 *w = constr->width.GetValue();
3516 *h = constr->height.GetValue();
3517 }
3518 else
3519 GetSize(w, h);
3520 }
3521
3522 void wxWindow::GetClientSizeConstraint(int *w, int *h) const
3523 {
3524 wxLayoutConstraints *constr = GetConstraints();
3525 if (constr)
3526 {
3527 *w = constr->width.GetValue();
3528 *h = constr->height.GetValue();
3529 }
3530 else
3531 GetClientSize(w, h);
3532 }
3533
3534 void wxWindow::GetPositionConstraint(int *x, int *y) const
3535 {
3536 wxLayoutConstraints *constr = GetConstraints();
3537 if (constr)
3538 {
3539 *x = constr->left.GetValue();
3540 *y = constr->top.GetValue();
3541 }
3542 else
3543 GetPosition(x, y);
3544 }
3545
wxWidgets (Impactor)