]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
projects / wxWidgets.git / blob
? search:


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