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