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