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


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