]> 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
Changed the "delete win" to the more proper "win->Destroy()" in
[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 if (fpos > frange-fthumb) fpos = frange-fthumb;
2432 if (fpos < 0.0) fpos = 0.0;
2433
2434 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
2435 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
2436 {
2437 SetScrollPos( orient, pos, refresh );
2438 return;
2439 }
2440
2441 m_oldHorizontalPos = fpos;
2442
2443 m_hAdjust->lower = 0.0;
2444 m_hAdjust->upper = frange;
2445 m_hAdjust->value = fpos;
2446 m_hAdjust->step_increment = 1.0;
2447 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
2448 m_hAdjust->page_size = fthumb;
2449 }
2450 else
2451 {
2452 float fpos = (float)pos;
2453 float frange = (float)range;
2454 float fthumb = (float)thumbVisible;
2455 if (fpos > frange-fthumb) fpos = frange-fthumb;
2456 if (fpos < 0.0) fpos = 0.0;
2457
2458 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
2459 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
2460 {
2461 SetScrollPos( orient, pos, refresh );
2462 return;
2463 }
2464
2465 m_oldVerticalPos = fpos;
2466
2467 m_vAdjust->lower = 0.0;
2468 m_vAdjust->upper = frange;
2469 m_vAdjust->value = fpos;
2470 m_vAdjust->step_increment = 1.0;
2471 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
2472 m_vAdjust->page_size = fthumb;
2473 }
2474
2475 if (m_wxwindow->window)
2476 {
2477 if (orient == wxHORIZONTAL)
2478 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2479 else
2480 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2481
2482 gtk_widget_set_usize( m_widget, m_width, m_height );
2483 }
2484 }
2485
2486 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
2487 {
2488 wxASSERT_MSG( (m_widget != NULL), "invalid window" );
2489
2490 wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
2491
2492 if (!m_wxwindow) return;
2493
2494 if (orient == wxHORIZONTAL)
2495 {
2496 float fpos = (float)pos;
2497 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
2498 if (fpos < 0.0) fpos = 0.0;
2499 m_oldHorizontalPos = fpos;
2500
2501 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
2502 m_hAdjust->value = fpos;
2503 }
2504 else
2505 {
2506 float fpos = (float)pos;
2507 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
2508 if (fpos < 0.0) fpos = 0.0;
2509 m_oldVerticalPos = fpos;
2510
2511 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
2512 m_vAdjust->value = fpos;
2513 }
2514
2515 if (!m_isScrolling)
2516 {
2517 if (m_wxwindow->window)
2518 {
2519 if (orient == wxHORIZONTAL)
2520 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
2521 else
2522 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
2523 }
2524 }
2525 }
2526
2527 int wxWindow::GetScrollThumb( int orient ) const
2528 {
2529 wxASSERT_MSG( (m_widget != NULL), "invalid window" );
2530
2531 wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
2532
2533 if (!m_wxwindow) return 0;
2534
2535 if (orient == wxHORIZONTAL)
2536 return (int)(m_hAdjust->page_size+0.5);
2537 else
2538 return (int)(m_vAdjust->page_size+0.5);
2539 }
2540
2541 int wxWindow::GetScrollPos( int orient ) const
2542 {
2543 wxASSERT_MSG( (m_widget != NULL), "invalid window" );
2544
2545 wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
2546
2547 if (!m_wxwindow) return 0;
2548
2549 if (orient == wxHORIZONTAL)
2550 return (int)(m_hAdjust->value+0.5);
2551 else
2552 return (int)(m_vAdjust->value+0.5);
2553 }
2554
2555 int wxWindow::GetScrollRange( int orient ) const
2556 {
2557 wxASSERT_MSG( (m_widget != NULL), "invalid window" );
2558
2559 wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
2560
2561 if (!m_wxwindow) return 0;
2562
2563 if (orient == wxHORIZONTAL)
2564 return (int)(m_hAdjust->upper+0.5);
2565 else
2566 return (int)(m_vAdjust->upper+0.5);
2567 }
2568
2569 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
2570 {
2571 wxASSERT_MSG( (m_widget != NULL), "invalid window" );
2572
2573 wxASSERT_MSG( (m_wxwindow != NULL), "window needs client area" );
2574
2575 if (!m_wxwindow) return;
2576
2577 int cw = 0;
2578 int ch = 0;
2579 GetClientSize( &cw, &ch );
2580
2581 int w = cw - abs(dx);
2582 int h = ch - abs(dy);
2583 if ((h < 0) || (w < 0))
2584 {
2585 Refresh();
2586 return;
2587 }
2588 int s_x = 0;
2589 int s_y = 0;
2590 if (dx < 0) s_x = -dx;
2591 if (dy < 0) s_y = -dy;
2592 int d_x = 0;
2593 int d_y = 0;
2594 if (dx > 0) d_x = dx;
2595 if (dy > 0) d_y = dy;
2596
2597 if (!m_scrollGC)
2598 {
2599 m_scrollGC = gdk_gc_new( m_wxwindow->window );
2600 gdk_gc_set_exposures( m_scrollGC, TRUE );
2601 }
2602
2603 gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
2604 m_wxwindow->window, s_x, s_y, w, h );
2605
2606 wxRect rect;
2607 if (dx < 0) rect.x = cw+dx; else rect.x = 0;
2608 if (dy < 0) rect.y = ch+dy; else rect.y = 0;
2609 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
2610 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
2611
2612 Refresh( TRUE, &rect );
2613 }
2614
2615 //-------------------------------------------------------------------------------------
2616 // Layout
2617 //-------------------------------------------------------------------------------------
2618
2619 wxLayoutConstraints *wxWindow::GetConstraints() const
2620 {
2621 return m_constraints;
2622 }
2623
2624 void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
2625 {
2626 if (m_constraints)
2627 {
2628 UnsetConstraints(m_constraints);
2629 delete m_constraints;
2630 }
2631 m_constraints = constraints;
2632 if (m_constraints)
2633 {
2634 // Make sure other windows know they're part of a 'meaningful relationship'
2635 if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
2636 m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2637 if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
2638 m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2639 if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
2640 m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2641 if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
2642 m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2643 if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
2644 m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2645 if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
2646 m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2647 if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
2648 m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2649 if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
2650 m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2651 }
2652 ;
2653 }
2654 ;
2655
2656 void wxWindow::SetAutoLayout( bool autoLayout )
2657 {
2658 m_autoLayout = autoLayout;
2659 }
2660
2661 bool wxWindow::GetAutoLayout() const
2662 {
2663 return m_autoLayout;
2664 }
2665
2666 wxSizer *wxWindow::GetSizer() const
2667 {
2668 return m_windowSizer;
2669 }
2670
2671 void wxWindow::SetSizerParent( wxWindow *win )
2672 {
2673 m_sizerParent = win;
2674 }
2675
2676 wxWindow *wxWindow::GetSizerParent() const
2677 {
2678 return m_sizerParent;
2679 }
2680
2681 // This removes any dangling pointers to this window
2682 // in other windows' constraintsInvolvedIn lists.
2683 void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
2684 {
2685 if (c)
2686 {
2687 if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
2688 c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2689 if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
2690 c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2691 if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
2692 c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2693 if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
2694 c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2695 if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
2696 c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2697 if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
2698 c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2699 if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
2700 c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2701 if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
2702 c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2703 }
2704 }
2705
2706 // Back-pointer to other windows we're involved with, so if we delete
2707 // this window, we must delete any constraints we're involved with.
2708 void wxWindow::AddConstraintReference(wxWindow *otherWin)
2709 {
2710 if (!m_constraintsInvolvedIn)
2711 m_constraintsInvolvedIn = new wxList;
2712 if (!m_constraintsInvolvedIn->Member(otherWin))
2713 m_constraintsInvolvedIn->Append(otherWin);
2714 }
2715
2716 // REMOVE back-pointer to other windows we're involved with.
2717 void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
2718 {
2719 if (m_constraintsInvolvedIn)
2720 m_constraintsInvolvedIn->DeleteObject(otherWin);
2721 }
2722
2723 // Reset any constraints that mention this window
2724 void wxWindow::DeleteRelatedConstraints()
2725 {
2726 if (m_constraintsInvolvedIn)
2727 {
2728 wxNode *node = m_constraintsInvolvedIn->First();
2729 while (node)
2730 {
2731 wxWindow *win = (wxWindow *)node->Data();
2732 wxNode *next = node->Next();
2733 wxLayoutConstraints *constr = win->GetConstraints();
2734
2735 // Reset any constraints involving this window
2736 if (constr)
2737 {
2738 constr->left.ResetIfWin((wxWindow *)this);
2739 constr->top.ResetIfWin((wxWindow *)this);
2740 constr->right.ResetIfWin((wxWindow *)this);
2741 constr->bottom.ResetIfWin((wxWindow *)this);
2742 constr->width.ResetIfWin((wxWindow *)this);
2743 constr->height.ResetIfWin((wxWindow *)this);
2744 constr->centreX.ResetIfWin((wxWindow *)this);
2745 constr->centreY.ResetIfWin((wxWindow *)this);
2746 }
2747 delete node;
2748 node = next;
2749 }
2750 delete m_constraintsInvolvedIn;
2751 m_constraintsInvolvedIn = (wxList *) NULL;
2752 }
2753 }
2754
2755 void wxWindow::SetSizer(wxSizer *sizer)
2756 {
2757 m_windowSizer = sizer;
2758 if (sizer)
2759 sizer->SetSizerParent((wxWindow *)this);
2760 }
2761
2762 /*
2763 * New version
2764 */
2765
2766 bool wxWindow::Layout()
2767 {
2768 if (GetConstraints())
2769 {
2770 int w, h;
2771 GetClientSize(&w, &h);
2772 GetConstraints()->width.SetValue(w);
2773 GetConstraints()->height.SetValue(h);
2774 }
2775
2776 // If top level (one sizer), evaluate the sizer's constraints.
2777 if (GetSizer())
2778 {
2779 int noChanges;
2780 GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated
2781 GetSizer()->LayoutPhase1(&noChanges);
2782 GetSizer()->LayoutPhase2(&noChanges);
2783 GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
2784 return TRUE;
2785 }
2786 else
2787 {
2788 // Otherwise, evaluate child constraints
2789 ResetConstraints(); // Mark all constraints as unevaluated
2790 DoPhase(1); // Just one phase need if no sizers involved
2791 DoPhase(2);
2792 SetConstraintSizes(); // Recursively set the real window sizes
2793 }
2794 return TRUE;
2795 }
2796
2797
2798 // Do a phase of evaluating constraints:
2799 // the default behaviour. wxSizers may do a similar
2800 // thing, but also impose their own 'constraints'
2801 // and order the evaluation differently.
2802 bool wxWindow::LayoutPhase1(int *noChanges)
2803 {
2804 wxLayoutConstraints *constr = GetConstraints();
2805 if (constr)
2806 {
2807 return constr->SatisfyConstraints((wxWindow *)this, noChanges);
2808 }
2809 else
2810 return TRUE;
2811 }
2812
2813 bool wxWindow::LayoutPhase2(int *noChanges)
2814 {
2815 *noChanges = 0;
2816
2817 // Layout children
2818 DoPhase(1);
2819 DoPhase(2);
2820 return TRUE;
2821 }
2822
2823 // Do a phase of evaluating child constraints
2824 bool wxWindow::DoPhase(int phase)
2825 {
2826 int noIterations = 0;
2827 int maxIterations = 500;
2828 int noChanges = 1;
2829 int noFailures = 0;
2830 wxList succeeded;
2831 while ((noChanges > 0) && (noIterations < maxIterations))
2832 {
2833 noChanges = 0;
2834 noFailures = 0;
2835 wxNode *node = m_children.First();
2836 while (node)
2837 {
2838 wxWindow *child = (wxWindow *)node->Data();
2839 if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
2840 {
2841 wxLayoutConstraints *constr = child->GetConstraints();
2842 if (constr)
2843 {
2844 if (succeeded.Member(child))
2845 {
2846 }
2847 else
2848 {
2849 int tempNoChanges = 0;
2850 bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
2851 noChanges += tempNoChanges;
2852 if (success)
2853 {
2854 succeeded.Append(child);
2855 }
2856 }
2857 }
2858 }
2859 node = node->Next();
2860 }
2861 noIterations ++;
2862 }
2863 return TRUE;
2864 }
2865
2866 void wxWindow::ResetConstraints()
2867 {
2868 wxLayoutConstraints *constr = GetConstraints();
2869 if (constr)
2870 {
2871 constr->left.SetDone(FALSE);
2872 constr->top.SetDone(FALSE);
2873 constr->right.SetDone(FALSE);
2874 constr->bottom.SetDone(FALSE);
2875 constr->width.SetDone(FALSE);
2876 constr->height.SetDone(FALSE);
2877 constr->centreX.SetDone(FALSE);
2878 constr->centreY.SetDone(FALSE);
2879 }
2880 wxNode *node = m_children.First();
2881 while (node)
2882 {
2883 wxWindow *win = (wxWindow *)node->Data();
2884 if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
2885 win->ResetConstraints();
2886 node = node->Next();
2887 }
2888 }
2889
2890 // Need to distinguish between setting the 'fake' size for
2891 // windows and sizers, and setting the real values.
2892 void wxWindow::SetConstraintSizes(bool recurse)
2893 {
2894 wxLayoutConstraints *constr = GetConstraints();
2895 if (constr && constr->left.GetDone() && constr->right.GetDone() &&
2896 constr->width.GetDone() && constr->height.GetDone())
2897 {
2898 int x = constr->left.GetValue();
2899 int y = constr->top.GetValue();
2900 int w = constr->width.GetValue();
2901 int h = constr->height.GetValue();
2902
2903 // If we don't want to resize this window, just move it...
2904 if ((constr->width.GetRelationship() != wxAsIs) ||
2905 (constr->height.GetRelationship() != wxAsIs))
2906 {
2907 // Calls Layout() recursively. AAAGH. How can we stop that.
2908 // Simply take Layout() out of non-top level OnSizes.
2909 SizerSetSize(x, y, w, h);
2910 }
2911 else
2912 {
2913 SizerMove(x, y);
2914 }
2915 }
2916 else if (constr)
2917 {
2918 char *windowClass = this->GetClassInfo()->GetClassName();
2919
2920 wxString winName;
2921 if (GetName() == "")
2922 winName = "unnamed";
2923 else
2924 winName = GetName();
2925 wxLogDebug( "Constraint(s) not satisfied for window of type %s, name %s:\n",
2926 (const char *)windowClass,
2927 (const char *)winName);
2928 if (!constr->left.GetDone()) wxLogDebug( " unsatisfied 'left' constraint.\n" );
2929 if (!constr->right.GetDone()) wxLogDebug( " unsatisfied 'right' constraint.\n" );
2930 if (!constr->width.GetDone()) wxLogDebug( " unsatisfied 'width' constraint.\n" );
2931 if (!constr->height.GetDone()) wxLogDebug( " unsatisfied 'height' constraint.\n" );
2932 wxLogDebug( "Please check constraints: try adding AsIs() constraints.\n" );
2933 }
2934
2935 if (recurse)
2936 {
2937 wxNode *node = m_children.First();
2938 while (node)
2939 {
2940 wxWindow *win = (wxWindow *)node->Data();
2941 if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
2942 win->SetConstraintSizes();
2943 node = node->Next();
2944 }
2945 }
2946 }
2947
2948 // This assumes that all sizers are 'on' the same
2949 // window, i.e. the parent of this window.
2950 void wxWindow::TransformSizerToActual(int *x, int *y) const
2951 {
2952 if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
2953 m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
2954 return;
2955
2956 int xp, yp;
2957 m_sizerParent->GetPosition(&xp, &yp);
2958 m_sizerParent->TransformSizerToActual(&xp, &yp);
2959 *x += xp;
2960 *y += yp;
2961 }
2962
2963 void wxWindow::SizerSetSize(int x, int y, int w, int h)
2964 {
2965 int xx = x;
2966 int yy = y;
2967 TransformSizerToActual(&xx, &yy);
2968 SetSize(xx, yy, w, h);
2969 }
2970
2971 void wxWindow::SizerMove(int x, int y)
2972 {
2973 int xx = x;
2974 int yy = y;
2975 TransformSizerToActual(&xx, &yy);
2976 Move(xx, yy);
2977 }
2978
2979 // Only set the size/position of the constraint (if any)
2980 void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
2981 {
2982 wxLayoutConstraints *constr = GetConstraints();
2983 if (constr)
2984 {
2985 if (x != -1)
2986 {
2987 constr->left.SetValue(x);
2988 constr->left.SetDone(TRUE);
2989 }
2990 if (y != -1)
2991 {
2992 constr->top.SetValue(y);
2993 constr->top.SetDone(TRUE);
2994 }
2995 if (w != -1)
2996 {
2997 constr->width.SetValue(w);
2998 constr->width.SetDone(TRUE);
2999 }
3000 if (h != -1)
3001 {
3002 constr->height.SetValue(h);
3003 constr->height.SetDone(TRUE);
3004 }
3005 }
3006 }
3007
3008 void wxWindow::MoveConstraint(int x, int y)
3009 {
3010 wxLayoutConstraints *constr = GetConstraints();
3011 if (constr)
3012 {
3013 if (x != -1)
3014 {
3015 constr->left.SetValue(x);
3016 constr->left.SetDone(TRUE);
3017 }
3018 if (y != -1)
3019 {
3020 constr->top.SetValue(y);
3021 constr->top.SetDone(TRUE);
3022 }
3023 }
3024 }
3025
3026 void wxWindow::GetSizeConstraint(int *w, int *h) const
3027 {
3028 wxLayoutConstraints *constr = GetConstraints();
3029 if (constr)
3030 {
3031 *w = constr->width.GetValue();
3032 *h = constr->height.GetValue();
3033 }
3034 else
3035 GetSize(w, h);
3036 }
3037
3038 void wxWindow::GetClientSizeConstraint(int *w, int *h) const
3039 {
3040 wxLayoutConstraints *constr = GetConstraints();
3041 if (constr)
3042 {
3043 *w = constr->width.GetValue();
3044 *h = constr->height.GetValue();
3045 }
3046 else
3047 GetClientSize(w, h);
3048 }
3049
3050 void wxWindow::GetPositionConstraint(int *x, int *y) const
3051 {
3052 wxLayoutConstraints *constr = GetConstraints();
3053 if (constr)
3054 {
3055 *x = constr->left.GetValue();
3056 *y = constr->top.GetValue();
3057 }
3058 else
3059 GetPosition(x, y);
3060 }
3061
3062 bool wxWindow::AcceptsFocus() const
3063 {
3064 return IsEnabled() && IsShown();
3065 }
3066
3067 void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event) )
3068 {
3069 UpdateWindowUI();
3070 }
wxWidgets (Impactor)