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