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