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