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