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