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


4abdea598ab7dd4cc68ebbb40f1b9dc141208ad4
[wxWidgets.git] / src / gtk1 / 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_delayedFont)
1378 win->SetFont( win->GetFont() );
1379
1380 if (win->m_delayedBackgroundColour)
1381 win->SetBackgroundColour( win->GetBackgroundColour() );
1382
1383 if (win->m_delayedForegroundColour)
1384 win->SetForegroundColour( win->GetForegroundColour() );
1385
1386 win->SetCursor( win->GetCursor() );
1387
1388 return FALSE;
1389 }
1390
1391 //-----------------------------------------------------------------------------
1392 // InsertChild for wxWindow.
1393 //-----------------------------------------------------------------------------
1394
1395 /* Callback for wxWindow. This very strange beast has to be used because
1396 * C++ has no virtual methods in a constructor. We have to emulate a
1397 * virtual function here as wxNotebook requires a different way to insert
1398 * a child in it. I had opted for creating a wxNotebookPage window class
1399 * which would have made this superfluous (such in the MDI window system),
1400 * but no-one was listening to me... */
1401
1402 static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
1403 {
1404 gtk_myfixed_put( GTK_MYFIXED(parent->m_wxwindow),
1405 GTK_WIDGET(child->m_widget),
1406 child->m_x,
1407 child->m_y,
1408 child->m_width,
1409 child->m_height );
1410
1411 if (parent->HasFlag(wxTAB_TRAVERSAL))
1412 {
1413 /* we now allow a window to get the focus as long as it
1414 doesn't have any children. */
1415 GTK_WIDGET_UNSET_FLAGS( parent->m_wxwindow, GTK_CAN_FOCUS );
1416 }
1417 }
1418
1419 //-----------------------------------------------------------------------------
1420 // global functions
1421 //-----------------------------------------------------------------------------
1422
1423 wxWindow* wxGetActiveWindow()
1424 {
1425 return g_focusWindow;
1426 }
1427
1428 //-----------------------------------------------------------------------------
1429 // wxWindow
1430 //-----------------------------------------------------------------------------
1431
1432 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
1433
1434 BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
1435 EVT_KEY_DOWN(wxWindow::OnKeyDown)
1436 END_EVENT_TABLE()
1437
1438 void wxWindow::Init()
1439 {
1440 // common init
1441 InitBase();
1442
1443 // GTK specific
1444 m_widget = (GtkWidget *) NULL;
1445 m_wxwindow = (GtkWidget *) NULL;
1446
1447 // position/size
1448 m_x = 0;
1449 m_y = 0;
1450 m_width = 0;
1451 m_height = 0;
1452
1453 m_sizeSet = FALSE;
1454 m_hasVMT = FALSE;
1455 m_needParent = TRUE;
1456
1457 m_hasScrolling = FALSE;
1458 m_isScrolling = FALSE;
1459
1460 m_hAdjust = (GtkAdjustment*) NULL;
1461 m_vAdjust = (GtkAdjustment*) NULL;
1462 m_oldHorizontalPos = 0.0;
1463 m_oldVerticalPos = 0.0;
1464
1465 m_resizing = FALSE;
1466 m_scrollGC = (GdkGC*) NULL;
1467 m_widgetStyle = (GtkStyle*) NULL;
1468
1469 m_insertCallback = wxInsertChildInWindow;
1470
1471 m_isStaticBox = FALSE;
1472 m_acceptsFocus = FALSE;
1473 }
1474
1475 wxWindow::wxWindow()
1476 {
1477 Init();
1478 }
1479
1480 wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
1481 const wxPoint &pos, const wxSize &size,
1482 long style, const wxString &name )
1483 {
1484 Init();
1485
1486 Create( parent, id, pos, size, style, name );
1487 }
1488
1489 bool wxWindow::Create( wxWindow *parent, wxWindowID id,
1490 const wxPoint &pos, const wxSize &size,
1491 long style, const wxString &name )
1492 {
1493 PreCreation( parent, id, pos, size, style, name );
1494
1495 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
1496 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
1497
1498 #ifdef __WXDEBUG__
1499 debug_focus_in( m_widget, _T("wxWindow::m_widget"), name );
1500 #endif
1501
1502 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
1503
1504 #ifdef __WXDEBUG__
1505 debug_focus_in( scrolledWindow->hscrollbar, _T("wxWindow::hsrcollbar"), name );
1506 debug_focus_in( scrolledWindow->vscrollbar, _T("wxWindow::vsrcollbar"), name );
1507 #endif
1508
1509 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1510 scroll_class->scrollbar_spacing = 0;
1511
1512 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
1513
1514 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
1515 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
1516
1517 m_wxwindow = gtk_myfixed_new();
1518
1519 #ifdef __WXDEBUG__
1520 debug_focus_in( m_wxwindow, _T("wxWindow::m_wxwindow"), name );
1521 #endif
1522
1523 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
1524
1525 #if (GTK_MINOR_VERSION > 0)
1526 GtkMyFixed *myfixed = GTK_MYFIXED(m_wxwindow);
1527
1528 if (HasFlag(wxRAISED_BORDER))
1529 {
1530 gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_OUT );
1531 }
1532 else if (HasFlag(wxSUNKEN_BORDER))
1533 {
1534 gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_IN );
1535 }
1536 else
1537 {
1538 gtk_myfixed_set_shadow_type( myfixed, GTK_SHADOW_NONE );
1539 }
1540 #else // GTK_MINOR_VERSION == 0
1541 GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
1542
1543 if (HasFlag(wxRAISED_BORDER))
1544 {
1545 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
1546 }
1547 else if (HasFlag(wxSUNKEN_BORDER))
1548 {
1549 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
1550 }
1551 else
1552 {
1553 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
1554 }
1555 #endif // GTK_MINOR_VERSION
1556
1557 if (HasFlag(wxTAB_TRAVERSAL))
1558 {
1559 /* we now allow a window to get the focus as long as it
1560 doesn't have any children. */
1561 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
1562 m_acceptsFocus = FALSE;
1563 }
1564 else
1565 {
1566 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
1567 m_acceptsFocus = TRUE;
1568 }
1569
1570 #if (GTK_MINOR_VERSION == 0)
1571 // shut the viewport up
1572 gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1573 gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1574 #endif // GTK_MINOR_VERSION == 0
1575
1576 // I _really_ don't want scrollbars in the beginning
1577 m_vAdjust->lower = 0.0;
1578 m_vAdjust->upper = 1.0;
1579 m_vAdjust->value = 0.0;
1580 m_vAdjust->step_increment = 1.0;
1581 m_vAdjust->page_increment = 1.0;
1582 m_vAdjust->page_size = 5.0;
1583 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
1584 m_hAdjust->lower = 0.0;
1585 m_hAdjust->upper = 1.0;
1586 m_hAdjust->value = 0.0;
1587 m_hAdjust->step_increment = 1.0;
1588 m_hAdjust->page_increment = 1.0;
1589 m_hAdjust->page_size = 5.0;
1590 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
1591
1592 // these handlers block mouse events to any window during scrolling such as
1593 // motion events and prevent GTK and wxWindows from fighting over where the
1594 // slider should be
1595
1596 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
1597 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1598
1599 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
1600 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1601
1602 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
1603 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1604
1605 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
1606 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
1607
1608 // these handlers get notified when screen updates are required either when
1609 // scrolling or when the window size (and therefore scrollbar configuration)
1610 // has changed
1611
1612 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
1613 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
1614 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
1615 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
1616
1617 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed",
1618 (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
1619 gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
1620 (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
1621
1622 gtk_widget_show( m_wxwindow );
1623
1624 if (m_parent)
1625 m_parent->DoAddChild( this );
1626
1627 PostCreation();
1628
1629 Show( TRUE );
1630
1631 return TRUE;
1632 }
1633
1634 wxWindow::~wxWindow()
1635 {
1636 m_hasVMT = FALSE;
1637
1638 if (m_widget)
1639 Show( FALSE );
1640
1641 DestroyChildren();
1642
1643 if (m_parent)
1644 m_parent->RemoveChild( this );
1645
1646 if (m_widgetStyle)
1647 {
1648 gtk_style_unref( m_widgetStyle );
1649 m_widgetStyle = (GtkStyle*) NULL;
1650 }
1651
1652 if (m_scrollGC)
1653 {
1654 gdk_gc_unref( m_scrollGC );
1655 m_scrollGC = (GdkGC*) NULL;
1656 }
1657
1658 if (m_wxwindow)
1659 {
1660 gtk_widget_destroy( m_wxwindow );
1661 m_wxwindow = (GtkWidget*) NULL;
1662 }
1663
1664 if (m_widget)
1665 {
1666 gtk_widget_destroy( m_widget );
1667 m_widget = (GtkWidget*) NULL;
1668 }
1669 }
1670
1671 void wxWindow::PreCreation( wxWindow *parent,
1672 wxWindowID id,
1673 const wxPoint &pos,
1674 const wxSize &size,
1675 long style,
1676 const wxString &name )
1677 {
1678 wxASSERT_MSG( !m_needParent || parent, _T("Need complete parent.") );
1679
1680 if ( !CreateBase(parent, id, pos, size, style, name) )
1681 {
1682 wxFAIL_MSG(_T("window creation failed"));
1683 }
1684
1685 m_width = WidthDefault(size.x);
1686 m_height = HeightDefault(size.y);
1687
1688 m_x = (int)pos.x;
1689 m_y = (int)pos.y;
1690
1691 if (!parent) /* some reasonable defaults */
1692 {
1693 if (m_x == -1)
1694 {
1695 m_x = (gdk_screen_width () - m_width) / 2;
1696 if (m_x < 10) m_x = 10;
1697 }
1698 if (m_y == -1)
1699 {
1700 m_y = (gdk_screen_height () - m_height) / 2;
1701 if (m_y < 10) m_y = 10;
1702 }
1703 }
1704 }
1705
1706 void wxWindow::PostCreation()
1707 {
1708 wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
1709
1710 if (m_wxwindow)
1711 {
1712 /* these get reported to wxWindows -> wxPaintEvent */
1713 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
1714 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
1715
1716 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
1717 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
1718
1719 #if (GTK_MINOR_VERSION > 0)
1720 /* these are called when the "sunken" or "raised" borders are drawn */
1721 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
1722 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
1723
1724 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
1725 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
1726 #endif
1727 }
1728
1729 GtkWidget *connect_widget = GetConnectWidget();
1730
1731 ConnectWidget( connect_widget );
1732
1733 /* we cannot set colours, fonts and cursors before the widget has
1734 been realized, so we do this directly after realization */
1735 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
1736 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
1737
1738 m_hasVMT = TRUE;
1739 }
1740
1741 void wxWindow::ConnectWidget( GtkWidget *widget )
1742 {
1743 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
1744 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
1745
1746 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
1747 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
1748
1749 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
1750 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
1751
1752 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
1753 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
1754
1755 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
1756 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
1757
1758 gtk_signal_connect( GTK_OBJECT(widget), "focus_in_event",
1759 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
1760
1761 gtk_signal_connect( GTK_OBJECT(widget), "focus_out_event",
1762 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
1763
1764 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
1765 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
1766
1767 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
1768 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
1769 }
1770
1771 bool wxWindow::Destroy()
1772 {
1773 wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
1774
1775 m_hasVMT = FALSE;
1776
1777 return wxWindowBase::Destroy();
1778 }
1779
1780 void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
1781 {
1782 wxASSERT_MSG( (m_widget != NULL), _T("invalid window") );
1783 wxASSERT_MSG( (m_parent != NULL), _T("wxWindow::SetSize requires parent.\n") );
1784
1785 if (m_resizing) return; /* I don't like recursions */
1786 m_resizing = TRUE;
1787
1788 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
1789 {
1790 /* don't set the size for children of wxNotebook, just take the values. */
1791 m_x = x;
1792 m_y = y;
1793 m_width = width;
1794 m_height = height;
1795 }
1796 else
1797 {
1798 if ((sizeFlags & wxSIZE_USE_EXISTING) == wxSIZE_USE_EXISTING)
1799 {
1800 if (x != -1) m_x = x;
1801 if (y != -1) m_y = y;
1802 if (width != -1) m_width = width;
1803 if (height != -1) m_height = height;
1804 }
1805 else
1806 {
1807 m_x = x;
1808 m_y = y;
1809 m_width = width;
1810 m_height = height;
1811 }
1812
1813 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
1814 {
1815 if (width == -1) m_width = 80;
1816 }
1817
1818 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
1819 {
1820 if (height == -1) m_height = 26;
1821 }
1822
1823 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
1824 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
1825 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
1826 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
1827
1828 int border = 0;
1829
1830 if (GTK_WIDGET_HAS_DEFAULT(m_widget))
1831 {
1832 /* the default button has a border around it */
1833 border = 5;
1834 }
1835
1836 /* this is the result of hours of debugging: the following code
1837 means that if we have a m_wxwindow and we set the size of
1838 m_widget, m_widget (which is a GtkScrolledWindow) does NOT
1839 automatically propagate its size down to its m_wxwindow,
1840 which is its client area. therefore, we have to tell the
1841 client area directly that it has to resize itself.
1842 this will lead to that m_widget (GtkScrolledWindow) will
1843 calculate how much size it needs for scrollbars etc and
1844 it will then call XXX_size_allocate of its child, which
1845 is m_wxwindow. m_wxwindow in turn will do the same with its
1846 children and so on. problems can arise if this happens
1847 before all the children have been realized as some widgets
1848 stupidy need to be realized during XXX_size_allocate (e.g.
1849 GtkNotebook) and they will segv if called otherwise. this
1850 emergency is tested in gtk_myfixed_size_allocate. Normally
1851 this shouldn't be needed and only gtk_widget_queue_resize()
1852 should be enough to provoke a resize at the next appropriate
1853 moment, but this seems to fail, e.g. when a wxNotebook contains
1854 a wxSplitterWindow: the splitter window's children won't
1855 show up properly resized then. */
1856
1857 gtk_myfixed_set_size( GTK_MYFIXED(m_parent->m_wxwindow),
1858 m_widget,
1859 m_x-border,
1860 m_y-border,
1861 m_width+2*border,
1862 m_height+2*border );
1863 }
1864
1865 m_sizeSet = TRUE;
1866
1867 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1868 event.SetEventObject( this );
1869 GetEventHandler()->ProcessEvent( event );
1870
1871 m_resizing = FALSE;
1872 }
1873
1874 void wxWindow::OnInternalIdle()
1875 {
1876 UpdateWindowUI();
1877 }
1878
1879 void wxWindow::DoGetSize( int *width, int *height ) const
1880 {
1881 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
1882
1883 if (width) (*width) = m_width;
1884 if (height) (*height) = m_height;
1885 }
1886
1887 void wxWindow::DoSetClientSize( int width, int height )
1888 {
1889 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
1890
1891 if (!m_wxwindow)
1892 {
1893 SetSize( width, height );
1894 }
1895 else
1896 {
1897 int dw = 0;
1898 int dh = 0;
1899
1900 if (!m_hasScrolling)
1901 {
1902 GtkStyleClass *window_class = m_wxwindow->style->klass;
1903
1904 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
1905 {
1906 dw += 2 * window_class->xthickness;
1907 dh += 2 * window_class->ythickness;
1908 }
1909 }
1910 else
1911 {
1912 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1913 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1914
1915 #if (GTK_MINOR_VERSION == 0)
1916 GtkWidget *viewport = scroll_window->viewport;
1917 GtkStyleClass *viewport_class = viewport->style->klass;
1918
1919 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
1920 {
1921 dw += 2 * viewport_class->xthickness;
1922 dh += 2 * viewport_class->ythickness;
1923 }
1924 #endif
1925
1926 /*
1927 GtkWidget *hscrollbar = scroll_window->hscrollbar;
1928 GtkWidget *vscrollbar = scroll_window->vscrollbar;
1929
1930 we use this instead: range.slider_width = 11 + 2*2pts edge
1931 */
1932
1933 if (scroll_window->vscrollbar_visible)
1934 {
1935 dw += 15; /* dw += vscrollbar->allocation.width; */
1936 dw += scroll_class->scrollbar_spacing;
1937 }
1938
1939 if (scroll_window->hscrollbar_visible)
1940 {
1941 dh += 15; /* dh += hscrollbar->allocation.height; */
1942 dw += scroll_class->scrollbar_spacing;
1943 }
1944 }
1945
1946 SetSize( width+dw, height+dh );
1947 }
1948 }
1949
1950 void wxWindow::DoGetClientSize( int *width, int *height ) const
1951 {
1952 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
1953
1954 if (!m_wxwindow)
1955 {
1956 if (width) (*width) = m_width;
1957 if (height) (*height) = m_height;
1958 }
1959 else
1960 {
1961 int dw = 0;
1962 int dh = 0;
1963
1964 if (!m_hasScrolling)
1965 {
1966 GtkStyleClass *window_class = m_wxwindow->style->klass;
1967
1968 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
1969 {
1970 dw += 2 * window_class->xthickness;
1971 dh += 2 * window_class->ythickness;
1972 }
1973 }
1974 else
1975 {
1976 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
1977 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1978
1979 #if (GTK_MINOR_VERSION == 0)
1980 GtkWidget *viewport = scroll_window->viewport;
1981 GtkStyleClass *viewport_class = viewport->style->klass;
1982
1983 if ( HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER) )
1984 {
1985 dw += 2 * viewport_class->xthickness;
1986 dh += 2 * viewport_class->ythickness;
1987 }
1988 #endif
1989 /*
1990 GtkWidget *hscrollbar = scroll_window->hscrollbar;
1991 GtkWidget *vscrollbar = scroll_window->vscrollbar;
1992
1993 we use this instead: range.slider_width = 11 + 2*2pts edge
1994 */
1995
1996 if (scroll_window->vscrollbar_visible)
1997 {
1998 dw += 15; /* dw += vscrollbar->allocation.width; */
1999 dw += scroll_class->scrollbar_spacing;
2000 }
2001
2002 if (scroll_window->hscrollbar_visible)
2003 {
2004 dh += 15; /* dh += hscrollbar->allocation.height; */
2005 dh += scroll_class->scrollbar_spacing;
2006 }
2007 }
2008
2009 if (width) (*width) = m_width - dw;
2010 if (height) (*height) = m_height - dh;
2011 }
2012 }
2013
2014 void wxWindow::DoGetPosition( int *x, int *y ) const
2015 {
2016 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
2017
2018 if (x) (*x) = m_x;
2019 if (y) (*y) = m_y;
2020 }
2021
2022 void wxWindow::ClientToScreen( int *x, int *y ) const
2023 {
2024 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
2025
2026 if (!m_widget->window) return;
2027
2028 GdkWindow *source = (GdkWindow *) NULL;
2029 if (m_wxwindow)
2030 source = m_wxwindow->window;
2031 else
2032 source = m_widget->window;
2033
2034 int org_x = 0;
2035 int org_y = 0;
2036 gdk_window_get_origin( source, &org_x, &org_y );
2037
2038 if (!m_wxwindow)
2039 {
2040 if (GTK_WIDGET_NO_WINDOW (m_widget))
2041 {
2042 org_x += m_widget->allocation.x;
2043 org_y += m_widget->allocation.y;
2044 }
2045 }
2046
2047 if (x) *x += org_x;
2048 if (y) *y += org_y;
2049 }
2050
2051 void wxWindow::ScreenToClient( int *x, int *y ) const
2052 {
2053 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
2054
2055 if (!m_widget->window) return;
2056
2057 GdkWindow *source = (GdkWindow *) NULL;
2058 if (m_wxwindow)
2059 source = m_wxwindow->window;
2060 else
2061 source = m_widget->window;
2062
2063 int org_x = 0;
2064 int org_y = 0;
2065 gdk_window_get_origin( source, &org_x, &org_y );
2066
2067 if (!m_wxwindow)
2068 {
2069 if (GTK_WIDGET_NO_WINDOW (m_widget))
2070 {
2071 org_x += m_widget->allocation.x;
2072 org_y += m_widget->allocation.y;
2073 }
2074 }
2075
2076 if (x) *x -= org_x;
2077 if (y) *y -= org_y;
2078 }
2079
2080 bool wxWindow::Show( bool show )
2081 {
2082 wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
2083
2084 if (!wxWindowBase::Show(show))
2085 {
2086 // nothing to do
2087 return FALSE;
2088 }
2089
2090 if (show)
2091 gtk_widget_show( m_widget );
2092 else
2093 gtk_widget_hide( m_widget );
2094
2095 return TRUE;
2096 }
2097
2098 bool wxWindow::Enable( bool enable )
2099 {
2100 wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
2101
2102 if (!wxWindowBase::Enable(enable))
2103 {
2104 // nothing to do
2105 return FALSE;
2106 }
2107
2108 gtk_widget_set_sensitive( m_widget, enable );
2109 if ( m_wxwindow )
2110 gtk_widget_set_sensitive( m_wxwindow, enable );
2111
2112 return TRUE;
2113 }
2114
2115 int wxWindow::GetCharHeight() const
2116 {
2117 wxCHECK_MSG( (m_widget != NULL), 12, _T("invalid window") );
2118
2119 wxCHECK_MSG( m_font.Ok(), 12, _T("invalid font") );
2120
2121 GdkFont *font = m_font.GetInternalFont( 1.0 );
2122
2123 return font->ascent + font->descent;
2124 }
2125
2126 int wxWindow::GetCharWidth() const
2127 {
2128 wxCHECK_MSG( (m_widget != NULL), 8, _T("invalid window") );
2129
2130 wxCHECK_MSG( m_font.Ok(), 8, _T("invalid font") );
2131
2132 GdkFont *font = m_font.GetInternalFont( 1.0 );
2133
2134 return gdk_string_width( font, "H" );
2135 }
2136
2137 void wxWindow::GetTextExtent( const wxString& string,
2138 int *x,
2139 int *y,
2140 int *descent,
2141 int *externalLeading,
2142 const wxFont *theFont ) const
2143 {
2144 wxFont fontToUse = m_font;
2145 if (theFont) fontToUse = *theFont;
2146
2147 wxCHECK_RET( fontToUse.Ok(), _T("invalid font") );
2148
2149 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
2150 if (x) (*x) = gdk_string_width( font, string.mbc_str() );
2151 if (y) (*y) = font->ascent + font->descent;
2152 if (descent) (*descent) = font->descent;
2153 if (externalLeading) (*externalLeading) = 0; // ??
2154 }
2155
2156 void wxWindow::OnKeyDown( wxKeyEvent &event )
2157 {
2158 event.SetEventType( wxEVT_CHAR );
2159
2160 if (!GetEventHandler()->ProcessEvent( event ))
2161 {
2162 event.Skip();
2163 }
2164 }
2165
2166 void wxWindow::SetFocus()
2167 {
2168 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
2169
2170 GtkWidget *connect_widget = GetConnectWidget();
2171 if (connect_widget)
2172 {
2173 if (GTK_WIDGET_CAN_FOCUS(connect_widget) /*&& !GTK_WIDGET_HAS_FOCUS (connect_widget)*/ )
2174 {
2175 gtk_widget_grab_focus (connect_widget);
2176 }
2177 else if (GTK_IS_CONTAINER(connect_widget))
2178 {
2179 gtk_container_focus( GTK_CONTAINER(connect_widget), GTK_DIR_TAB_FORWARD );
2180 }
2181 else
2182 {
2183 }
2184 }
2185 }
2186
2187 bool wxWindow::AcceptsFocus() const
2188 {
2189 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
2190 }
2191
2192 bool wxWindow::Reparent( wxWindow *newParent )
2193 {
2194 wxCHECK_MSG( (m_widget != NULL), (wxWindow*) NULL, _T("invalid window") );
2195
2196 gtk_widget_unparent( m_widget );
2197
2198 if ( !wxWindowBase::Reparent(newParent) )
2199 return FALSE;
2200
2201 return TRUE;
2202 }
2203
2204 void wxWindow::Raise()
2205 {
2206 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
2207
2208 if (!m_widget->window) return;
2209
2210 gdk_window_raise( m_widget->window );
2211 }
2212
2213 void wxWindow::Lower()
2214 {
2215 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
2216
2217 if (!m_widget->window) return;
2218
2219 gdk_window_lower( m_widget->window );
2220 }
2221
2222 bool wxWindow::SetCursor( const wxCursor &cursor )
2223 {
2224 wxCHECK_MSG( (m_widget != NULL), FALSE, _T("invalid window") );
2225
2226 if (!wxWindowBase::SetCursor(cursor))
2227 {
2228 // don't leave if the GTK widget has just
2229 // been realized
2230 if (!m_delayedCursor) return FALSE;
2231 }
2232
2233 GtkWidget *connect_widget = GetConnectWidget();
2234 if (!connect_widget->window)
2235 {
2236 // indicate that a new style has been set
2237 // but it couldn't get applied as the
2238 // widget hasn't been realized yet.
2239 m_delayedCursor = TRUE;
2240
2241 // pretend we have done something
2242 return TRUE;
2243 }
2244
2245 if ((m_widget) && (m_widget->window))
2246 gdk_window_set_cursor( m_widget->window, GetCursor().GetCursor() );
2247
2248 if ((m_wxwindow) && (m_wxwindow->window))
2249 gdk_window_set_cursor( m_wxwindow->window, GetCursor().GetCursor() );
2250
2251 // cursor was set
2252 return TRUE;
2253 }
2254
2255 void wxWindow::WarpPointer( int WXUNUSED(x), int WXUNUSED(y) )
2256 {
2257 // TODO
2258 }
2259
2260 void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
2261 {
2262 wxCHECK_RET( (m_widget != NULL), _T("invalid window") );
2263
2264 if (!m_widget->window) return;
2265
2266 if (eraseBackground && m_wxwindow && m_wxwindow->window)
2267 {
2268 if (rect)
2269 {
2270 gdk_window_clear_area( m_wxwindow->window,
2271 rect->x, rect->y,
2272 rect->width, rect->height );
2273 }
2274 else
2275 {
2276 gdk_window_clear( m_wxwindow->window );
2277 }
2278 }
2279
2280 if (!rect)
2281 {
2282 if (m_wxwindow)
2283 gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
2284 else
2285 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
2286 }
2287 else
2288 {
2289 GdkRectangle gdk_rect;
2290 gdk_rect.x = rect->x;
2291 gdk_rect.y = rect->y;
2292 gdk_rect.width = rect->width;
2293 gdk_rect.height = rect->height;
2294
2295 if (m_wxwindow)
2296 gtk_widget_draw( m_wxwindow, &gdk_rect );
2297 else
2298 gtk_widget_draw( m_widget, &gdk_rect );
2299 }
2300 }
2301
2302 void wxWindow::Clear()
2303 {
2304 wxCHECK_RET( m_widget != NULL, _T("invalid window") );
2305
2306 if (!m_widget->window) return;
2307
2308 if (m_wxwindow && m_wxwindow->window)
2309 {
2310 gdk_window_clear( m_wxwindow->window );
2311 }
2312 }
2313
2314 #if wxUSE_TOOLTIPS
2315 void wxWindow::DoSetToolTip( wxToolTip *tip )
2316 {
2317 wxWindowBase::DoSetToolTip(tip);
2318
2319 if (m_tooltip)
2320 m_tooltip->Apply( this );
2321 }
2322
2323 void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
2324 {
2325 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConv_current->cWX2MB(tip), (gchar*) NULL );
2326 }
2327 #endif // wxUSE_TOOLTIPS
2328
2329 bool wxWindow::SetBackgroundColour( const wxColour &colour )
2330 {
2331 wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
2332
2333 if (!wxWindowBase::SetBackgroundColour(colour))
2334 {
2335 // don't leave if the GTK widget has just
2336 // been realized
2337 if (!m_delayedBackgroundColour) return FALSE;
2338 }
2339
2340 GtkWidget *connect_widget = GetConnectWidget();
2341 if (!connect_widget->window)
2342 {
2343 // indicate that a new style has been set
2344 // but it couldn't get applied as the
2345 // widget hasn't been realized yet.
2346 m_delayedBackgroundColour = TRUE;
2347
2348 // pretend we have done something
2349 return TRUE;
2350 }
2351
2352 if (m_wxwindow && m_wxwindow->window)
2353 {
2354 /* wxMSW doesn't clear the window here. I don't do that either to
2355 provide compatibility. call Clear() to do the job. */
2356
2357 m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_wxwindow->window ) );
2358 gdk_window_set_background( m_wxwindow->window, m_backgroundColour.GetColor() );
2359 }
2360
2361 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2362
2363 if (sysbg == m_backgroundColour)
2364 {
2365 m_backgroundColour = wxNullColour;
2366 ApplyWidgetStyle();
2367 m_backgroundColour = sysbg;
2368 }
2369 else
2370 {
2371 ApplyWidgetStyle();
2372 }
2373
2374 return TRUE;
2375 }
2376
2377 bool wxWindow::SetForegroundColour( const wxColour &colour )
2378 {
2379 wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
2380
2381 if (!wxWindowBase::SetForegroundColour(colour))
2382 {
2383 // don't leave if the GTK widget has just
2384 // been realized
2385 if (!m_delayedForegroundColour) return FALSE;
2386 }
2387
2388 GtkWidget *connect_widget = GetConnectWidget();
2389 if (!connect_widget->window)
2390 {
2391 // indicate that a new style has been set
2392 // but it couldn't get applied as the
2393 // widget hasn't been realized yet.
2394 m_delayedForegroundColour = TRUE;
2395
2396 // pretend we have done something
2397 return TRUE;
2398 }
2399
2400 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2401 if (sysbg == m_foregroundColour)
2402 {
2403 m_backgroundColour = wxNullColour;
2404 ApplyWidgetStyle();
2405 m_backgroundColour = sysbg;
2406 }
2407 else
2408 {
2409 ApplyWidgetStyle();
2410 }
2411
2412 return TRUE;
2413 }
2414
2415 GtkStyle *wxWindow::GetWidgetStyle()
2416 {
2417 if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
2418
2419 m_widgetStyle = gtk_style_copy( gtk_widget_get_style( m_widget ) );
2420
2421 return m_widgetStyle;
2422 }
2423
2424 void wxWindow::SetWidgetStyle()
2425 {
2426 GtkStyle *style = GetWidgetStyle();
2427
2428 gdk_font_unref( style->font );
2429 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
2430
2431 if (m_foregroundColour.Ok())
2432 {
2433 m_foregroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
2434 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
2435 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
2436 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
2437 }
2438
2439 if (m_backgroundColour.Ok())
2440 {
2441 m_backgroundColour.CalcPixel( gdk_window_get_colormap( m_widget->window ) );
2442 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2443 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2444 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2445 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2446 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2447 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2448 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2449 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2450 }
2451 }
2452
2453 void wxWindow::ApplyWidgetStyle()
2454 {
2455 }
2456
2457 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
2458 {
2459 menu->SetInvokingWindow( win );
2460 wxNode *node = menu->GetItems().First();
2461 while (node)
2462 {
2463 wxMenuItem *menuitem = (wxMenuItem*)node->Data();
2464 if (menuitem->IsSubMenu())
2465 {
2466 SetInvokingWindow( menuitem->GetSubMenu(), win );
2467 }
2468 node = node->Next();
2469 }
2470 }
2471
2472 static gint gs_pop_x = 0;
2473 static gint gs_pop_y = 0;
2474
2475 static void pop_pos_callback( GtkMenu *menu, gint *x, gint *y, wxWindow *win )
2476 {
2477 win->ClientToScreen( &gs_pop_x, &gs_pop_y );
2478 *x = gs_pop_x;
2479 *y = gs_pop_y;
2480 }
2481
2482 bool wxWindow::PopupMenu( wxMenu *menu, int x, int y )
2483 {
2484 wxCHECK_MSG( m_widget != NULL, FALSE, _T("invalid window") );
2485
2486 wxCHECK_MSG( menu != NULL, FALSE, _T("invalid popup-menu") );
2487
2488 SetInvokingWindow( menu, this );
2489
2490 menu->UpdateUI();
2491
2492 gs_pop_x = x;
2493 gs_pop_y = y;
2494
2495 gtk_menu_popup(
2496 GTK_MENU(menu->m_menu),
2497 (GtkWidget *) NULL, // parent menu shell
2498 (GtkWidget *) NULL, // parent menu item
2499 (GtkMenuPositionFunc) pop_pos_callback,
2500 (gpointer) this, // client data
2501 0, // button used to activate it
2502 0 //gs_timeLastClick // the time of activation
2503 );
2504 return TRUE;
2505 }
2506
2507 #if wxUSE_DRAG_AND_DROP
2508
2509 void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
2510 {
2511 wxCHECK_RET( m_widget != NULL, _T("invalid window") );
2512
2513 GtkWidget *dnd_widget = GetConnectWidget();
2514
2515 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
2516
2517 if (m_dropTarget) delete m_dropTarget;
2518 m_dropTarget = dropTarget;
2519
2520 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
2521 }
2522
2523 #endif // wxUSE_DRAG_AND_DROP
2524
2525 GtkWidget* wxWindow::GetConnectWidget()
2526 {
2527 GtkWidget *connect_widget = m_widget;
2528 if (m_wxwindow) connect_widget = m_wxwindow;
2529
2530 return connect_widget;
2531 }
2532
2533 bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
2534 {
2535 if (m_wxwindow) return (window == m_wxwindow->window);
2536 return (window == m_widget->window);
2537 }
2538
2539 bool wxWindow::SetFont( const wxFont &font )
2540 {
2541 wxCHECK_MSG( m_widget != NULL, FALSE, _T( "invalid window") );
2542
2543 if (!wxWindowBase::SetFont(font))
2544 {
2545 // don't leave if the GTK widget has just
2546 // been realized
2547 if (!m_delayedFont) return FALSE;
2548 }
2549
2550 GtkWidget *connect_widget = GetConnectWidget();
2551 if (!connect_widget->window)
2552 {
2553 // indicate that a new style has been set
2554 // but it couldn't get applied as the
2555 // widget hasn't been realized yet.
2556 m_delayedFont = TRUE;
2557
2558 // pretend we have done something
2559 return TRUE;
2560 }
2561
2562 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2563 if ( sysbg == m_backgroundColour )
2564 {
2565 m_backgroundColour = wxNullColour;
2566 ApplyWidgetStyle();
2567 m_backgroundColour = sysbg;
2568 }
2569 else
2570 {
2571 ApplyWidgetStyle();
2572 }
2573
2574 return TRUE;
2575 }
2576
2577 void wxWindow::CaptureMouse()
2578 {
2579 wxCHECK_RET( m_widget != NULL, _T("invalid window") );
2580
2581 wxCHECK_RET( g_capturing == FALSE, _T("CaptureMouse called twice") );
2582
2583 GtkWidget *connect_widget = GetConnectWidget();
2584 if (!connect_widget->window) return;
2585
2586 gtk_grab_add( connect_widget );
2587 gdk_pointer_grab( connect_widget->window, FALSE,
2588 (GdkEventMask)
2589 (GDK_BUTTON_PRESS_MASK |
2590 GDK_BUTTON_RELEASE_MASK |
2591 GDK_POINTER_MOTION_MASK),
2592 (GdkWindow *) NULL,
2593 (GdkCursor *) NULL,
2594 GDK_CURRENT_TIME );
2595 g_capturing = TRUE;
2596 }
2597
2598 void wxWindow::ReleaseMouse()
2599 {
2600 wxCHECK_RET( m_widget != NULL, _T("invalid window") );
2601
2602 wxCHECK_RET( g_capturing == TRUE, _T("ReleaseMouse called twice") );
2603
2604 GtkWidget *connect_widget = GetConnectWidget();
2605 if (!connect_widget->window) return;
2606
2607 gtk_grab_remove( connect_widget );
2608 gdk_pointer_ungrab ( GDK_CURRENT_TIME );
2609 g_capturing = FALSE;
2610 }
2611
2612 bool wxWindow::IsRetained() const
2613 {
2614 return FALSE;
2615 }
2616
2617 void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
2618 int range, bool refresh )
2619 {
2620 wxCHECK_RET( m_widget != NULL, _T("invalid window") );
2621
2622 wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
2623
2624 m_hasScrolling = TRUE;
2625
2626 if (orient == wxHORIZONTAL)
2627 {
2628 float fpos = (float)pos;
2629 float frange = (float)range;
2630 float fthumb = (float)thumbVisible;
2631 if (fpos > frange-fthumb) fpos = frange-fthumb;
2632 if (fpos < 0.0) fpos = 0.0;
2633
2634 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
2635 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
2636 {
2637 SetScrollPos( orient, pos, refresh );
2638 return;
2639 }
2640
2641 m_oldHorizontalPos = fpos;
2642
2643 m_hAdjust->lower = 0.0;
2644 m_hAdjust->upper = frange;
2645 m_hAdjust->value = fpos;
2646 m_hAdjust->step_increment = 1.0;
2647 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
2648 m_hAdjust->page_size = fthumb;
2649 }
2650 else
2651 {
2652 float fpos = (float)pos;
2653 float frange = (float)range;
2654 float fthumb = (float)thumbVisible;
2655 if (fpos > frange-fthumb) fpos = frange-fthumb;
2656 if (fpos < 0.0) fpos = 0.0;
2657
2658 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
2659 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
2660 {
2661 SetScrollPos( orient, pos, refresh );
2662 return;
2663 }
2664
2665 m_oldVerticalPos = fpos;
2666
2667 m_vAdjust->lower = 0.0;
2668 m_vAdjust->upper = frange;
2669 m_vAdjust->value = fpos;
2670 m_vAdjust->step_increment = 1.0;
2671 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
2672 m_vAdjust->page_size = fthumb;
2673 }
2674
2675 if (m_wxwindow->window)
2676 {
2677 if (orient == wxHORIZONTAL)
2678 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2679 else
2680 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2681
2682 gtk_widget_set_usize( m_widget, m_width, m_height );
2683 }
2684 }
2685
2686 void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
2687 {
2688 wxCHECK_RET( m_widget != NULL, _T("invalid window") );
2689
2690 wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
2691
2692 if (orient == wxHORIZONTAL)
2693 {
2694 float fpos = (float)pos;
2695 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
2696 if (fpos < 0.0) fpos = 0.0;
2697 m_oldHorizontalPos = fpos;
2698
2699 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
2700 m_hAdjust->value = fpos;
2701 }
2702 else
2703 {
2704 float fpos = (float)pos;
2705 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
2706 if (fpos < 0.0) fpos = 0.0;
2707 m_oldVerticalPos = fpos;
2708
2709 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
2710 m_vAdjust->value = fpos;
2711 }
2712
2713 if (!m_isScrolling)
2714 {
2715 if (m_wxwindow->window)
2716 {
2717 if (orient == wxHORIZONTAL)
2718 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
2719 else
2720 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
2721 }
2722 }
2723 }
2724
2725 int wxWindow::GetScrollThumb( int orient ) const
2726 {
2727 wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
2728
2729 wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
2730
2731 if (orient == wxHORIZONTAL)
2732 return (int)(m_hAdjust->page_size+0.5);
2733 else
2734 return (int)(m_vAdjust->page_size+0.5);
2735 }
2736
2737 int wxWindow::GetScrollPos( int orient ) const
2738 {
2739 wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
2740
2741 wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
2742
2743 if (orient == wxHORIZONTAL)
2744 return (int)(m_hAdjust->value+0.5);
2745 else
2746 return (int)(m_vAdjust->value+0.5);
2747 }
2748
2749 int wxWindow::GetScrollRange( int orient ) const
2750 {
2751 wxCHECK_MSG( m_widget != NULL, 0, _T("invalid window") );
2752
2753 wxCHECK_MSG( m_wxwindow != NULL, 0, _T("window needs client area for scrolling") );
2754
2755 if (orient == wxHORIZONTAL)
2756 return (int)(m_hAdjust->upper+0.5);
2757 else
2758 return (int)(m_vAdjust->upper+0.5);
2759 }
2760
2761 void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
2762 {
2763 wxCHECK_RET( m_widget != NULL, _T("invalid window") );
2764
2765 wxCHECK_RET( m_wxwindow != NULL, _T("window needs client area for scrolling") );
2766
2767 if (!m_scrollGC)
2768 {
2769 m_scrollGC = gdk_gc_new( m_wxwindow->window );
2770 gdk_gc_set_exposures( m_scrollGC, TRUE );
2771 }
2772
2773 int cw = 0;
2774 int ch = 0;
2775 GetClientSize( &cw, &ch );
2776 int w = cw - abs(dx);
2777 int h = ch - abs(dy);
2778
2779 if ((h < 0) || (w < 0))
2780 {
2781 Refresh();
2782 }
2783 else
2784 {
2785 int s_x = 0;
2786 int s_y = 0;
2787 if (dx < 0) s_x = -dx;
2788 if (dy < 0) s_y = -dy;
2789 int d_x = 0;
2790 int d_y = 0;
2791 if (dx > 0) d_x = dx;
2792 if (dy > 0) d_y = dy;
2793
2794 gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
2795 m_wxwindow->window, s_x, s_y, w, h );
2796
2797 wxRect rect;
2798 if (dx < 0) rect.x = cw+dx; else rect.x = 0;
2799 if (dy < 0) rect.y = ch+dy; else rect.y = 0;
2800 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
2801 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
2802
2803 Refresh( TRUE, &rect );
2804 }
2805
2806 wxNode *node = m_children.First();
2807 while (node)
2808 {
2809 wxWindow *child = (wxWindow*) node->Data();
2810 child->Move( child->m_x + dx, child->m_y + dy );
2811 node = node->Next();
2812 }
2813 }
2814
2815 void wxWindow::SetScrolling(bool scroll)
2816 {
2817 m_isScrolling = g_blockEventsOnScroll = scroll;
2818 }
wxWidgets (Impactor)