]> git.saurik.com Git - wxWidgets.git/blame - src/gtk1/window.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New toolbar event processing
[wxWidgets.git] / src / gtk1 / window.cpp
CommitLineData
c801d85f
KB		 1/////////////////////////////////////////////////////////////////////////////
2// Name: window.cpp
3// Purpose:
4// Author: Robert Roebling
5// Created: 01/02/97
6// Id:
7// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
5e0aa05a 8// Licence: wxWindows licence
c801d85f
KB		 9/////////////////////////////////////////////////////////////////////////////
10
11
12#ifdef __GNUG__
13#pragma implementation "window.h"
14#endif
15
16#include "wx/defs.h"
17#include "wx/window.h"
18#include "wx/dc.h"
19#include "wx/frame.h"
20#include "wx/app.h"
21#include "wx/layout.h"
22#include "wx/utils.h"
23#include "wx/dialog.h"
24#include "wx/msgdlg.h"
25#include "wx/dcclient.h"
26#include "wx/dnd.h"
27#include "wx/mdi.h"
53b28675 28#include "wx/notebook.h"
c801d85f
KB		 29#include "gdk/gdkkeysyms.h"
30#include <math.h>
31#include "wx/gtk/win_gtk.h"
32#include "gdk/gdkprivate.h"
33
34//-----------------------------------------------------------------------------
35// data
36//-----------------------------------------------------------------------------
37
38extern wxList wxPendingDelete;
39extern wxList wxTopLevelWindows;
40extern bool g_blockEventsOnDrag;
41
42//-----------------------------------------------------------------------------
43// GTK callbacks for wxWindows event system
44//-----------------------------------------------------------------------------
45
46//-----------------------------------------------------------------------------
47// expose (of m_wxwindow, not of m_widget)
48
49void gtk_window_expose_callback( GtkWidget *WXUNUSED(widget), GdkEventExpose *gdk_event, wxWindow *win )
50{
51 if (!win->HasVMT()) return;
52 if (g_blockEventsOnDrag) return;
53
54/*
55 printf( "OnExpose from " );
56 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
57 printf( win->GetClassInfo()->GetClassName() );
58 printf( ".\n" );
59
60 printf( "x: %d \n", gdk_event->area.x );
61 printf( "y: %d \n", gdk_event->area.y );
62 printf( "w: %d \n", gdk_event->area.width );
63 printf( "h: %d \n", gdk_event->area.height );
64*/
65
66 win->m_updateRegion.Union( gdk_event->area.x,
67 gdk_event->area.y,
5e0aa05a
VZ		 68 gdk_event->area.width,
69 gdk_event->area.height );
70
c801d85f
KB		 71 if (gdk_event->count > 0) return;
72
73 wxPaintEvent event( win->GetId() );
74 event.SetEventObject( win );
75 win->ProcessEvent( event );
76
77 win->m_updateRegion.Clear();
78};
79
80//-----------------------------------------------------------------------------
81// draw (of m_wxwindow, not of m_widget)
82
83void gtk_window_draw_callback( GtkWidget *WXUNUSED(widget), GdkRectangle *rect, wxWindow *win )
84{
85 if (!win->HasVMT()) return;
86 if (g_blockEventsOnDrag) return;
87
88/*
89 printf( "OnDraw from " );
90 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
91 printf( win->GetClassInfo()->GetClassName() );
92 printf( ".\n" );
93
94 printf( "x: %d \n", rect->x );
95 printf( "y: %d \n", rect->y );
96 printf( "w: %d \n", rect->width );
97 printf( "h: %d \n", rect->height );
98*/
99
100 win->m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
5e0aa05a 101
c801d85f
KB		 102 wxPaintEvent event( win->GetId() );
103 event.SetEventObject( win );
104 win->ProcessEvent( event );
105
106 win->m_updateRegion.Clear();
107};
108
109//-----------------------------------------------------------------------------
110// size
33d0b396
RR		 111// I don't any longer intercept GTK's internal resize events, except
112// for frames and from within MDI and tabbed windows (client area
113// size determined internally by GTK, not wxWin).
c801d85f
KB		 114
115/*
116void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxWindow *win )
117{
118 if (!win->HasVMT()) return;
119 if (g_blockEventsOnDrag) return;
120
121 return;
122
123 if ((win->m_x == alloc->x) &&
124 (win->m_y == alloc->y) &&
125 (win->m_width == alloc->width) &&
126 (win->m_height == alloc->height))
127 {
128 return;
129 };
130
131 printf( "OnResize from " );
132 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
133 printf( win->GetClassInfo()->GetClassName() );
134 printf( " .\n" );
135
136 printf( " Old: X: %d Y: %d ", win->m_x, win->m_y );
137 printf( " W: %d H: %d ", win->m_width, win->m_height );
138 printf( " .\n" );
139
140 printf( " New: X: %d Y: %d ", alloc->x, alloc->y );
141 printf( " W: %d H: %d ", alloc->width, alloc->height );
142 printf( " .\n" );
143
144 wxSizeEvent event( wxSize( alloc->width, alloc->height), win->GetId() );
145 event.SetEventObject( win );
146 win->ProcessEvent( event );
147};
148*/
149
150//-----------------------------------------------------------------------------
151// key_press
152
153gint gtk_window_key_press_callback( GtkWidget *WXUNUSED(widget), GdkEventKey *gdk_event, wxWindow *win )
154{
155 if (!win->HasVMT()) return FALSE;
156 if (g_blockEventsOnDrag) return FALSE;
157
158/*
159 printf( "OnKeyPress from " );
160 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
161 printf( win->GetClassInfo()->GetClassName() );
162 printf( ".\n" );
163*/
164
165 long key_code = 0;
166 switch (gdk_event->keyval)
167 {
5e0aa05a
VZ		 168 case GDK_BackSpace: key_code = WXK_BACK; break;
169 case GDK_Tab: key_code = WXK_TAB; break;
170 case GDK_Linefeed: key_code = WXK_RETURN; break;
171 case GDK_Clear: key_code = WXK_CLEAR; break;
172 case GDK_Return: key_code = WXK_RETURN; break;
173 case GDK_Pause: key_code = WXK_PAUSE; break;
174 case GDK_Scroll_Lock: key_code = WXK_SCROLL; break;
175 case GDK_Escape: key_code = WXK_ESCAPE; break;
176 case GDK_Delete: key_code = WXK_DELETE; break;
177 case GDK_Home: key_code = WXK_HOME; break;
178 case GDK_Left: key_code = WXK_LEFT; break;
179 case GDK_Up: key_code = WXK_UP; break;
180 case GDK_Right: key_code = WXK_RIGHT; break;
181 case GDK_Down: key_code = WXK_DOWN; break;
182 case GDK_Prior: key_code = WXK_PRIOR; break;
183// case GDK_Page_Up: key_code = WXK_PAGEUP; break;
184 case GDK_Next: key_code = WXK_NEXT; break;
185// case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
186 case GDK_End: key_code = WXK_END; break;
187 case GDK_Begin: key_code = WXK_HOME; break;
188 case GDK_Select: key_code = WXK_SELECT; break;
189 case GDK_Print: key_code = WXK_PRINT; break;
190 case GDK_Execute: key_code = WXK_EXECUTE; break;
191 case GDK_Insert: key_code = WXK_INSERT; break;
192 case GDK_Num_Lock: key_code = WXK_NUMLOCK; break;
193 case GDK_KP_Tab: key_code = WXK_TAB; break;
194 case GDK_KP_Enter: key_code = WXK_RETURN; break;
195 case GDK_KP_Home: key_code = WXK_HOME; break;
196 case GDK_KP_Left: key_code = WXK_LEFT; break;
197 case GDK_KP_Up: key_code = WXK_UP; break;
198 case GDK_KP_Right: key_code = WXK_RIGHT; break;
199 case GDK_KP_Down: key_code = WXK_DOWN; break;
200 case GDK_KP_Prior: key_code = WXK_PRIOR; break;
201// case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
202 case GDK_KP_Next: key_code = WXK_NEXT; break;
203// case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
204 case GDK_KP_End: key_code = WXK_END; break;
205 case GDK_KP_Begin: key_code = WXK_HOME; break;
206 case GDK_KP_Insert: key_code = WXK_INSERT; break;
207 case GDK_KP_Delete: key_code = WXK_DELETE; break;
208 case GDK_KP_Multiply: key_code = WXK_MULTIPLY; break;
209 case GDK_KP_Add: key_code = WXK_ADD; break;
210 case GDK_KP_Separator: key_code = WXK_SEPARATOR; break;
211 case GDK_KP_Subtract: key_code = WXK_SUBTRACT; break;
212 case GDK_KP_Decimal: key_code = WXK_DECIMAL; break;
213 case GDK_KP_Divide: key_code = WXK_DIVIDE; break;
214 case GDK_KP_0: key_code = WXK_NUMPAD0; break;
215 case GDK_KP_1: key_code = WXK_NUMPAD1; break;
216 case GDK_KP_2: key_code = WXK_NUMPAD2; break;
217 case GDK_KP_3: key_code = WXK_NUMPAD3; break;
218 case GDK_KP_4: key_code = WXK_NUMPAD4; break;
219 case GDK_KP_5: key_code = WXK_NUMPAD5; break;
220 case GDK_KP_6: key_code = WXK_NUMPAD6; break;
221 case GDK_KP_7: key_code = WXK_NUMPAD7; break;
222 case GDK_KP_8: key_code = WXK_NUMPAD7; break;
223 case GDK_KP_9: key_code = WXK_NUMPAD9; break;
224 case GDK_F1: key_code = WXK_F1; break;
225 case GDK_F2: key_code = WXK_F2; break;
226 case GDK_F3: key_code = WXK_F3; break;
227 case GDK_F4: key_code = WXK_F4; break;
228 case GDK_F5: key_code = WXK_F5; break;
229 case GDK_F6: key_code = WXK_F6; break;
230 case GDK_F7: key_code = WXK_F7; break;
231 case GDK_F8: key_code = WXK_F8; break;
232 case GDK_F9: key_code = WXK_F9; break;
233 case GDK_F10: key_code = WXK_F10; break;
234 case GDK_F11: key_code = WXK_F11; break;
235 case GDK_F12: key_code = WXK_F12; break;
c801d85f
KB		 236 default:
237 {
238 if ((gdk_event->keyval >= 0x20) && (gdk_event->keyval <= 0xFF))
239 key_code = gdk_event->keyval;
240 };
241 };
242
243 if (!key_code) return FALSE;
244
245 wxKeyEvent event( wxEVT_CHAR );
246 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
247 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
248 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
249 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
250 event.m_keyCode = key_code;
251 event.m_x = 0;
252 event.m_y = 0;
253 event.SetEventObject( win );
254 return win->ProcessEvent( event );
255};
256
257//-----------------------------------------------------------------------------
258// button_press
259
260gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
261{
262 if (widget->window != gdk_event->window) return FALSE;
263 if (g_blockEventsOnDrag) return FALSE;
264
265 if (win->m_wxwindow)
266 {
267 if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow) && !GTK_WIDGET_HAS_FOCUS (win->m_wxwindow) )
268 {
269 gtk_widget_grab_focus (win->m_wxwindow);
270
271/*
272 printf( "GrabFocus from " );
273 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
274 printf( win->GetClassInfo()->GetClassName() );
275 printf( ".\n" );
276*/
277
278 };
279 };
280
281 if (!win->HasVMT()) return FALSE;
282
283/*
284 printf( "OnButtonPress from " );
285 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
286 printf( win->GetClassInfo()->GetClassName() );
287 printf( ".\n" );
288*/
289
7798a18e 290 wxEventType event_type = wxEVT_LEFT_DOWN;
c801d85f
KB		 291
292 if (gdk_event->button == 1)
293 {
294 switch (gdk_event->type)
295 {
296 case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
297 case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
298 default: break;
299 };
300 }
301 else if (gdk_event->button == 2)
302 {
303 switch (gdk_event->type)
304 {
305 case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
306 case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
307 default: break;
308 };
309 }
310 else if (gdk_event->button == 3)
311 {
312 switch (gdk_event->type)
313 {
314 case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
315 case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
316 default: break;
317 };
318 };
319
320 wxMouseEvent event( event_type );
321 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
322 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
323 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
324 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
325 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
326 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
327 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
328
329 event.m_x = (long)gdk_event->x;
330 event.m_y = (long)gdk_event->y;
331 event.SetEventObject( win );
332
333 win->ProcessEvent( event );
334
335 return TRUE;
336};
337
338//-----------------------------------------------------------------------------
339// button_release
340
341gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindow *win )
342{
343 if (widget->window != gdk_event->window) return TRUE;
344
345 if (g_blockEventsOnDrag) return FALSE;
346
347 if (!win->HasVMT()) return FALSE;
348
349/*
350 printf( "OnButtonRelease from " );
351 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
352 printf( win->GetClassInfo()->GetClassName() );
353 printf( ".\n" );
354*/
355
7798a18e 356 wxEventType event_type = wxEVT_NULL;
c801d85f
KB		 357
358 switch (gdk_event->button)
359 {
360 case 1: event_type = wxEVT_LEFT_UP; break;
361 case 2: event_type = wxEVT_MIDDLE_UP; break;
362 case 3: event_type = wxEVT_RIGHT_UP; break;
363 };
364
365 wxMouseEvent event( event_type );
366 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
367 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
368 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
369 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
370 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
371 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
372 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
373 event.m_x = (long)gdk_event->x;
374 event.m_y = (long)gdk_event->y;
375 event.SetEventObject( win );
376
377 return win->ProcessEvent( event );
378};
379
380//-----------------------------------------------------------------------------
381// motion_notify
382
383gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindow *win )
384{
385 if (widget->window != gdk_event->window) return TRUE;
386
387 if (g_blockEventsOnDrag) return FALSE;
388
389 if (!win->HasVMT()) return FALSE;
390
391/*
392 printf( "OnMotion from " );
393 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
394 printf( win->GetClassInfo()->GetClassName() );
395 printf( ".\n" );
396*/
397
398 wxMouseEvent event( wxEVT_MOTION );
399 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
400 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
401 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
402 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
403 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
404 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
405 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
406
407 event.m_x = (long)gdk_event->x;
408 event.m_y = (long)gdk_event->y;
409 event.SetEventObject( win );
410
411 win->ProcessEvent( event );
412
413 return FALSE;
414};
415
416//-----------------------------------------------------------------------------
417// focus_in
418
401ec7b6 419gint gtk_window_focus_in_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
c801d85f 420{
401ec7b6 421 if (g_blockEventsOnDrag) return FALSE;
c801d85f
KB		 422 if (win->m_wxwindow)
423 {
424 if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
425 {
426 GTK_WIDGET_SET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
427/*
428 printf( "SetFocus flag from " );
429 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
430 printf( win->GetClassInfo()->GetClassName() );
431 printf( ".\n" );
432*/
433 };
434 };
435
401ec7b6 436 if (!win->HasVMT()) return FALSE;
c801d85f
KB		 437
438/*
439 printf( "OnSetFocus from " );
440 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
441 printf( win->GetClassInfo()->GetClassName() );
442 printf( " " );
443 printf( WXSTRINGCAST win->GetLabel() );
444 printf( ".\n" );
445*/
446
447 wxFocusEvent event( wxEVT_SET_FOCUS, win->GetId() );
448 event.SetEventObject( win );
401ec7b6 449 return win->ProcessEvent( event );
c801d85f
KB		 450};
451
452//-----------------------------------------------------------------------------
453// focus out
454
401ec7b6 455gint gtk_window_focus_out_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
c801d85f 456{
401ec7b6 457 if (g_blockEventsOnDrag) return FALSE;
c801d85f
KB		 458 if (win->m_wxwindow)
459 {
460 if (GTK_WIDGET_CAN_FOCUS(win->m_wxwindow))
461 GTK_WIDGET_UNSET_FLAGS (win->m_wxwindow, GTK_HAS_FOCUS);
462 };
463
401ec7b6 464 if (!win->HasVMT()) return FALSE;
c801d85f
KB		 465
466/*
467 printf( "OnKillFocus from " );
468 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
469 printf( win->GetClassInfo()->GetClassName() );
470 printf( ".\n" );
471*/
472
473 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
474 event.SetEventObject( win );
401ec7b6 475 return win->ProcessEvent( event );
c801d85f
KB		 476};
477
478//-----------------------------------------------------------------------------
479// vertical scroll
480
481void gtk_window_vscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
482{
483 if (g_blockEventsOnDrag) return;
484
485/*
486 printf( "OnVScroll from " );
487 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
488 printf( win->GetClassInfo()->GetClassName() );
489 printf( ".\n" );
490*/
491
492 if (!win->HasVMT()) return;
493
494 float diff = win->m_vAdjust->value - win->m_oldVerticalPos;
495 if (fabs(diff) < 0.2) return;
496
497/*
498 int i = (int)(win->m_oldVerticalPos+0.5);
499 printf( "Old value: %d.\n", i );
500 i = (int)(win->m_vAdjust->value+0.5);
501 printf( "Sending new value: %d.\n", i );
502*/
503
7798a18e 504 wxEventType command = wxEVT_NULL;
c801d85f
KB		 505
506 float line_step = win->m_vAdjust->step_increment;
507 float page_step = win->m_vAdjust->page_increment;
508
509 if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
510 else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
511 else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
512 else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
513 else command = wxEVT_SCROLL_THUMBTRACK;
514
515 int value = (int)(win->m_vAdjust->value+0.5);
516
517 wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
518 event.SetEventObject( win );
519 win->ProcessEvent( event );
520};
521
522//-----------------------------------------------------------------------------
523// horizontal scroll
524
525void gtk_window_hscroll_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
526{
527 if (g_blockEventsOnDrag) return;
528
529/*
530 printf( "OnHScroll from " );
531 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
532 printf( win->GetClassInfo()->GetClassName() );
533 printf( ".\n" );
534*/
535
536 if (!win->HasVMT()) return;
537
538 float diff = win->m_hAdjust->value - win->m_oldHorizontalPos;
539 if (fabs(diff) < 0.2) return;
540
541/*
542 int i = (int)(win->m_oldHorizontalPos+0.5);
543 printf( "Old value: %d.\n", i );
544 i = (int)(win->m_hAdjust->value+0.5);
545 printf( "Sending new value: %d.\n", i );
546*/
547
7798a18e 548 wxEventType command = wxEVT_NULL;
c801d85f
KB		 549
550 float line_step = win->m_hAdjust->step_increment;
551 float page_step = win->m_hAdjust->page_increment;
552
553 if (fabs(diff-line_step) < 0.2) command = wxEVT_SCROLL_LINEDOWN;
554 else if (fabs(diff+line_step) < 0.2) command = wxEVT_SCROLL_LINEUP;
555 else if (fabs(diff-page_step) < 0.2) command = wxEVT_SCROLL_PAGEDOWN;
556 else if (fabs(diff+page_step) < 0.2) command = wxEVT_SCROLL_PAGEUP;
557 else command = wxEVT_SCROLL_THUMBTRACK;
558
559 int value = (int)(win->m_hAdjust->value+0.5);
560
561 wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
562 event.SetEventObject( win );
563 win->ProcessEvent( event );
564};
565
566//-----------------------------------------------------------------------------
567// vertical scroll change
568
569void gtk_window_vscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
570{
571 if (g_blockEventsOnDrag) return;
572
573/*
574 printf( "OnVScroll change from " );
575 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
576 printf( win->GetClassInfo()->GetClassName() );
577 printf( ".\n" );
578*/
579
580 if (!win->HasVMT()) return;
581
7798a18e 582 wxEventType command = wxEVT_SCROLL_THUMBTRACK;
c801d85f
KB		 583 int value = (int)(win->m_vAdjust->value+0.5);
584
585 wxScrollEvent event( command, win->GetId(), value, wxVERTICAL );
586 event.SetEventObject( win );
587 win->ProcessEvent( event );
588};
589
590//-----------------------------------------------------------------------------
591// horizontal scroll change
592
593void gtk_window_hscroll_change_callback( GtkWidget *WXUNUSED(widget), wxWindow *win )
594{
595 if (g_blockEventsOnDrag) return;
596
597/*
598 printf( "OnHScroll change from " );
599 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
600 printf( win->GetClassInfo()->GetClassName() );
601 printf( ".\n" );
602*/
603
604 if (!win->HasVMT()) return;
605
7798a18e 606 wxEventType command = wxEVT_SCROLL_THUMBTRACK;
c801d85f
KB		 607 int value = (int)(win->m_hAdjust->value+0.5);
608
609 wxScrollEvent event( command, win->GetId(), value, wxHORIZONTAL );
610 event.SetEventObject( win );
611 win->ProcessEvent( event );
612};
613
614//-----------------------------------------------------------------------------
615// drop
616
617void gtk_window_drop_callback( GtkWidget *widget, GdkEvent *event, wxWindow *win )
618{
619 printf( "OnDrop.\n" );
620
621 if (win->GetDropTarget())
622 {
623 int x = 0;
624 int y = 0;
625 gdk_window_get_pointer( widget->window, &x, &y, NULL );
626 win->GetDropTarget()->Drop( event, x, y );
627 };
628
629/*
630 g_free (event->dropdataavailable.data);
631 g_free (event->dropdataavailable.data_type);
632*/
633}
634
635//-----------------------------------------------------------------------------
636// destroy
637
638bool gtk_window_destroy_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxWindow *win )
639{
640 printf( "OnDestroy from " );
641 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
642 printf( win->GetClassInfo()->GetClassName() );
643 printf( ".\n" );
644 printf( "Goodbye.\n" );
645 printf( " Robert Roebling.\n" );
646
647 return FALSE;
648};
649
650//-----------------------------------------------------------------------------
651// enter
652
401ec7b6 653bool gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
c801d85f 654{
401ec7b6
RR		 655 if (widget->window != gdk_event->window) return TRUE;
656
c801d85f
KB		 657 if (g_blockEventsOnDrag) return FALSE;
658
659 if (widget->window)
660 gdk_window_set_cursor( widget->window, win->m_cursor->GetCursor() );
661
401ec7b6
RR		 662 wxMouseEvent event( wxEVT_ENTER_WINDOW );
663 event.SetEventObject( win );
664 return win->ProcessEvent( event );
c801d85f
KB		 665};
666
667//-----------------------------------------------------------------------------
668// leave
669
401ec7b6 670bool gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindow *win )
c801d85f 671{
401ec7b6
RR		 672 if (widget->window != gdk_event->window) return TRUE;
673
c801d85f
KB		 674 if (g_blockEventsOnDrag) return FALSE;
675
676 if (widget->window)
677 gdk_window_set_cursor( widget->window, wxSTANDARD_CURSOR->GetCursor() );
678
401ec7b6
RR		 679 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
680 event.SetEventObject( win );
681 return win->ProcessEvent( event );
c801d85f
KB		 682};
683
684//-----------------------------------------------------------------------------
685// wxWindow implementation
686//-----------------------------------------------------------------------------
687
688IMPLEMENT_DYNAMIC_CLASS(wxWindow,wxEvtHandler)
689
690BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
c801d85f 691 EVT_SIZE(wxWindow::OnSize)
c801d85f
KB		 692 EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
693 EVT_INIT_DIALOG(wxWindow::OnInitDialog)
5e0aa05a 694 EVT_IDLE(wxWindow::OnIdle)
c801d85f
KB		 695END_EVENT_TABLE()
696
697wxWindow::wxWindow()
698{
699 m_widget = NULL;
700 m_wxwindow = NULL;
701 m_parent = NULL;
702 m_children.DeleteContents( FALSE );
703 m_x = 0;
704 m_y = 0;
705 m_width = 0;
706 m_height = 0;
707 m_retCode = 0;
708 m_eventHandler = this;
709 m_windowValidator = NULL;
710 m_windowId = -1;
711 m_cursor = new wxCursor( wxCURSOR_ARROW );
712 m_font = *wxSWISS_FONT;
713 m_windowStyle = 0;
714 m_windowName = "noname";
715 m_constraints = NULL;
716 m_constraintsInvolvedIn = NULL;
717 m_windowSizer = NULL;
718 m_sizerParent = NULL;
719 m_autoLayout = FALSE;
720 m_sizeSet = FALSE;
721 m_hasVMT = FALSE;
722 m_needParent = TRUE;
723 m_hasScrolling = FALSE;
724 m_hAdjust = NULL;
725 m_vAdjust = NULL;
726 m_oldHorizontalPos = 0.0;
727 m_oldVerticalPos = 0.0;
728 m_isShown = FALSE;
729 m_isEnabled = TRUE;
730 m_drawingOffsetX = 0;
731 m_drawingOffsetY = 0;
732 m_pDropTarget = NULL;
33d0b396 733 m_resizing = FALSE;
c801d85f
KB		 734};
735
debe6624
JS		 736wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
737 const wxPoint &pos, const wxSize &size,
738 long style, const wxString &name )
c801d85f
KB		 739{
740 Create( parent, id, pos, size, style, name );
741};
742
debe6624
JS		 743bool wxWindow::Create( wxWindow *parent, wxWindowID id,
744 const wxPoint &pos, const wxSize &size,
745 long style, const wxString &name )
c801d85f
KB		 746{
747 m_isShown = FALSE;
748 m_isEnabled = TRUE;
749 m_needParent = TRUE;
750
751 PreCreation( parent, id, pos, size, style, name );
752
753 m_widget = gtk_scrolled_window_new( NULL, NULL );
754 m_hasScrolling = TRUE;
755
756 GtkScrolledWindow *s_window;
757 s_window = GTK_SCROLLED_WINDOW(m_widget);
758
759 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
760 scroll_class->scrollbar_spacing = 0;
761
762 gtk_scrolled_window_set_policy( s_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
763
764 m_oldHorizontalPos = 0.0;
765 m_oldVerticalPos = 0.0;
766
767 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->hscrollbar) );
768 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(s_window->vscrollbar) );
769
770 gtk_signal_connect (GTK_OBJECT (m_hAdjust), "value_changed",
5e0aa05a 771 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
c801d85f 772 gtk_signal_connect (GTK_OBJECT (m_vAdjust), "value_changed",
5e0aa05a
VZ		 773 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
774
c801d85f 775 gtk_signal_connect (GTK_OBJECT (m_hAdjust), "changed",
5e0aa05a 776 (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
c801d85f 777 gtk_signal_connect (GTK_OBJECT (m_vAdjust), "changed",
5e0aa05a 778 (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
c801d85f
KB		 779
780 GtkViewport *viewport;
781 viewport = GTK_VIEWPORT(s_window->viewport);
782
783 if (m_windowStyle & wxRAISED_BORDER)
784 {
785 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
786 }
787 else if (m_windowStyle & wxSUNKEN_BORDER)
788 {
789 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
790 }
791 else
792 {
793 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
794 };
795
796 m_wxwindow = gtk_myfixed_new();
797
798 if (m_windowStyle & wxTAB_TRAVERSAL == wxTAB_TRAVERSAL)
799 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
800 else
801 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
802
803 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
804
805 // shut the viewport up
806 gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
807 gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
808
809 // I _really_ don't want scrollbars in the beginning
810 m_vAdjust->lower = 0.0;
811 m_vAdjust->upper = 1.0;
812 m_vAdjust->value = 0.0;
813 m_vAdjust->step_increment = 1.0;
814 m_vAdjust->page_increment = 1.0;
815 m_vAdjust->page_size = 5.0;
816 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
817 m_hAdjust->lower = 0.0;
818 m_hAdjust->upper = 1.0;
819 m_hAdjust->value = 0.0;
820 m_hAdjust->step_increment = 1.0;
821 m_hAdjust->page_increment = 1.0;
822 m_hAdjust->page_size = 5.0;
823 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
824
825 gtk_widget_show( m_wxwindow );
826
827 PostCreation();
828
829 Show( TRUE );
830
831 return TRUE;
832};
833
834wxWindow::~wxWindow(void)
835{
836 m_hasVMT = FALSE;
837
838 if (m_pDropTarget) delete m_pDropTarget;
839
840 if (m_parent) m_parent->RemoveChild( this );
841 if (m_widget) Show( FALSE );
842
843 DestroyChildren();
844
845 if (m_wxwindow) gtk_widget_destroy( m_wxwindow );
846
847 if (m_widget) gtk_widget_destroy( m_widget );
848
849// delete m_cursor;
850
851 DeleteRelatedConstraints();
852 if (m_constraints)
853 {
854 // This removes any dangling pointers to this window
855 // in other windows' constraintsInvolvedIn lists.
856 UnsetConstraints(m_constraints);
857 delete m_constraints;
858 m_constraints = NULL;
859 }
860 if (m_windowSizer)
861 {
862 delete m_windowSizer;
863 m_windowSizer = NULL;
864 }
865 // If this is a child of a sizer, remove self from parent
866 if (m_sizerParent)
867 m_sizerParent->RemoveChild((wxWindow *)this);
868
869 // Just in case the window has been Closed, but
870 // we're then deleting immediately: don't leave
871 // dangling pointers.
872 wxPendingDelete.DeleteObject(this);
873
874 // Just in case we've loaded a top-level window via
875 // wxWindow::LoadNativeDialog but we weren't a dialog
876 // class
877 wxTopLevelWindows.DeleteObject(this);
878
879};
880
debe6624
JS		 881void wxWindow::PreCreation( wxWindow *parent, wxWindowID id,
882 const wxPoint &pos, const wxSize &size,
883 long style, const wxString &name )
c801d85f
KB		 884{
885 if (m_needParent && (parent == NULL))
886 wxFatalError( "Need complete parent.", name );
887
888 m_widget = NULL;
889 m_hasVMT = FALSE;
890 m_parent = parent;
891 m_children.DeleteContents( FALSE );
892 m_x = (int)pos.x;
893 m_y = (int)pos.y;
894 m_width = size.x;
895 if (m_width == -1) m_width = 20;
896 m_height = size.y;
897 if (m_height == -1) m_height = 20;
898 m_retCode = 0;
899 m_eventHandler = this;
900 m_windowValidator = NULL;
901 m_windowId = id;
902 m_sizeSet = FALSE;
903 m_cursor = new wxCursor( wxCURSOR_ARROW );
904 m_font = *wxSWISS_FONT;
905 m_backgroundColour = wxWHITE;
906 m_foregroundColour = wxBLACK;
907 m_windowStyle = style;
908 m_windowName = name;
909 m_constraints = NULL;
910 m_constraintsInvolvedIn = NULL;
911 m_windowSizer = NULL;
912 m_sizerParent = NULL;
913 m_autoLayout = FALSE;
914 m_drawingOffsetX = 0;
915 m_drawingOffsetY = 0;
916 m_pDropTarget = NULL;
33d0b396 917 m_resizing = FALSE;
c801d85f
KB		 918}
919
920void wxWindow::PostCreation(void)
921{
922 if (m_parent) m_parent->AddChild( this );
923
924// GtkStyle *style = m_widget->style;
925// style->font = m_font.GetInternalFont( 1.0 ); // destroy old font ?
926
927 GtkWidget *connect_widget = m_widget;
928 if (m_wxwindow) connect_widget = m_wxwindow;
929
930 gtk_object_set_data (GTK_OBJECT (connect_widget), "MyWxWindow", (gpointer)this );
931
932 if (m_wxwindow)
933 {
934 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
935 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
936
937 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
938 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
939 };
940
941/*
942 gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
943 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
944*/
945
946 gtk_signal_connect( GTK_OBJECT(connect_widget), "key_press_event",
947 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
948
949 gtk_signal_connect( GTK_OBJECT(connect_widget), "button_press_event",
950 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
951
952 gtk_signal_connect( GTK_OBJECT(connect_widget), "button_release_event",
953 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
954
955 gtk_signal_connect( GTK_OBJECT(connect_widget), "motion_notify_event",
956 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
957
958 gtk_signal_connect( GTK_OBJECT(connect_widget), "focus_in_event",
959 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
960
961 gtk_signal_connect( GTK_OBJECT(connect_widget), "focus_out_event",
962 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
963
964 gtk_signal_connect( GTK_OBJECT(connect_widget), "drop_data_available_event",
965 GTK_SIGNAL_FUNC(gtk_window_drop_callback), (gpointer)this );
966
967 // Only for cursor handling
968
969 gtk_signal_connect( GTK_OBJECT(m_widget), "enter_notify_event",
970 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
971
972 gtk_signal_connect( GTK_OBJECT(m_widget), "leave_notify_event",
973 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
974
975 if (m_wxwindow)
976 {
977 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "enter_notify_event",
978 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
979
980 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "leave_notify_event",
981 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
982 };
983
984/*
985 // Does destroy ever get called ?
986
987 gtk_signal_connect( GTK_OBJECT(m_widget), "destroy_event",
988 GTK_SIGNAL_FUNC(gtk_window_destroy_callback), (gpointer)this );
989
990 if (m_wxwindow)
991 {
992 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "destroy_event",
993 GTK_SIGNAL_FUNC(gtk_window_destroy_callback), (gpointer)this );
994 };
995*/
996
997 if (m_widget && m_parent) gtk_widget_realize( m_widget );
998 if (m_wxwindow) gtk_widget_realize( m_wxwindow );
999
1000 SetCursor( wxSTANDARD_CURSOR );
1001
1002 m_hasVMT = TRUE;
1003};
1004
1005bool wxWindow::HasVMT(void)
1006{
1007 return m_hasVMT;
1008};
1009
debe6624 1010bool wxWindow::Close( bool force )
c801d85f
KB		 1011{
1012 wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId);
1013 event.SetEventObject(this);
1014 event.SetForce(force);
1015
1016 return GetEventHandler()->ProcessEvent(event);
1017};
1018
1019bool wxWindow::Destroy(void)
1020{
1021 m_hasVMT = FALSE;
1022 delete this;
1023 return TRUE;
1024};
1025
1026bool wxWindow::DestroyChildren(void)
1027{
1028 if (GetChildren())
1029 {
1030 wxNode *node;
1031 while ((node = GetChildren()->First()) != (wxNode *)NULL)
1032 {
1033 wxWindow *child;
1034 if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL)
1035 {
1036 delete child;
5e0aa05a 1037 if (GetChildren()->Member(child)) delete node;
c801d85f
KB		 1038 };
1039 };
1040 };
1041 return TRUE;
1042};
1043
1044void wxWindow::PrepareDC( wxDC &WXUNUSED(dc) )
1045{
1046 // are we to set fonts here ?
1047};
1048
1049void wxWindow::ImplementSetSize(void)
1050{
1051 gtk_widget_set_usize( m_widget, m_width, m_height );
1052};
1053
1054void wxWindow::ImplementSetPosition(void)
1055{
1a6944fd
RR		 1056 if (!m_parent)
1057 {
1058 if (IsKindOf(CLASSINFO(wxFrame)) ||
1059 IsKindOf(CLASSINFO(wxDialog)))
1060 {
1061 gtk_widget_set_uposition( m_widget, m_x, m_y );
1062 }
1063 else
1064 {
1065 printf( "wxWindow::SetSize error.\n" );
1066 }
1067 return;
1068 }
1069
c801d85f
KB		 1070 if ((m_parent) && (m_parent->m_wxwindow))
1071 gtk_myfixed_move( GTK_MYFIXED(m_parent->m_wxwindow), m_widget, m_x, m_y );
1a6944fd
RR		 1072
1073 // Don't do anything for children of wxNotebook and wxMDIChildFrame
c801d85f
KB		 1074};
1075
debe6624 1076void wxWindow::SetSize( int x, int y, int width, int height, int sizeFlags )
c801d85f 1077{
33d0b396
RR		 1078 if (m_resizing) return; // I don't like recursions
1079 m_resizing = TRUE;
1080
c801d85f
KB		 1081 int newX = x;
1082 int newY = y;
1083 int newW = width;
1084 int newH = height;
1085
1086 if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
1087 {
1088 if (newX == -1) newX = m_x;
1089 if (newY == -1) newY = m_y;
1090 if (newW == -1) newW = m_width;
1091 if (newH == -1) newH = m_height;
1092 };
1093
1094 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
1095 {
1096 if (newW == -1) newW = 80;
1097 };
1098
1099 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
1100 {
1101 if (newH == -1) newH = 26;
1102 };
1103
1104 if ((m_x != newX) || (m_y != newY) || (!m_sizeSet))
1105 {
1106 m_x = newX;
1107 m_y = newY;
1108 ImplementSetPosition();
1109 };
1110 if ((m_width != newW) || (m_height != newH) || (!m_sizeSet))
1111 {
1112 m_width = newW;
1113 m_height = newH;
1114 ImplementSetSize();
1115 };
1116 m_sizeSet = TRUE;
1117
1118 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1119 event.SetEventObject( this );
1120 ProcessEvent( event );
33d0b396
RR		 1121
1122 m_resizing = FALSE;
c801d85f
KB		 1123};
1124
debe6624 1125void wxWindow::SetSize( int width, int height )
c801d85f
KB		 1126{
1127 SetSize( -1, -1, width, height, wxSIZE_USE_EXISTING );
1128};
1129
debe6624 1130void wxWindow::Move( int x, int y )
c801d85f
KB		 1131{
1132 SetSize( x, y, -1, -1, wxSIZE_USE_EXISTING );
1133};
1134
1135void wxWindow::GetSize( int *width, int *height ) const
1136{
33d0b396
RR		 1137 if (width) (*width) = m_width;
1138 if (height) (*height) = m_height;
c801d85f
KB		 1139};
1140
debe6624 1141void wxWindow::SetClientSize( int width, int height )
c801d85f
KB		 1142{
1143 if (!m_wxwindow)
1144 {
1145 SetSize( width, height );
1146 }
1147 else
1148 {
1149 int dw = 0;
1150 int dh = 0;
1151
1152 if (!m_hasScrolling)
1153 {
1154/*
1155 do we have sunken dialogs ?
1156
1157 GtkStyleClass *window_class = m_wxwindow->style->klass;
1158
1159 dw += 2 * window_class->xthickness;
1160 dh += 2 * window_class->ythickness;
1161*/
1162 }
1163 else
1164 {
1165 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1166 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1167
1168 GtkWidget *viewport = scroll_window->viewport;
1169 GtkStyleClass *viewport_class = viewport->style->klass;
1170
1171 GtkWidget *hscrollbar = scroll_window->hscrollbar;
1172 GtkWidget *vscrollbar = scroll_window->vscrollbar;
1173
1174 if ((m_windowStyle & wxRAISED_BORDER) ||
1175 (m_windowStyle & wxSUNKEN_BORDER)
5e0aa05a 1176 )
c801d85f
KB		 1177 {
1178 dw += 2 * viewport_class->xthickness;
1179 dh += 2 * viewport_class->ythickness;
1180 };
1181
1182 if (GTK_WIDGET_VISIBLE(vscrollbar))
1183 {
1184 dw += vscrollbar->allocation.width;
1185 dw += scroll_class->scrollbar_spacing;
1186 };
1187
1188 if (GTK_WIDGET_VISIBLE(hscrollbar))
1189 {
1190 dh += hscrollbar->allocation.height;
1191 dw += scroll_class->scrollbar_spacing;
1192 };
1193 };
1194
1195 SetSize( width+dw, height+dh );
1196 };
1197};
1198
1199void wxWindow::GetClientSize( int *width, int *height ) const
1200{
1201 if (!m_wxwindow)
1202 {
1203 if (width) (*width) = m_width;
1204 if (height) (*height) = m_height;
1205 }
1206 else
1207 {
1208 int dw = 0;
1209 int dh = 0;
1210
1211 if (!m_hasScrolling)
1212 {
1213/*
1214 do we have sunken dialogs ?
1215
1216 GtkStyleClass *window_class = m_wxwindow->style->klass;
1217
1218 dw += 2 * window_class->xthickness;
1219 dh += 2 * window_class->ythickness;
1220*/
1221 }
1222 else
1223 {
1224 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1225 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1226
1227 GtkWidget *viewport = scroll_window->viewport;
1228 GtkStyleClass *viewport_class = viewport->style->klass;
1229
1230 GtkWidget *hscrollbar = scroll_window->hscrollbar;
1231 GtkWidget *vscrollbar = scroll_window->vscrollbar;
1232
1233 if ((m_windowStyle & wxRAISED_BORDER) ||
1234 (m_windowStyle & wxSUNKEN_BORDER)
5e0aa05a 1235 )
c801d85f
KB		 1236 {
1237 dw += 2 * viewport_class->xthickness;
1238 dh += 2 * viewport_class->ythickness;
1239 };
1240
1241 if (GTK_WIDGET_VISIBLE(vscrollbar))
1242 {
1243// dw += vscrollbar->allocation.width;
1244 dw += 15; // range.slider_width = 11 + 2*2pts edge
1245 dw += scroll_class->scrollbar_spacing;
1246 };
1247
1248 if (GTK_WIDGET_VISIBLE(hscrollbar))
1249 {
1250// dh += hscrollbar->allocation.height;
1251 dh += 15;
1252 dh += scroll_class->scrollbar_spacing;
1253 };
1254 };
1255
1256 if (width) (*width) = m_width - dw;
1257 if (height) (*height) = m_height - dh;
1258 };
1259};
1260
1261void wxWindow::GetPosition( int *x, int *y ) const
1262{
1263 if (x) (*x) = m_x;
1264 if (y) (*y) = m_y;
1265};
1266
1267void wxWindow::ClientToScreen( int *x, int *y )
1268{
1269 // Does this look simple ?
1270
1271 GdkWindow *source = NULL;
1272 if (m_wxwindow)
1273 source = m_wxwindow->window;
1274 else
1275 source = m_widget->window;
1276
1277 int org_x = 0;
1278 int org_y = 0;
1279 gdk_window_get_origin( source, &org_x, &org_y );
1280
1281 if (!m_wxwindow)
1282 {
1283 if (GTK_WIDGET_NO_WINDOW (m_widget))
1284 {
1285 org_x += m_widget->allocation.x;
1286 org_y += m_widget->allocation.y;
1287 };
1288 };
1289
1290 if (x) *x += org_x;
1291 if (y) *y += org_y;
1292};
1293
1294void wxWindow::ScreenToClient( int *x, int *y )
1295{
1296 GdkWindow *source = NULL;
1297 if (m_wxwindow)
1298 source = m_wxwindow->window;
1299 else
1300 source = m_widget->window;
1301
1302 int org_x = 0;
1303 int org_y = 0;
1304 gdk_window_get_origin( source, &org_x, &org_y );
1305
1306 if (!m_wxwindow)
1307 {
1308 if (GTK_WIDGET_NO_WINDOW (m_widget))
1309 {
1310 org_x += m_widget->allocation.x;
1311 org_y += m_widget->allocation.y;
1312 };
1313 };
1314
1315 if (x) *x -= org_x;
1316 if (y) *y -= org_y;
1317};
1318
debe6624 1319void wxWindow::Centre( int direction )
c801d85f
KB		 1320{
1321 int x = 0;
1322 int y = 0;
1323 GetPosition( &x, &y );
1324 if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
1325 {
1326 if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (gdk_screen_width () - m_width) / 2;
1327 if (direction & wxVERTICAL == wxVERTICAL) y = (gdk_screen_height () - m_height) / 2;
1328 gtk_widget_set_uposition( m_widget, x, y );
1329 }
1330 else
1331 {
1332 if (m_parent)
1333 {
1334 int p_w = 0;
1335 int p_h = 0;
1336 m_parent->GetSize( &p_w, &p_h );
1337 if (direction & wxHORIZONTAL == wxHORIZONTAL) x = (p_w - m_width) / 2;
1338 if (direction & wxVERTICAL == wxVERTICAL) y = (p_h - m_height) / 2;
1339 gtk_widget_set_uposition( m_widget, x, y );
1340 };
1341 }
1342};
1343
1344void wxWindow::Fit(void)
1345{
5e0aa05a
VZ		 1346 int maxX = 0;
1347 int maxY = 0;
1348 wxNode *node = GetChildren()->First();
1349 while ( node )
1350 {
1351 wxWindow *win = (wxWindow *)node->Data();
1352 int wx, wy, ww, wh;
1353 win->GetPosition(&wx, &wy);
1354 win->GetSize(&ww, &wh);
1355 if ( wx + ww > maxX )
1356 maxX = wx + ww;
1357 if ( wy + wh > maxY )
1358 maxY = wy + wh;
1359
1360 node = node->Next();
1361 }
1362 SetClientSize(maxX + 5, maxY + 5);
c801d85f
KB		 1363};
1364
1365void wxWindow::OnSize( wxSizeEvent &WXUNUSED(event) )
1366{
da7f8ac4 1367 //if (GetAutoLayout()) Layout();
c801d85f
KB		 1368};
1369
debe6624 1370bool wxWindow::Show( bool show )
c801d85f
KB		 1371{
1372 if (show)
1373 gtk_widget_show( m_widget );
1374 else
1375 gtk_widget_hide( m_widget );
1376 m_isShown = show;
1377 return TRUE;
1378};
1379
debe6624 1380void wxWindow::Enable( bool enable )
c801d85f
KB		 1381{
1382 m_isEnabled = enable;
1383 gtk_widget_set_sensitive( m_widget, enable );
1384 if (m_wxwindow) gtk_widget_set_sensitive( m_wxwindow, enable );
1385};
1386
debe6624 1387void wxWindow::MakeModal( bool modal )
c801d85f
KB		 1388{
1389 return;
1390 // Disable all other windows
1391 if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame)))
1392 {
1393 wxNode *node = wxTopLevelWindows.First();
1394 while (node)
1395 {
1396 wxWindow *win = (wxWindow *)node->Data();
1397 if (win != this)
1398 win->Enable(!modal);
1399
1400 node = node->Next();
1401 }
1402 }
1403}
1404
1405void wxWindow::SetFocus(void)
1406{
1407 GtkWidget *connect_widget = m_widget;
1408 if (m_wxwindow) connect_widget = m_wxwindow;
1409 if (connect_widget)
1410 {
1411 if (GTK_WIDGET_CAN_FOCUS(connect_widget) && !GTK_WIDGET_HAS_FOCUS (connect_widget) )
1412 {
1413 gtk_widget_grab_focus (connect_widget);
1414 };
1415 };
1416};
1417
1418bool wxWindow::OnClose(void)
1419{
1420 printf( "OnClose event.\n" );
1421 return TRUE;
1422};
1423
1424void wxWindow::AddChild( wxWindow *child )
1425{
1426 // Addchild is (often) called before the program
1427 // has left the parents constructor so that no
1428 // virtual tables work yet. The approach below
1429 // practically imitates virtual tables, i.e. it
1430 // implements a different AddChild() behaviour
1431 // for wxFrame, wxDialog, wxWindow and
1432 // wxMDIParentFrame.
1433
1434 if (IsKindOf(CLASSINFO(wxMDIParentFrame)))
1435 {
1436 if (child->IsKindOf(CLASSINFO(wxMDIChildFrame)))
1437 {
1438 wxMDIClientWindow *client = ((wxMDIParentFrame*)this)->GetClientWindow();
1439 if (client)
1440 {
1441 client->AddChild( child );
1442 return;
1443 };
1444 };
1445 };
7f4dc78d 1446
33d0b396
RR		 1447 // wxNotebooks are very special, so they have their own AddChild
1448
53b28675 1449 if (IsKindOf(CLASSINFO(wxNotebook)))
7f4dc78d 1450 {
53b28675 1451 wxNotebook *tab = (wxNotebook*)this;
7f4dc78d
RR		 1452 tab->AddChild( child );
1453 return;
1454 };
1455
c801d85f
KB		 1456 m_children.Append( child );
1457 if (child->IsKindOf(CLASSINFO(wxFrame)) || child->IsKindOf(CLASSINFO(wxDialog)))
1458 {
1459 if ((child->m_x != -1) && (child->m_y != -1))
1460 gtk_widget_set_uposition( child->m_widget, child->m_x, child->m_y );
1461 }
1462 else
1463 {
1464 if (m_wxwindow)
1465 gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget, child->m_x, child->m_y );
1466 };
1467 gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
1468};
1469
1470wxList *wxWindow::GetChildren(void)
1471{
1472 return (&m_children);
1473};
1474
1475void wxWindow::RemoveChild( wxWindow *child )
1476{
1477 if (GetChildren())
1478 GetChildren()->DeleteObject( child );
1479 child->m_parent = NULL;
1480};
1481
1482void wxWindow::SetReturnCode( int retCode )
1483{
1484 m_retCode = retCode;
1485};
1486
1487int wxWindow::GetReturnCode(void)
1488{
1489 return m_retCode;
1490};
1491
1492wxWindow *wxWindow::GetParent(void)
1493{
1494 return m_parent;
1495};
1496
1497wxEvtHandler *wxWindow::GetEventHandler(void)
1498{
1499 return m_eventHandler;
1500};
1501
1502void wxWindow::SetEventhandler( wxEvtHandler *handler )
1503{
1504 m_eventHandler = handler;
1505};
1506
1507wxValidator *wxWindow::GetValidator(void)
1508{
1509 return m_windowValidator;
1510};
1511
1512void wxWindow::SetValidator( wxValidator *validator )
1513{
1514 m_windowValidator = validator;
1515};
1516
1517bool wxWindow::IsBeingDeleted(void)
1518{
1519 return FALSE;
1520};
1521
1522void wxWindow::SetId( wxWindowID id )
1523{
1524 m_windowId = id;
1525};
1526
1527wxWindowID wxWindow::GetId(void)
1528{
1529 return m_windowId;
1530};
1531
1532void wxWindow::SetCursor( const wxCursor &cursor )
1533{
1534 if (*m_cursor == cursor) return;
1535 (*m_cursor) = cursor;
1536 if (m_widget->window)
1537 gdk_window_set_cursor( m_widget->window, m_cursor->GetCursor() );
1538 if (m_wxwindow && m_wxwindow->window)
1539 gdk_window_set_cursor( m_wxwindow->window, m_cursor->GetCursor() );
1540};
1541
debe6624 1542void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
c801d85f
KB		 1543{
1544 if (eraseBackground && m_wxwindow && m_wxwindow->window)
1545 {
1546 if (rect)
1547 gdk_window_clear_area( m_wxwindow->window,
1548 rect->x,
5e0aa05a
VZ		 1549 rect->y,
1550 rect->width,
1551 rect->height );
c801d85f
KB		 1552 else
1553 Clear();
1554 };
1555 if (!rect)
1556 {
1557 if (m_wxwindow)
1558 {
1559 wxClientDC dc(this);
1560 PrepareDC(dc);
1561 long x = 0;
1562 long y = 0;
1563 dc.GetInternalDeviceOrigin( &x, &y );
1564
1565 int w = 0;
1566 int h = 0;
1567 GetClientSize( &w, &h );
1568
1569 GdkRectangle gdk_rect;
1570 gdk_rect.x = x;
1571 gdk_rect.y = y;
1572 gdk_rect.width = w;
1573 gdk_rect.height = h;
1574 gtk_widget_draw( m_wxwindow, &gdk_rect );
1575 };
1576 }
1577 else
1578 {
1579 GdkRectangle gdk_rect;
1580 gdk_rect.x = rect->x;
1581 gdk_rect.y = rect->y;
1582 gdk_rect.width = rect->width;
1583 gdk_rect.height = rect->height;
1584 if (m_wxwindow)
1585 gtk_widget_draw( m_wxwindow, &gdk_rect );
1586 else
1587 gtk_widget_draw( m_widget, &gdk_rect );
1588 };
1589};
1590
debe6624 1591bool wxWindow::IsExposed( long x, long y )
c801d85f
KB		 1592{
1593 return (m_updateRegion.Contains( x, y ) != wxOutRegion );
1594};
1595
debe6624 1596bool wxWindow::IsExposed( long x, long y, long width, long height )
c801d85f
KB		 1597{
1598 return (m_updateRegion.Contains( x, y, width, height ) != wxOutRegion );
1599};
1600
1601void wxWindow::Clear(void)
1602{
1603 if (m_wxwindow && m_wxwindow->window) gdk_window_clear( m_wxwindow->window );
1604};
1605
1606wxColour wxWindow::GetBackgroundColour(void) const
1607{
1608 return m_backgroundColour;
1609};
1610
1611void wxWindow::SetBackgroundColour( const wxColour &colour )
1612{
1613 m_backgroundColour = colour;
1614 if (m_wxwindow)
1615 {
1616 m_backgroundColour.CalcPixel( m_wxwindow->style->colormap );
1617 gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
1618 gdk_window_clear( m_wxwindow->window );
1619 };
1620 // do something ?
1621};
1622
1623bool wxWindow::Validate(void)
1624{
1625 wxNode *node = GetChildren()->First();
1626 while (node)
1627 {
1628 wxWindow *child = (wxWindow *)node->Data();
1629 if (child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this))
1630 { return FALSE; }
1631 node = node->Next();
1632 };
1633 return TRUE;
1634};
1635
1636bool wxWindow::TransferDataToWindow(void)
1637{
1638 wxNode *node = GetChildren()->First();
1639 while (node)
1640 {
1641 wxWindow *child = (wxWindow *)node->Data();
1642 if (child->GetValidator() && /* child->GetValidator()->Ok() && */
5e0aa05a 1643 !child->GetValidator()->TransferToWindow() )
c801d85f
KB		 1644 {
1645 wxMessageBox( "Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION );
1646 return FALSE;
1647 };
1648 node = node->Next();
1649 };
1650 return TRUE;
1651};
1652
1653bool wxWindow::TransferDataFromWindow(void)
1654{
1655 wxNode *node = GetChildren()->First();
1656 while (node)
1657 {
1658 wxWindow *child = (wxWindow *)node->Data();
1659 if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->TransferFromWindow() )
1660 { return FALSE; }
1661 node = node->Next();
1662 }
1663 return TRUE;
1664};
1665
1666void wxWindow::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
1667{
1668 TransferDataToWindow();
1669};
1670
1671void wxWindow::InitDialog(void)
1672{
1673 wxInitDialogEvent event(GetId());
1674 event.SetEventObject( this );
1675 GetEventHandler()->ProcessEvent(event);
1676};
1677
1678void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
1679{
1680 GtkWidget *connect_widget = m_widget;
1681 if (m_wxwindow) connect_widget = m_wxwindow;
1682 if (m_pDropTarget)
1683 {
1684 m_pDropTarget->UnregisterWidget( connect_widget );
1685 delete m_pDropTarget;
1686 };
1687 m_pDropTarget = dropTarget;
1688 if (m_pDropTarget)
1689 {
1690 m_pDropTarget->RegisterWidget( connect_widget );
1691 };
1692};
1693
1694wxDropTarget *wxWindow::GetDropTarget() const
1695{
1696 return m_pDropTarget;
1697};
1698
1699void wxWindow::SetFont( const wxFont &font )
1700{
1701 m_font = font;
1702/*
1703 create new style
1704 copy old style values to new one
1705 set font in new style
1706 -> takes to many resources
1707
1708 GtkStyle *style = gtk_style_new();
1709 ...
1710*/
1711};
1712
1713wxFont *wxWindow::GetFont(void)
1714{
1715 return &m_font;
1716};
1717
1718void wxWindow::SetWindowStyleFlag( long flag )
1719{
1720 m_windowStyle = flag;
1721};
1722
1723long wxWindow::GetWindowStyleFlag(void) const
1724{
1725 return m_windowStyle;
1726};
1727
1728void wxWindow::CaptureMouse(void)
1729{
1730 GtkWidget *connect_widget = m_widget;
1731 if (m_wxwindow) connect_widget = m_wxwindow;
1732 gtk_grab_add( connect_widget );
1733 gdk_pointer_grab ( connect_widget->window, FALSE,
1734 (GdkEventMask)
5e0aa05a
VZ		 1735 (GDK_BUTTON_PRESS_MASK |
1736 GDK_BUTTON_RELEASE_MASK |
1737 GDK_POINTER_MOTION_MASK),
1738 NULL, NULL, GDK_CURRENT_TIME );
c801d85f
KB		 1739};
1740
1741void wxWindow::ReleaseMouse(void)
1742{
1743 GtkWidget *connect_widget = m_widget;
1744 if (m_wxwindow) connect_widget = m_wxwindow;
1745 gtk_grab_remove( connect_widget );
1746 gdk_pointer_ungrab ( GDK_CURRENT_TIME );
1747};
1748
1749void wxWindow::SetTitle( const wxString &WXUNUSED(title) )
1750{
1751};
1752
1753wxString wxWindow::GetTitle(void) const
1754{
1755 return (wxString&)m_windowName;
1756};
1757
1758wxString wxWindow::GetLabel(void) const
1759{
1760 return GetTitle();
1761};
1762
1763void wxWindow::SetName( const wxString &name )
1764{
1765 m_windowName = name;
1766};
1767
1768wxString wxWindow::GetName(void) const
1769{
1770 return (wxString&)m_windowName;
1771};
1772
7fd1d163 1773bool wxWindow::IsShown(void) const
c801d85f
KB		 1774{
1775 return m_isShown;
1776};
1777
1778bool wxWindow::IsRetained(void)
1779{
1780 return FALSE;
1781};
1782
debe6624 1783wxWindow *wxWindow::FindWindow( long id )
c801d85f
KB		 1784{
1785 if (id == m_windowId) return this;
1786 wxNode *node = m_children.First();
1787 while (node)
1788 {
1789 wxWindow *child = (wxWindow*)node->Data();
1790 wxWindow *res = child->FindWindow( id );
1791 if (res) return res;
1792 node = node->Next();
1793 };
1794 return NULL;
1795};
1796
1797wxWindow *wxWindow::FindWindow( const wxString& name )
1798{
1799 if (name == m_windowName) return this;
1800 wxNode *node = m_children.First();
1801 while (node)
1802 {
1803 wxWindow *child = (wxWindow*)node->Data();
1804 wxWindow *res = child->FindWindow( name );
1805 if (res) return res;
1806 node = node->Next();
1807 };
1808 return NULL;
1809};
1810
debe6624
JS		 1811void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
1812 int range, bool WXUNUSED(refresh) )
c801d85f
KB		 1813{
1814 if (!m_wxwindow) return;
1815
1816 if (orient == wxHORIZONTAL)
1817 {
1818 float fpos = (float)pos;
1819 m_oldHorizontalPos = fpos;
1820 float frange = (float)range;
1821 float fthumb = (float)thumbVisible;
1822
1823 if ((fabs(fpos-m_hAdjust->value) < 0.2) &&
1824 (fabs(frange-m_hAdjust->upper) < 0.2) &&
5e0aa05a 1825 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
c801d85f
KB		 1826 return;
1827
1828 m_hAdjust->lower = 0.0;
1829 m_hAdjust->upper = frange;
1830 m_hAdjust->value = fpos;
1831 m_hAdjust->step_increment = 1.0;
1832 m_hAdjust->page_increment = (float)(wxMax(fthumb-2,0));
1833 m_hAdjust->page_size = fthumb;
1834 }
1835 else
1836 {
1837 float fpos = (float)pos;
1838 m_oldVerticalPos = fpos;
1839 float frange = (float)range;
1840 float fthumb = (float)thumbVisible;
1841
1842 if ((fabs(fpos-m_vAdjust->value) < 0.2) &&
1843 (fabs(frange-m_vAdjust->upper) < 0.2) &&
5e0aa05a 1844 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
c801d85f
KB		 1845 return;
1846
1847 m_vAdjust->lower = 0.0;
1848 m_vAdjust->upper = frange;
1849 m_vAdjust->value = fpos;
1850 m_vAdjust->step_increment = 1.0;
1851 m_vAdjust->page_increment = (float)(wxMax(fthumb-2,0));
1852 m_vAdjust->page_size = fthumb;
1853 };
33d0b396 1854
c801d85f
KB		 1855 if (m_wxwindow->window)
1856 {
1857 if (orient == wxHORIZONTAL)
1858 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
1859 else
1860 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
1861
401ec7b6 1862 gtk_widget_set_usize( m_widget, m_width, m_height );
c801d85f
KB		 1863 };
1864};
1865
debe6624 1866void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
c801d85f
KB		 1867{
1868 if (!m_wxwindow) return;
1869
1870 if (orient == wxHORIZONTAL)
1871 {
1872 float fpos = (float)pos;
1873 m_oldHorizontalPos = fpos;
1874
1875 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
1876 m_hAdjust->value = fpos;
1877 }
1878 else
1879 {
1880 float fpos = (float)pos;
1881 m_oldVerticalPos = fpos;
1882 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
1883 m_vAdjust->value = fpos;
1884 };
1885
1886 if (m_wxwindow->window)
1887 {
1888 if (orient == wxHORIZONTAL)
1889 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
1890 else
1891 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
1892 };
1893};
1894
debe6624 1895int wxWindow::GetScrollThumb( int orient ) const
c801d85f
KB		 1896{
1897 if (!m_wxwindow) return 0;
1898
1899 if (orient == wxHORIZONTAL)
1900 return (int)(m_hAdjust->page_size+0.5);
1901 else
1902 return (int)(m_vAdjust->page_size+0.5);
1903};
1904
debe6624 1905int wxWindow::GetScrollPos( int orient ) const
c801d85f
KB		 1906{
1907 if (!m_wxwindow) return 0;
1908
1909 if (orient == wxHORIZONTAL)
1910 return (int)(m_hAdjust->value+0.5);
1911 else
1912 return (int)(m_vAdjust->value+0.5);
1913};
1914
debe6624 1915int wxWindow::GetScrollRange( int orient ) const
c801d85f
KB		 1916{
1917 if (!m_wxwindow) return 0;
1918
1919 if (orient == wxHORIZONTAL)
1920 return (int)(m_hAdjust->upper+0.5);
1921 else
1922 return (int)(m_vAdjust->upper+0.5);
1923};
1924
debe6624 1925void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
c801d85f
KB		 1926{
1927 if (!m_wxwindow) return;
1928
1929 m_drawingOffsetX += dx;
1930 m_drawingOffsetY += dy;
1931
1932// printf( "X: %d Y: %d \n", (int)m_drawingOffsetX, (int)m_drawingOffsetY );
1933
1934 gtk_myfixed_set_offset( GTK_MYFIXED(m_wxwindow), m_drawingOffsetX, m_drawingOffsetY );
1935
1936/*
1937 The code here is very nifty, but it doesn't work with
1938 overlapping windows...
1939
1940 int cw = 0;
1941 int ch = 0;
1942 GetClientSize( &cw, &ch );
1943
1944 int w = cw - abs(dx);
1945 int h = ch - abs(dy);
1946 if ((h < 0) || (w < 0))
1947 {
1948 Refresh();
1949 return;
1950 };
1951 int s_x = 0;
1952 int s_y = 0;
1953 if (dx < 0) s_x = -dx;
1954 if (dy < 0) s_y = -dy;
1955 int d_x = 0;
1956 int d_y = 0;
1957 if (dx > 0) d_x = dx;
1958 if (dy > 0) d_y = dy;
1959 gdk_window_copy_area( m_wxwindow->window, m_wxwindow->style->fg_gc[0], d_x, d_y,
1960 m_wxwindow->window, s_x, s_y, w, h );
1961
1962 wxRect rect;
1963 if (dx < 0) rect.x = cw+dx; else rect.x = 0;
1964 if (dy < 0) rect.y = ch+dy; else rect.y = 0;
1965 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
1966 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
1967
1968 Refresh( TRUE, &rect );
1969*/
1970};
1971
1972void wxWindow::GetDrawingOffset( long *x, long *y )
1973{
1974 if (x) *x = m_drawingOffsetX;
1975 if (y) *y = m_drawingOffsetY;
1976};
1977
1978//-------------------------------------------------------------------------------------
1979// Layout
1980//-------------------------------------------------------------------------------------
1981
1982wxLayoutConstraints *wxWindow::GetConstraints(void) const
1983{
1984 return m_constraints;
1985};
1986
1987void wxWindow::SetConstraints( wxLayoutConstraints *constraints )
1988{
1989 if (m_constraints)
1990 {
1991 UnsetConstraints(m_constraints);
1992 delete m_constraints;
1993 }
1994 m_constraints = constraints;
1995 if (m_constraints)
1996 {
1997 // Make sure other windows know they're part of a 'meaningful relationship'
1998 if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this))
1999 m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2000 if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this))
2001 m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2002 if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this))
2003 m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2004 if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this))
2005 m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2006 if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this))
2007 m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2008 if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this))
2009 m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2010 if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this))
2011 m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2012 if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this))
2013 m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this);
2014 }
2015;
2016}
2017;
2018
debe6624 2019void wxWindow::SetAutoLayout( bool autoLayout )
c801d85f
KB		 2020{
2021 m_autoLayout = autoLayout;
2022};
2023
2024bool wxWindow::GetAutoLayout(void) const
2025{
2026 return m_autoLayout;
2027};
2028
2029wxSizer *wxWindow::GetSizer(void) const
2030{
2031 return m_windowSizer;
2032};
2033
2034void wxWindow::SetSizerParent( wxWindow *win )
2035{
2036 m_sizerParent = win;
2037};
2038
2039wxWindow *wxWindow::GetSizerParent(void) const
2040{
2041 return m_sizerParent;
2042};
2043
2044// This removes any dangling pointers to this window
2045// in other windows' constraintsInvolvedIn lists.
2046void wxWindow::UnsetConstraints(wxLayoutConstraints *c)
2047{
2048 if (c)
2049 {
2050 if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this))
2051 c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2052 if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this))
2053 c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2054 if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this))
2055 c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2056 if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this))
2057 c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2058 if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this))
2059 c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2060 if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this))
2061 c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2062 if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this))
2063 c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2064 if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this))
2065 c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this);
2066 }
2067}
2068
2069// Back-pointer to other windows we're involved with, so if we delete
2070// this window, we must delete any constraints we're involved with.
2071void wxWindow::AddConstraintReference(wxWindow *otherWin)
2072{
2073 if (!m_constraintsInvolvedIn)
2074 m_constraintsInvolvedIn = new wxList;
2075 if (!m_constraintsInvolvedIn->Member(otherWin))
2076 m_constraintsInvolvedIn->Append(otherWin);
2077}
2078
2079// REMOVE back-pointer to other windows we're involved with.
2080void wxWindow::RemoveConstraintReference(wxWindow *otherWin)
2081{
2082 if (m_constraintsInvolvedIn)
2083 m_constraintsInvolvedIn->DeleteObject(otherWin);
2084}
2085
2086// Reset any constraints that mention this window
2087void wxWindow::DeleteRelatedConstraints(void)
2088{
2089 if (m_constraintsInvolvedIn)
2090 {
2091 wxNode *node = m_constraintsInvolvedIn->First();
2092 while (node)
2093 {
2094 wxWindow *win = (wxWindow *)node->Data();
2095 wxNode *next = node->Next();
2096 wxLayoutConstraints *constr = win->GetConstraints();
2097
2098 // Reset any constraints involving this window
2099 if (constr)
2100 {
2101 constr->left.ResetIfWin((wxWindow *)this);
2102 constr->top.ResetIfWin((wxWindow *)this);
2103 constr->right.ResetIfWin((wxWindow *)this);
2104 constr->bottom.ResetIfWin((wxWindow *)this);
2105 constr->width.ResetIfWin((wxWindow *)this);
2106 constr->height.ResetIfWin((wxWindow *)this);
2107 constr->centreX.ResetIfWin((wxWindow *)this);
2108 constr->centreY.ResetIfWin((wxWindow *)this);
2109 }
2110 delete node;
2111 node = next;
2112 }
2113 delete m_constraintsInvolvedIn;
2114 m_constraintsInvolvedIn = NULL;
2115 }
2116}
2117
2118void wxWindow::SetSizer(wxSizer *sizer)
2119{
2120 m_windowSizer = sizer;
2121 if (sizer)
2122 sizer->SetSizerParent((wxWindow *)this);
2123}
2124
2125/*
2126 * New version
2127 */
2128
2129bool wxWindow::Layout(void)
2130{
2131 if (GetConstraints())
2132 {
2133 int w, h;
2134 GetClientSize(&w, &h);
2135 GetConstraints()->width.SetValue(w);
2136 GetConstraints()->height.SetValue(h);
2137 }
2138
2139 // If top level (one sizer), evaluate the sizer's constraints.
2140 if (GetSizer())
2141 {
2142 int noChanges;
2143 GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated
2144 GetSizer()->LayoutPhase1(&noChanges);
2145 GetSizer()->LayoutPhase2(&noChanges);
2146 GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes
2147 return TRUE;
2148 }
2149 else
2150 {
2151 // Otherwise, evaluate child constraints
2152 ResetConstraints(); // Mark all constraints as unevaluated
2153 DoPhase(1); // Just one phase need if no sizers involved
2154 DoPhase(2);
2155 SetConstraintSizes(); // Recursively set the real window sizes
2156 }
2157 return TRUE;
2158}
2159
2160
2161// Do a phase of evaluating constraints:
2162// the default behaviour. wxSizers may do a similar
2163// thing, but also impose their own 'constraints'
2164// and order the evaluation differently.
2165bool wxWindow::LayoutPhase1(int *noChanges)
2166{
2167 wxLayoutConstraints *constr = GetConstraints();
2168 if (constr)
2169 {
2170 return constr->SatisfyConstraints((wxWindow *)this, noChanges);
2171 }
2172 else
2173 return TRUE;
2174}
2175
2176bool wxWindow::LayoutPhase2(int *noChanges)
2177{
2178 *noChanges = 0;
2179
2180 // Layout children
2181 DoPhase(1);
2182 DoPhase(2);
2183 return TRUE;
2184}
2185
2186// Do a phase of evaluating child constraints
debe6624 2187bool wxWindow::DoPhase(int phase)
c801d85f
KB		 2188{
2189 int noIterations = 0;
2190 int maxIterations = 500;
2191 int noChanges = 1;
2192 int noFailures = 0;
2193 wxList succeeded;
2194 while ((noChanges > 0) && (noIterations < maxIterations))
2195 {
2196 noChanges = 0;
2197 noFailures = 0;
2198 wxNode *node = GetChildren()->First();
2199 while (node)
2200 {
2201 wxWindow *child = (wxWindow *)node->Data();
2202 if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog)))
2203 {
2204 wxLayoutConstraints *constr = child->GetConstraints();
2205 if (constr)
2206 {
2207 if (succeeded.Member(child))
2208 {
2209 }
2210 else
2211 {
2212 int tempNoChanges = 0;
2213 bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ;
2214 noChanges += tempNoChanges;
2215 if (success)
2216 {
2217 succeeded.Append(child);
2218 }
2219 }
2220 }
2221 }
2222 node = node->Next();
2223 }
2224 noIterations ++;
2225 }
2226 return TRUE;
2227}
2228
2229void wxWindow::ResetConstraints(void)
2230{
2231 wxLayoutConstraints *constr = GetConstraints();
2232 if (constr)
2233 {
2234 constr->left.SetDone(FALSE);
2235 constr->top.SetDone(FALSE);
2236 constr->right.SetDone(FALSE);
2237 constr->bottom.SetDone(FALSE);
2238 constr->width.SetDone(FALSE);
2239 constr->height.SetDone(FALSE);
2240 constr->centreX.SetDone(FALSE);
2241 constr->centreY.SetDone(FALSE);
2242 }
2243 wxNode *node = GetChildren()->First();
2244 while (node)
2245 {
2246 wxWindow *win = (wxWindow *)node->Data();
2247 if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
2248 win->ResetConstraints();
2249 node = node->Next();
2250 }
2251}
2252
2253// Need to distinguish between setting the 'fake' size for
2254// windows and sizers, and setting the real values.
debe6624 2255void wxWindow::SetConstraintSizes(bool recurse)
c801d85f
KB		 2256{
2257 wxLayoutConstraints *constr = GetConstraints();
2258 if (constr && constr->left.GetDone() && constr->right.GetDone() &&
2259 constr->width.GetDone() && constr->height.GetDone())
2260 {
2261 int x = constr->left.GetValue();
2262 int y = constr->top.GetValue();
2263 int w = constr->width.GetValue();
2264 int h = constr->height.GetValue();
2265
2266 // If we don't want to resize this window, just move it...
2267 if ((constr->width.GetRelationship() != wxAsIs) ||
2268 (constr->height.GetRelationship() != wxAsIs))
2269 {
2270 // Calls Layout() recursively. AAAGH. How can we stop that.
2271 // Simply take Layout() out of non-top level OnSizes.
2272 SizerSetSize(x, y, w, h);
2273 }
2274 else
2275 {
2276 SizerMove(x, y);
2277 }
2278 }
2279 else if (constr)
2280 {
2281 char *windowClass = this->GetClassInfo()->GetClassName();
2282
2283 wxString winName;
5e0aa05a
VZ		 2284 if (GetName() == "")
2285 winName = "unnamed";
2286 else
2287 winName = GetName();
c801d85f
KB		 2288 wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName);
2289 if (!constr->left.GetDone())
2290 wxDebugMsg(" unsatisfied 'left' constraint.\n");
2291 if (!constr->right.GetDone())
2292 wxDebugMsg(" unsatisfied 'right' constraint.\n");
2293 if (!constr->width.GetDone())
2294 wxDebugMsg(" unsatisfied 'width' constraint.\n");
2295 if (!constr->height.GetDone())
2296 wxDebugMsg(" unsatisfied 'height' constraint.\n");
2297 wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n");
2298 }
2299
2300 if (recurse)
2301 {
2302 wxNode *node = GetChildren()->First();
2303 while (node)
2304 {
2305 wxWindow *win = (wxWindow *)node->Data();
2306 if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog)))
2307 win->SetConstraintSizes();
2308 node = node->Next();
2309 }
2310 }
2311}
2312
2313// This assumes that all sizers are 'on' the same
2314// window, i.e. the parent of this window.
2315void wxWindow::TransformSizerToActual(int *x, int *y) const
2316{
2317 if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) ||
5e0aa05a 2318 m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) )
c801d85f
KB		 2319 return;
2320
2321 int xp, yp;
2322 m_sizerParent->GetPosition(&xp, &yp);
2323 m_sizerParent->TransformSizerToActual(&xp, &yp);
2324 *x += xp;
2325 *y += yp;
2326}
2327
debe6624 2328void wxWindow::SizerSetSize(int x, int y, int w, int h)
c801d85f 2329{
5e0aa05a
VZ		 2330 int xx = x;
2331 int yy = y;
c801d85f
KB		 2332 TransformSizerToActual(&xx, &yy);
2333 SetSize(xx, yy, w, h);
2334}
2335
debe6624 2336void wxWindow::SizerMove(int x, int y)
c801d85f 2337{
5e0aa05a
VZ		 2338 int xx = x;
2339 int yy = y;
c801d85f
KB		 2340 TransformSizerToActual(&xx, &yy);
2341 Move(xx, yy);
2342}
2343
2344// Only set the size/position of the constraint (if any)
debe6624 2345void wxWindow::SetSizeConstraint(int x, int y, int w, int h)
c801d85f
KB		 2346{
2347 wxLayoutConstraints *constr = GetConstraints();
2348 if (constr)
2349 {
2350 if (x != -1)
2351 {
2352 constr->left.SetValue(x);
2353 constr->left.SetDone(TRUE);
2354 }
2355 if (y != -1)
2356 {
2357 constr->top.SetValue(y);
2358 constr->top.SetDone(TRUE);
2359 }
2360 if (w != -1)
2361 {
2362 constr->width.SetValue(w);
2363 constr->width.SetDone(TRUE);
2364 }
2365 if (h != -1)
2366 {
2367 constr->height.SetValue(h);
2368 constr->height.SetDone(TRUE);
2369 }
2370 }
2371}
2372
debe6624 2373void wxWindow::MoveConstraint(int x, int y)
c801d85f
KB		 2374{
2375 wxLayoutConstraints *constr = GetConstraints();
2376 if (constr)
2377 {
2378 if (x != -1)
2379 {
2380 constr->left.SetValue(x);
2381 constr->left.SetDone(TRUE);
2382 }
2383 if (y != -1)
2384 {
2385 constr->top.SetValue(y);
2386 constr->top.SetDone(TRUE);
2387 }
2388 }
2389}
2390
2391void wxWindow::GetSizeConstraint(int *w, int *h) const
2392{
2393 wxLayoutConstraints *constr = GetConstraints();
2394 if (constr)
2395 {
2396 *w = constr->width.GetValue();
2397 *h = constr->height.GetValue();
2398 }
2399 else
2400 GetSize(w, h);
2401}
2402
2403void wxWindow::GetClientSizeConstraint(int *w, int *h) const
2404{
2405 wxLayoutConstraints *constr = GetConstraints();
2406 if (constr)
2407 {
2408 *w = constr->width.GetValue();
2409 *h = constr->height.GetValue();
2410 }
2411 else
2412 GetClientSize(w, h);
2413}
2414
2415void wxWindow::GetPositionConstraint(int *x, int *y) const
2416{
2417 wxLayoutConstraints *constr = GetConstraints();
2418 if (constr)
2419 {
2420 *x = constr->left.GetValue();
2421 *y = constr->top.GetValue();
2422 }
2423 else
2424 GetPosition(x, y);
2425}
2426
7fd1d163 2427bool wxWindow::AcceptsFocus() const
0abbe297
VZ		 2428{
2429 return IsEnabled() && IsShown();
2430}
5e0aa05a
VZ		 2431
2432void wxWindow::OnIdle(wxIdleEvent& event)
2433{
2434 UpdateWindowUI();
2435}
2436
2437#include "../common/wincmn.cpp"
wxWidgets (Impactor)