]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/window.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Applied patch [ 571965 ] update stc contrib stuff
[wxWidgets.git] / src / gtk / window.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: gtk/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 #ifdef __VMS
16 #define XWarpPointer XWARPPOINTER
17 #endif
18
19 #include "wx/defs.h"
20 #include "wx/window.h"
21 #include "wx/dcclient.h"
22 #include "wx/frame.h"
23 #include "wx/app.h"
24 #include "wx/layout.h"
25 #include "wx/utils.h"
26 #include "wx/dialog.h"
27 #include "wx/msgdlg.h"
28 #include "wx/module.h"
29
30 #if wxUSE_DRAG_AND_DROP
31 #include "wx/dnd.h"
32 #endif
33
34 #if wxUSE_TOOLTIPS
35 #include "wx/tooltip.h"
36 #endif
37
38 #if wxUSE_CARET
39 #include "wx/caret.h"
40 #endif // wxUSE_CARET
41
42 #if wxUSE_TEXTCTRL
43 #include "wx/textctrl.h"
44 #endif
45
46 #include "wx/menu.h"
47 #include "wx/statusbr.h"
48 #include "wx/intl.h"
49 #include "wx/settings.h"
50 #include "wx/log.h"
51
52 #ifdef __WXDEBUG__
53 #include "wx/thread.h"
54 #endif
55
56 #include <math.h>
57
58 #include "wx/gtk/private.h"
59 #include <gdk/gdkprivate.h>
60 #include <gdk/gdkkeysyms.h>
61 #include <gdk/gdkx.h>
62
63 #include <gtk/gtk.h>
64 #include <gtk/gtkprivate.h>
65
66 #include "wx/gtk/win_gtk.h"
67
68 #ifdef __WXGTK20__
69 #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d))
70 #else
71 #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d))
72 #endif
73
74 #ifdef __WXGTK20__
75 #ifdef HAVE_XIM
76 #undef HAVE_XIM
77 #endif
78 #endif
79
80 #ifdef __WXGTK20__
81 extern GtkContainerClass *pizza_parent_class;
82 #endif
83
84 //-----------------------------------------------------------------------------
85 // documentation on internals
86 //-----------------------------------------------------------------------------
87
88 /*
89 I have been asked several times about writing some documentation about
90 the GTK port of wxWindows, especially its internal structures. Obviously,
91 you cannot understand wxGTK without knowing a little about the GTK, but
92 some more information about what the wxWindow, which is the base class
93 for all other window classes, does seems required as well.
94
95 I)
96
97 What does wxWindow do? It contains the common interface for the following
98 jobs of its descendants:
99
100 1) Define the rudimentary behaviour common to all window classes, such as
101 resizing, intercepting user input (so as to make it possible to use these
102 events for special purposes in a derived class), window names etc.
103
104 2) Provide the possibility to contain and manage children, if the derived
105 class is allowed to contain children, which holds true for those window
106 classes which do not display a native GTK widget. To name them, these
107 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
108 work classes are a special case and are handled a bit differently from
109 the rest. The same holds true for the wxNotebook class.
110
111 3) Provide the possibility to draw into a client area of a window. This,
112 too, only holds true for classes that do not display a native GTK widget
113 as above.
114
115 4) Provide the entire mechanism for scrolling widgets. This actual inter-
116 face for this is usually in wxScrolledWindow, but the GTK implementation
117 is in this class.
118
119 5) A multitude of helper or extra methods for special purposes, such as
120 Drag'n'Drop, managing validators etc.
121
122 6) Display a border (sunken, raised, simple or none).
123
124 Normally one might expect, that one wxWindows window would always correspond
125 to one GTK widget. Under GTK, there is no such allround widget that has all
126 the functionality. Moreover, the GTK defines a client area as a different
127 widget from the actual widget you are handling. Last but not least some
128 special classes (e.g. wxFrame) handle different categories of widgets and
129 still have the possibility to draw something in the client area.
130 It was therefore required to write a special purpose GTK widget, that would
131 represent a client area in the sense of wxWindows capable to do the jobs
132 2), 3) and 4). I have written this class and it resides in win_gtk.c of
133 this directory.
134
135 All windows must have a widget, with which they interact with other under-
136 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
137 thw wxWindow class has a member variable called m_widget which holds a
138 pointer to this widget. When the window class represents a GTK native widget,
139 this is (in most cases) the only GTK widget the class manages. E.g. the
140 wxStatitText class handles only a GtkLabel widget a pointer to which you
141 can find in m_widget (defined in wxWindow)
142
143 When the class has a client area for drawing into and for containing children
144 it has to handle the client area widget (of the type GtkPizza, defined in
145 win_gtk.c), but there could be any number of widgets, handled by a class
146 The common rule for all windows is only, that the widget that interacts with
147 the rest of GTK must be referenced in m_widget and all other widgets must be
148 children of this widget on the GTK level. The top-most widget, which also
149 represents the client area, must be in the m_wxwindow field and must be of
150 the type GtkPizza.
151
152 As I said, the window classes that display a GTK native widget only have
153 one widget, so in the case of e.g. the wxButton class m_widget holds a
154 pointer to a GtkButton widget. But windows with client areas (for drawing
155 and children) have a m_widget field that is a pointer to a GtkScrolled-
156 Window and a m_wxwindow field that is pointer to a GtkPizza and this
157 one is (in the GTK sense) a child of the GtkScrolledWindow.
158
159 If the m_wxwindow field is set, then all input to this widget is inter-
160 cepted and sent to the wxWindows class. If not, all input to the widget
161 that gets pointed to by m_widget gets intercepted and sent to the class.
162
163 II)
164
165 The design of scrolling in wxWindows is markedly different from that offered
166 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
167 clicking on a scrollbar belonging to scrolled window will inevitably move
168 the window. In wxWindows, the scrollbar will only emit an event, send this
169 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
170 which actually moves the window and its subchildren. Note that GtkPizza
171 memorizes how much it has been scrolled but that wxWindows forgets this
172 so that the two coordinates systems have to be kept in synch. This is done
173 in various places using the pizza->xoffset and pizza->yoffset values.
174
175 III)
176
177 Singularily the most broken code in GTK is the code that is supposes to
178 inform subwindows (child windows) about new positions. Very often, duplicate
179 events are sent without changes in size or position, equally often no
180 events are sent at all (All this is due to a bug in the GtkContainer code
181 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
182 GTK's own system and it simply waits for size events for toplevel windows
183 and then iterates down the respective size events to all window. This has
184 the disadvantage, that windows might get size events before the GTK widget
185 actually has the reported size. This doesn't normally pose any problem, but
186 the OpenGl drawing routines rely on correct behaviour. Therefore, I have
187 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
188 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
189 window that is used for OpenGl output really has that size (as reported by
190 GTK).
191
192 IV)
193
194 If someone at some point of time feels the immense desire to have a look at,
195 change or attempt to optimse the Refresh() logic, this person will need an
196 intimate understanding of what a "draw" and what an "expose" events are and
197 what there are used for, in particular when used in connection with GTK's
198 own windowless widgets. Beware.
199
200 V)
201
202 Cursors, too, have been a constant source of pleasure. The main difficulty
203 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
204 for the parent. To prevent this from doing too much harm, I use idle time
205 to set the cursor over and over again, starting from the toplevel windows
206 and ending with the youngest generation (speaking of parent and child windows).
207 Also don't forget that cursors (like much else) are connected to GdkWindows,
208 not GtkWidgets and that the "window" field of a GtkWidget might very well
209 point to the GdkWindow of the parent widget (-> "window less widget") and
210 that the two obviously have very different meanings.
211
212 */
213
214 //-----------------------------------------------------------------------------
215 // data
216 //-----------------------------------------------------------------------------
217
218 extern wxList wxPendingDelete;
219 extern bool g_blockEventsOnDrag;
220 extern bool g_blockEventsOnScroll;
221 extern wxCursor g_globalCursor;
222
223 static GdkGC *g_eraseGC = NULL;
224
225 // mouse capture state: the window which has it and if the mouse is currently
226 // inside it
227 static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
228 static bool g_captureWindowHasMouse = FALSE;
229
230 /* extern */ wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL;
231
232 // the last window which had the focus - this is normally never NULL (except
233 // if we never had focus at all) as even when g_focusWindow is NULL it still
234 // keeps its previous value
235 static wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL;
236
237 // the frame that is currently active (i.e. its child has focus). It is
238 // used to generate wxActivateEvents
239 static wxWindowGTK *g_activeFrame = (wxWindowGTK*) NULL;
240 static bool g_activeFrameLostFocus = FALSE;
241
242 // If a window get the focus set but has not been realized
243 // yet, defer setting the focus to idle time.
244 wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;
245
246 // if we detect that the app has got/lost the focus, we set this variable to
247 // either TRUE or FALSE and an activate event will be sent during the next
248 // OnIdle() call and it is reset to -1: this value means that we shouldn't
249 // send any activate events at all
250 static int g_sendActivateEvent = -1;
251
252 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
253 the last click here */
254 static guint32 gs_timeLastClick = 0;
255
256 extern bool g_mainThreadLocked;
257
258 //-----------------------------------------------------------------------------
259 // debug
260 //-----------------------------------------------------------------------------
261
262 #ifndef __WXGTK20__
263 #define DISABLE_STYLE_IF_BROKEN_THEME 1
264 #endif
265
266 #ifdef __WXDEBUG__
267
268 #if wxUSE_THREADS
269 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
270 #else
271 # define DEBUG_MAIN_THREAD
272 #endif
273 #else
274 #define DEBUG_MAIN_THREAD
275 #endif // Debug
276
277 // the trace mask used for the focus debugging messages
278 #define TRACE_FOCUS _T("focus")
279
280 //-----------------------------------------------------------------------------
281 // missing gdk functions
282 //-----------------------------------------------------------------------------
283
284 void
285 gdk_window_warp_pointer (GdkWindow *window,
286 gint x,
287 gint y)
288 {
289 #ifndef __WXGTK20__
290 GdkWindowPrivate *priv;
291 #endif
292
293 if (!window)
294 window = GDK_ROOT_PARENT();
295
296 #ifdef __WXGTK20__
297 if (!GDK_WINDOW_DESTROYED(window))
298 {
299 XWarpPointer (GDK_WINDOW_XDISPLAY(window),
300 None, /* not source window -> move from anywhere */
301 GDK_WINDOW_XID(window), /* dest window */
302 0, 0, 0, 0, /* not source window -> move from anywhere */
303 x, y );
304 }
305 #else
306 priv = (GdkWindowPrivate*) window;
307
308 if (!priv->destroyed)
309 {
310 XWarpPointer (priv->xdisplay,
311 None, /* not source window -> move from anywhere */
312 priv->xwindow, /* dest window */
313 0, 0, 0, 0, /* not source window -> move from anywhere */
314 x, y );
315 }
316 #endif
317 }
318
319 //-----------------------------------------------------------------------------
320 // idle system
321 //-----------------------------------------------------------------------------
322
323 extern void wxapp_install_idle_handler();
324 extern bool g_isIdle;
325
326 //-----------------------------------------------------------------------------
327 // local code (see below)
328 //-----------------------------------------------------------------------------
329
330 // returns the child of win which currently has focus or NULL if not found
331 //
332 // Note: can't be static, needed by textctrl.cpp.
333 wxWindow *wxFindFocusedChild(wxWindowGTK *win)
334 {
335 wxWindow *winFocus = wxWindowGTK::FindFocus();
336 if ( !winFocus )
337 return (wxWindow *)NULL;
338
339 if ( winFocus == win )
340 return (wxWindow *)win;
341
342 for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
343 node;
344 node = node->GetNext() )
345 {
346 wxWindow *child = wxFindFocusedChild(node->GetData());
347 if ( child )
348 return child;
349 }
350
351 return (wxWindow *)NULL;
352 }
353
354 static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
355 {
356 // wxUniversal widgets draw the borders and scrollbars themselves
357 #ifndef __WXUNIVERSAL__
358 if (!win->m_hasVMT)
359 return;
360
361 int dw = 0;
362 int dh = 0;
363
364 if (win->m_hasScrolling)
365 {
366 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
367
368 GtkRequisition vscroll_req;
369 vscroll_req.width = 2;
370 vscroll_req.height = 2;
371 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
372 (scroll_window->vscrollbar, &vscroll_req );
373
374 GtkRequisition hscroll_req;
375 hscroll_req.width = 2;
376 hscroll_req.height = 2;
377 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
378 (scroll_window->hscrollbar, &hscroll_req );
379
380 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget) );
381
382 if (scroll_window->vscrollbar_visible)
383 {
384 dw += vscroll_req.width;
385 dw += scroll_class->scrollbar_spacing;
386 }
387
388 if (scroll_window->hscrollbar_visible)
389 {
390 dh += hscroll_req.height;
391 dh += scroll_class->scrollbar_spacing;
392 }
393 }
394
395 int dx = 0;
396 int dy = 0;
397 if (GTK_WIDGET_NO_WINDOW (widget))
398 {
399 dx += widget->allocation.x;
400 dy += widget->allocation.y;
401 }
402
403 if (win->HasFlag(wxRAISED_BORDER))
404 {
405 gtk_draw_shadow( widget->style,
406 widget->window,
407 GTK_STATE_NORMAL,
408 GTK_SHADOW_OUT,
409 dx, dy,
410 widget->allocation.width-dw, widget->allocation.height-dh );
411 return;
412 }
413
414 if (win->HasFlag(wxSUNKEN_BORDER))
415 {
416 gtk_draw_shadow( widget->style,
417 widget->window,
418 GTK_STATE_NORMAL,
419 GTK_SHADOW_IN,
420 dx, dy,
421 widget->allocation.width-dw, widget->allocation.height-dh );
422 return;
423 }
424
425 if (win->HasFlag(wxSIMPLE_BORDER))
426 {
427 GdkGC *gc;
428 gc = gdk_gc_new( widget->window );
429 gdk_gc_set_foreground( gc, &widget->style->black );
430 gdk_draw_rectangle( widget->window, gc, FALSE,
431 dx, dy,
432 widget->allocation.width-dw-1, widget->allocation.height-dh-1 );
433 gdk_gc_unref( gc );
434 return;
435 }
436 #endif // __WXUNIVERSAL__
437 }
438
439 //-----------------------------------------------------------------------------
440 // "expose_event" of m_widget
441 //-----------------------------------------------------------------------------
442
443 gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )
444 {
445 if (gdk_event->count > 0) return FALSE;
446
447 draw_frame( widget, win );
448
449 #ifdef __WXGTK20__
450
451 (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
452
453 #endif
454 return TRUE;
455 }
456
457 //-----------------------------------------------------------------------------
458 // "draw" of m_widget
459 //-----------------------------------------------------------------------------
460
461 #ifndef __WXGTK20__
462
463 static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
464 {
465 draw_frame( widget, win );
466 }
467
468 #endif // GTK+ < 2.0
469
470 //-----------------------------------------------------------------------------
471 // "size_request" of m_widget
472 //-----------------------------------------------------------------------------
473
474 static void gtk_window_size_request_callback( GtkWidget *widget, GtkRequisition *requisition, wxWindow *win )
475 {
476 int w,h;
477 win->GetSize( &w, &h );
478 if (w < 2) w = 2;
479 if (h < 2) h = 2;
480
481 requisition->height = h;
482 requisition->width = w;
483 }
484
485 //-----------------------------------------------------------------------------
486 // "expose_event" of m_wxwindow
487 //-----------------------------------------------------------------------------
488
489 static int gtk_window_expose_callback( GtkWidget *widget,
490 GdkEventExpose *gdk_event,
491 wxWindow *win )
492 {
493 DEBUG_MAIN_THREAD
494
495 if (g_isIdle)
496 wxapp_install_idle_handler();
497
498 #if 0
499 if (win->GetName())
500 {
501 wxPrintf( wxT("OnExpose from ") );
502 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
503 wxPrintf( win->GetClassInfo()->GetClassName() );
504 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event->area.x,
505 (int)gdk_event->area.y,
506 (int)gdk_event->area.width,
507 (int)gdk_event->area.height );
508 }
509 #endif
510
511 win->GetUpdateRegion().Union( gdk_event->area.x,
512 gdk_event->area.y,
513 gdk_event->area.width,
514 gdk_event->area.height );
515 win->m_clearRegion.Union( gdk_event->area.x,
516 gdk_event->area.y,
517 gdk_event->area.width,
518 gdk_event->area.height );
519
520 // Actual redrawing takes place in idle time.
521 win->GtkUpdate();
522
523 #ifdef __WXGTK20__
524
525 (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
526
527 #endif
528
529 return TRUE;
530 }
531
532 //-----------------------------------------------------------------------------
533 // "event" of m_wxwindow
534 //-----------------------------------------------------------------------------
535
536 // GTK thinks it is clever and filters out a certain amount of "unneeded"
537 // expose events. We need them, of course, so we override the main event
538 // procedure in GtkWidget by giving our own handler for all system events.
539 // There, we look for expose events ourselves whereas all other events are
540 // handled normally.
541
542 gint gtk_window_event_event_callback( GtkWidget *widget,
543 GdkEventExpose *event,
544 wxWindow *win )
545 {
546 if (event->type == GDK_EXPOSE)
547 {
548 gint ret = gtk_window_expose_callback( widget, event, win );
549 return ret;
550 }
551
552 return FALSE;
553 }
554
555 //-----------------------------------------------------------------------------
556 // "draw" of m_wxwindow
557 //-----------------------------------------------------------------------------
558
559 #ifndef __WXGTK20__
560
561 // This callback is a complete replacement of the gtk_pizza_draw() function,
562 // which is disabled.
563
564 static void gtk_window_draw_callback( GtkWidget *widget,
565 GdkRectangle *rect,
566 wxWindow *win )
567 {
568 DEBUG_MAIN_THREAD
569
570 if (g_isIdle)
571 wxapp_install_idle_handler();
572
573 // The wxNO_FULL_REPAINT_ON_RESIZE flag only works if
574 // there are no child windows.
575 if ((win->HasFlag(wxNO_FULL_REPAINT_ON_RESIZE)) &&
576 (win->GetChildren().GetCount() == 0))
577 {
578 return;
579 }
580
581 #if 0
582 if (win->GetName())
583 {
584 wxPrintf( wxT("OnDraw from ") );
585 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
586 wxPrintf( win->GetClassInfo()->GetClassName() );
587 wxPrintf( wxT(" %d %d %d %d\n"), (int)rect->x,
588 (int)rect->y,
589 (int)rect->width,
590 (int)rect->height );
591 }
592 #endif
593
594 #ifndef __WXUNIVERSAL__
595 GtkPizza *pizza = GTK_PIZZA (widget);
596
597 if (win->GetThemeEnabled())
598 {
599 wxWindow *parent = win->GetParent();
600 while (parent && !parent->IsTopLevel())
601 parent = parent->GetParent();
602 if (!parent)
603 parent = win;
604
605 gtk_paint_flat_box (parent->m_widget->style,
606 pizza->bin_window,
607 GTK_STATE_NORMAL,
608 GTK_SHADOW_NONE,
609 rect,
610 parent->m_widget,
611 (char *)"base",
612 0, 0, -1, -1);
613 }
614
615
616 if (!(GTK_WIDGET_APP_PAINTABLE (widget)) &&
617 (pizza->clear_on_draw))
618 {
619 gdk_window_clear_area( pizza->bin_window,
620 rect->x, rect->y, rect->width, rect->height);
621 }
622 #endif
623
624 win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
625
626 // Actual redrawing takes place in idle time.
627
628 win->GtkUpdate();
629
630 #ifndef __WXUNIVERSAL__
631 // Redraw child widgets
632 GList *children = pizza->children;
633 while (children)
634 {
635 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
636 children = children->next;
637
638 GdkRectangle child_area;
639 if (gtk_widget_intersect (child->widget, rect, &child_area))
640 {
641 gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ );
642 }
643 }
644 #endif
645 }
646
647 #endif
648
649 //-----------------------------------------------------------------------------
650 // "key_press_event" from any window
651 //-----------------------------------------------------------------------------
652
653 // set WXTRACE to this to see the key event codes on the console
654 #define TRACE_KEYS _T("keyevent")
655
656 // translates an X key symbol to WXK_XXX value
657 //
658 // if isChar is true it means that the value returned will be used for EVT_CHAR
659 // event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
660 // for example, while if it is false it means that the value is going to be
661 // used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
662 // WXK_NUMPAD_DIVIDE
663 static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
664 {
665 long key_code;
666
667 switch ( keysym )
668 {
669 // Shift, Control and Alt don't generate the CHAR events at all
670 case GDK_Shift_L:
671 case GDK_Shift_R:
672 key_code = isChar ? 0 : WXK_SHIFT;
673 break;
674 case GDK_Control_L:
675 case GDK_Control_R:
676 key_code = isChar ? 0 : WXK_CONTROL;
677 break;
678 case GDK_Meta_L:
679 case GDK_Meta_R:
680 case GDK_Alt_L:
681 case GDK_Alt_R:
682 case GDK_Super_L:
683 case GDK_Super_R:
684 key_code = isChar ? 0 : WXK_ALT;
685 break;
686
687 // neither do the toggle modifies
688 case GDK_Scroll_Lock:
689 key_code = isChar ? 0 : WXK_SCROLL;
690 break;
691
692 case GDK_Caps_Lock:
693 key_code = isChar ? 0 : WXK_CAPITAL;
694 break;
695
696 case GDK_Num_Lock:
697 key_code = isChar ? 0 : WXK_NUMLOCK;
698 break;
699
700
701 // various other special keys
702 case GDK_Menu:
703 key_code = WXK_MENU;
704 break;
705
706 case GDK_Help:
707 key_code = WXK_HELP;
708 break;
709
710 case GDK_BackSpace:
711 key_code = WXK_BACK;
712 break;
713
714 case GDK_ISO_Left_Tab:
715 case GDK_Tab:
716 key_code = WXK_TAB;
717 break;
718
719 case GDK_Linefeed:
720 case GDK_Return:
721 key_code = WXK_RETURN;
722 break;
723
724 case GDK_Clear:
725 key_code = WXK_CLEAR;
726 break;
727
728 case GDK_Pause:
729 key_code = WXK_PAUSE;
730 break;
731
732 case GDK_Select:
733 key_code = WXK_SELECT;
734 break;
735
736 case GDK_Print:
737 key_code = WXK_PRINT;
738 break;
739
740 case GDK_Execute:
741 key_code = WXK_EXECUTE;
742 break;
743
744 case GDK_Escape:
745 key_code = WXK_ESCAPE;
746 break;
747
748 // cursor and other extended keyboard keys
749 case GDK_Delete:
750 key_code = WXK_DELETE;
751 break;
752
753 case GDK_Home:
754 key_code = WXK_HOME;
755 break;
756
757 case GDK_Left:
758 key_code = WXK_LEFT;
759 break;
760
761 case GDK_Up:
762 key_code = WXK_UP;
763 break;
764
765 case GDK_Right:
766 key_code = WXK_RIGHT;
767 break;
768
769 case GDK_Down:
770 key_code = WXK_DOWN;
771 break;
772
773 case GDK_Prior: // == GDK_Page_Up
774 key_code = WXK_PRIOR;
775 break;
776
777 case GDK_Next: // == GDK_Page_Down
778 key_code = WXK_NEXT;
779 break;
780
781 case GDK_End:
782 key_code = WXK_END;
783 break;
784
785 case GDK_Begin:
786 key_code = WXK_HOME;
787 break;
788
789 case GDK_Insert:
790 key_code = WXK_INSERT;
791 break;
792
793
794 // numpad keys
795 case GDK_KP_0:
796 case GDK_KP_1:
797 case GDK_KP_2:
798 case GDK_KP_3:
799 case GDK_KP_4:
800 case GDK_KP_5:
801 case GDK_KP_6:
802 case GDK_KP_7:
803 case GDK_KP_8:
804 case GDK_KP_9:
805 key_code = (isChar ? '0' : WXK_NUMPAD0) + keysym - GDK_KP_0;
806 break;
807
808 case GDK_KP_Space:
809 key_code = isChar ? ' ' : WXK_NUMPAD_SPACE;
810 break;
811
812 case GDK_KP_Tab:
813 key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
814 break;
815
816 case GDK_KP_Enter:
817 key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
818 break;
819
820 case GDK_KP_F1:
821 key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
822 break;
823
824 case GDK_KP_F2:
825 key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
826 break;
827
828 case GDK_KP_F3:
829 key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
830 break;
831
832 case GDK_KP_F4:
833 key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
834 break;
835
836 case GDK_KP_Home:
837 key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
838 break;
839
840 case GDK_KP_Left:
841 key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
842 break;
843
844 case GDK_KP_Up:
845 key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
846 break;
847
848 case GDK_KP_Right:
849 key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
850 break;
851
852 case GDK_KP_Down:
853 key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
854 break;
855
856 case GDK_KP_Prior: // == GDK_KP_Page_Up
857 key_code = isChar ? WXK_PRIOR : WXK_NUMPAD_PRIOR;
858 break;
859
860 case GDK_KP_Next: // == GDK_KP_Page_Down
861 key_code = isChar ? WXK_NEXT : WXK_NUMPAD_NEXT;
862 break;
863
864 case GDK_KP_End:
865 key_code = isChar ? WXK_END : WXK_NUMPAD_END;
866 break;
867
868 case GDK_KP_Begin:
869 key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
870 break;
871
872 case GDK_KP_Insert:
873 key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
874 break;
875
876 case GDK_KP_Delete:
877 key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
878 break;
879
880 case GDK_KP_Equal:
881 key_code = isChar ? '=' : WXK_NUMPAD_EQUAL;
882 break;
883
884 case GDK_KP_Multiply:
885 key_code = isChar ? '*' : WXK_NUMPAD_MULTIPLY;
886 break;
887
888 case GDK_KP_Add:
889 key_code = isChar ? '+' : WXK_NUMPAD_ADD;
890 break;
891
892 case GDK_KP_Separator:
893 // FIXME: what is this?
894 key_code = isChar ? '.' : WXK_NUMPAD_SEPARATOR;
895 break;
896
897 case GDK_KP_Subtract:
898 key_code = isChar ? '-' : WXK_NUMPAD_SUBTRACT;
899 break;
900
901 case GDK_KP_Decimal:
902 key_code = isChar ? '.' : WXK_NUMPAD_DECIMAL;
903 break;
904
905 case GDK_KP_Divide:
906 key_code = isChar ? '/' : WXK_NUMPAD_DIVIDE;
907 break;
908
909
910 // function keys
911 case GDK_F1:
912 case GDK_F2:
913 case GDK_F3:
914 case GDK_F4:
915 case GDK_F5:
916 case GDK_F6:
917 case GDK_F7:
918 case GDK_F8:
919 case GDK_F9:
920 case GDK_F10:
921 case GDK_F11:
922 case GDK_F12:
923 key_code = WXK_F1 + keysym - GDK_F1;
924 break;
925
926 default:
927 key_code = 0;
928 }
929
930 return key_code;
931 }
932
933 static inline bool wxIsAsciiKeysym(KeySym ks)
934 {
935 return ks < 256;
936 }
937
938 static bool
939 wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
940 wxWindowGTK *win,
941 GdkEventKey *gdk_event)
942 {
943 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
944 // but only event->keyval which is quite useless to us, so remember
945 // the last character from GDK_KEY_PRESS and reuse it as last resort
946 //
947 // NB: should be MT-safe as we're always called from the main thread only
948 static struct
949 {
950 KeySym keysym;
951 long keycode;
952 } s_lastKeyPress = { 0, 0 };
953
954 KeySym keysym = gdk_event->keyval;
955
956 wxLogTrace(TRACE_KEYS, _T("Key %s event: keysym = %ld"),
957 event.GetEventType() == wxEVT_KEY_UP ? _T("release")
958 : _T("press"),
959 keysym);
960
961 long key_code = wxTranslateKeySymToWXKey(keysym, FALSE /* !isChar */);
962
963 if ( !key_code )
964 {
965 // do we have the translation or is it a plain ASCII character?
966 if ( (gdk_event->length == 1) || wxIsAsciiKeysym(keysym) )
967 {
968 // we should use keysym if it is ASCII as X does some translations
969 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
970 // which we don't want here (but which we do use for OnChar())
971 if ( !wxIsAsciiKeysym(keysym) )
972 {
973 keysym = (KeySym)gdk_event->string[0];
974 }
975
976 // we want to always get the same key code when the same key is
977 // pressed regardless of the state of the modifies, i.e. on a
978 // standard US keyboard pressing '5' or '%' ('5' key with
979 // Shift) should result in the same key code in OnKeyDown():
980 // '5' (although OnChar() will get either '5' or '%').
981 //
982 // to do it we first translate keysym to keycode (== scan code)
983 // and then back but always using the lower register
984 Display *dpy = (Display *)wxGetDisplay();
985 KeyCode keycode = XKeysymToKeycode(dpy, keysym);
986
987 wxLogTrace(TRACE_KEYS, _T("\t-> keycode %d"), keycode);
988
989 KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
990
991 // use the normalized, i.e. lower register, keysym if we've
992 // got one
993 key_code = keysymNormalized ? keysymNormalized : keysym;
994
995 // as explained above, we want to have lower register key codes
996 // normally but for the letter keys we want to have the upper ones
997 //
998 // NB: don't use XConvertCase() here, we want to do it for letters
999 // only
1000 key_code = toupper(key_code);
1001 }
1002 else // non ASCII key, what to do?
1003 {
1004 // by default, ignore it
1005 key_code = 0;
1006
1007 // but if we have cached information from the last KEY_PRESS
1008 if ( gdk_event->type == GDK_KEY_RELEASE )
1009 {
1010 // then reuse it
1011 if ( keysym == s_lastKeyPress.keysym )
1012 {
1013 key_code = s_lastKeyPress.keycode;
1014 }
1015 }
1016 }
1017
1018 if ( gdk_event->type == GDK_KEY_PRESS )
1019 {
1020 // remember it to be reused for KEY_UP event later
1021 s_lastKeyPress.keysym = keysym;
1022 s_lastKeyPress.keycode = key_code;
1023 }
1024 }
1025
1026 wxLogTrace(TRACE_KEYS, _T("\t-> wxKeyCode %ld"), key_code);
1027
1028 // sending unknown key events doesn't really make sense
1029 if ( !key_code )
1030 return FALSE;
1031
1032 // now fill all the other fields
1033 int x = 0;
1034 int y = 0;
1035 GdkModifierType state;
1036 if (gdk_event->window)
1037 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1038
1039 event.SetTimestamp( gdk_event->time );
1040 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
1041 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
1042 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
1043 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
1044 event.m_keyCode = key_code;
1045 event.m_scanCode = gdk_event->keyval;
1046 event.m_rawCode = (wxUint32) gdk_event->keyval;
1047 event.m_rawFlags = 0;
1048 event.m_x = x;
1049 event.m_y = y;
1050 event.SetEventObject( win );
1051
1052 return TRUE;
1053 }
1054
1055 static gint gtk_window_key_press_callback( GtkWidget *widget,
1056 GdkEventKey *gdk_event,
1057 wxWindow *win )
1058 {
1059 DEBUG_MAIN_THREAD
1060
1061 if (g_isIdle)
1062 wxapp_install_idle_handler();
1063
1064 if (!win->m_hasVMT)
1065 return FALSE;
1066 if (g_blockEventsOnDrag)
1067 return FALSE;
1068
1069
1070 wxKeyEvent event( wxEVT_KEY_DOWN );
1071 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1072 {
1073 // unknown key pressed, ignore (the event would be useless anyhow)
1074 return FALSE;
1075 }
1076
1077 // Emit KEY_DOWN event
1078 bool ret = win->GetEventHandler()->ProcessEvent( event );
1079
1080 #if wxUSE_ACCEL
1081 if (!ret)
1082 {
1083 wxWindowGTK *ancestor = win;
1084 while (ancestor)
1085 {
1086 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1087 if (command != -1)
1088 {
1089 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1090 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
1091 break;
1092 }
1093 if (ancestor->IsTopLevel())
1094 break;
1095 ancestor = ancestor->GetParent();
1096 }
1097 }
1098 #endif // wxUSE_ACCEL
1099
1100 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1101 // will only be sent if it is not in an accelerator table.
1102 if (!ret)
1103 {
1104 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1105 KeySym keysym = gdk_event->keyval;
1106 long key_code = wxTranslateKeySymToWXKey(keysym, TRUE /* isChar */);
1107 if ( !key_code )
1108 {
1109 if ( gdk_event->length == 1 )
1110 {
1111 key_code = (unsigned char)gdk_event->string[0];
1112 }
1113 else if ( wxIsAsciiKeysym(keysym) )
1114 {
1115 // ASCII key
1116 key_code = (unsigned char)keysym;
1117 }
1118 }
1119
1120 if ( key_code )
1121 {
1122 wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);
1123
1124 event.m_keyCode = key_code;
1125
1126 // Implement OnCharHook by checking ancesteror top level windows
1127 wxWindow *parent = win;
1128 while (parent && !parent->IsTopLevel())
1129 parent = parent->GetParent();
1130 if (parent)
1131 {
1132 event.SetEventType( wxEVT_CHAR_HOOK );
1133 ret = parent->GetEventHandler()->ProcessEvent( event );
1134 }
1135
1136 if (!ret)
1137 {
1138 event.SetEventType(wxEVT_CHAR);
1139 ret = win->GetEventHandler()->ProcessEvent( event );
1140 }
1141 }
1142 }
1143
1144 // win is a control: tab can be propagated up
1145 if ( !ret &&
1146 ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
1147 // VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1148 // have this style, yet choose not to process this particular TAB in which
1149 // case TAB must still work as a navigational character
1150 #if 0
1151 !win->HasFlag(wxTE_PROCESS_TAB) &&
1152 #endif // 0
1153 win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1154 {
1155 wxNavigationKeyEvent new_event;
1156 new_event.SetEventObject( win->GetParent() );
1157 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1158 new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
1159 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1160 new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
1161 new_event.SetCurrentFocus( win );
1162 ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
1163 }
1164
1165 // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
1166 if ( !ret &&
1167 (gdk_event->keyval == GDK_Escape) )
1168 {
1169 wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
1170 new_event.SetEventObject( win );
1171 ret = win->GetEventHandler()->ProcessEvent( new_event );
1172 }
1173
1174 // Doesn't work.
1175 #if 0
1176 // Pressing F10 will activate the menu bar of the top frame
1177 if ( (!ret) &&
1178 (gdk_event->keyval == GDK_F10) )
1179 {
1180 wxWindowGTK *ancestor = win;
1181 while (ancestor)
1182 {
1183 if (wxIsKindOf(ancestor,wxFrame))
1184 {
1185 wxFrame *frame = (wxFrame*) ancestor;
1186 wxMenuBar *menubar = frame->GetMenuBar();
1187 if (menubar)
1188 {
1189 wxNode *node = menubar->GetMenus().First();
1190 if (node)
1191 {
1192 wxMenu *firstMenu = (wxMenu*) node->Data();
1193 gtk_menu_item_select( GTK_MENU_ITEM(firstMenu->m_owner) );
1194 ret = TRUE;
1195 break;
1196 }
1197 }
1198 }
1199 ancestor = ancestor->GetParent();
1200 }
1201 }
1202 #endif // 0
1203
1204 if (ret)
1205 {
1206 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
1207 return TRUE;
1208 }
1209
1210 return FALSE;
1211 }
1212
1213 //-----------------------------------------------------------------------------
1214 // "key_release_event" from any window
1215 //-----------------------------------------------------------------------------
1216
1217 static gint gtk_window_key_release_callback( GtkWidget *widget,
1218 GdkEventKey *gdk_event,
1219 wxWindowGTK *win )
1220 {
1221 DEBUG_MAIN_THREAD
1222
1223 if (g_isIdle)
1224 wxapp_install_idle_handler();
1225
1226 if (!win->m_hasVMT)
1227 return FALSE;
1228
1229 if (g_blockEventsOnDrag)
1230 return FALSE;
1231
1232 wxKeyEvent event( wxEVT_KEY_UP );
1233 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1234 {
1235 // unknown key pressed, ignore (the event would be useless anyhow
1236 return FALSE;
1237 }
1238
1239 if ( !win->GetEventHandler()->ProcessEvent( event ) )
1240 return FALSE;
1241
1242 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
1243 return TRUE;
1244 }
1245
1246 // ============================================================================
1247 // the mouse events
1248 // ============================================================================
1249
1250 // ----------------------------------------------------------------------------
1251 // mouse event processing helpers
1252 // ----------------------------------------------------------------------------
1253
1254 // init wxMouseEvent with the info from gdk_event
1255 //
1256 // NB: this has to be a macro as gdk_event type is different for different
1257 // events we're used with
1258 #define InitMouseEvent(/* wxWindowGTK * */ win, \
1259 /* wxMouseEvent& */ event, \
1260 /* GdkEventXXX * */ gdk_event) \
1261 { \
1262 event.SetTimestamp( gdk_event->time ); \
1263 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); \
1264 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); \
1265 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); \
1266 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK); \
1267 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); \
1268 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); \
1269 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); \
1270 \
1271 wxPoint pt = win->GetClientAreaOrigin(); \
1272 event.m_x = (wxCoord)gdk_event->x - pt.x; \
1273 event.m_y = (wxCoord)gdk_event->y - pt.y; \
1274 \
1275 event.SetEventObject( win ); \
1276 event.SetId( win->GetId() ); \
1277 event.SetTimestamp( gdk_event->time ); \
1278 } \
1279
1280 static void AdjustEventButtonState(wxMouseEvent& event)
1281 {
1282 // GDK reports the old state of the button for a button press event, but
1283 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1284 // for a LEFT_DOWN event, not FALSE, so we will invert
1285 // left/right/middleDown for the corresponding click events
1286
1287 if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1288 (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1289 (event.GetEventType() == wxEVT_LEFT_UP))
1290 {
1291 event.m_leftDown = !event.m_leftDown;
1292 return;
1293 }
1294
1295 if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1296 (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1297 (event.GetEventType() == wxEVT_MIDDLE_UP))
1298 {
1299 event.m_middleDown = !event.m_middleDown;
1300 return;
1301 }
1302
1303 if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1304 (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1305 (event.GetEventType() == wxEVT_RIGHT_UP))
1306 {
1307 event.m_rightDown = !event.m_rightDown;
1308 return;
1309 }
1310 }
1311
1312 // find the window to send the mouse event too
1313 static
1314 wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1315 {
1316 wxCoord xx = x;
1317 wxCoord yy = y;
1318
1319 if (win->m_wxwindow)
1320 {
1321 GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
1322 xx += pizza->xoffset;
1323 yy += pizza->yoffset;
1324 }
1325
1326 wxNode *node = win->GetChildren().First();
1327 while (node)
1328 {
1329 wxWindowGTK *child = (wxWindowGTK*)node->Data();
1330
1331 node = node->Next();
1332 if (!child->IsShown())
1333 continue;
1334
1335 if (child->IsTransparentForMouse())
1336 {
1337 // wxStaticBox is transparent in the box itself
1338 int xx1 = child->m_x;
1339 int yy1 = child->m_y;
1340 int xx2 = child->m_x + child->m_width;
1341 int yy2 = child->m_x + child->m_height;
1342
1343 // left
1344 if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
1345 // right
1346 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
1347 // top
1348 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
1349 // bottom
1350 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
1351 {
1352 win = child;
1353 x -= child->m_x;
1354 y -= child->m_y;
1355 break;
1356 }
1357
1358 }
1359 else
1360 {
1361 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
1362 (child->m_x <= xx) &&
1363 (child->m_y <= yy) &&
1364 (child->m_x+child->m_width >= xx) &&
1365 (child->m_y+child->m_height >= yy))
1366 {
1367 win = child;
1368 x -= child->m_x;
1369 y -= child->m_y;
1370 break;
1371 }
1372 }
1373 }
1374
1375 return win;
1376 }
1377
1378 //-----------------------------------------------------------------------------
1379 // "button_press_event"
1380 //-----------------------------------------------------------------------------
1381
1382 static gint gtk_window_button_press_callback( GtkWidget *widget,
1383 GdkEventButton *gdk_event,
1384 wxWindowGTK *win )
1385 {
1386 DEBUG_MAIN_THREAD
1387
1388 if (g_isIdle)
1389 wxapp_install_idle_handler();
1390
1391 /*
1392 wxPrintf( wxT("1) OnButtonPress from ") );
1393 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1394 wxPrintf( win->GetClassInfo()->GetClassName() );
1395 wxPrintf( wxT(".\n") );
1396 */
1397 if (!win->m_hasVMT) return FALSE;
1398 if (g_blockEventsOnDrag) return TRUE;
1399 if (g_blockEventsOnScroll) return TRUE;
1400
1401 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1402
1403 if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())
1404 {
1405 gtk_widget_grab_focus( win->m_wxwindow );
1406 /*
1407 wxPrintf( wxT("GrabFocus from ") );
1408 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1409 wxPrintf( win->GetClassInfo()->GetClassName() );
1410 wxPrintf( wxT(".\n") );
1411 */
1412 }
1413
1414 wxEventType event_type = wxEVT_NULL;
1415
1416 if (gdk_event->button == 1)
1417 {
1418 switch (gdk_event->type)
1419 {
1420 case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
1421 case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
1422 default: break;
1423 }
1424 }
1425 else if (gdk_event->button == 2)
1426 {
1427 switch (gdk_event->type)
1428 {
1429 case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
1430 case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
1431 default: break;
1432 }
1433 }
1434 else if (gdk_event->button == 3)
1435 {
1436 switch (gdk_event->type)
1437 {
1438 case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
1439 case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
1440 default: break;
1441 }
1442 }
1443
1444 if ( event_type == wxEVT_NULL )
1445 {
1446 // unknown mouse button or click type
1447 return FALSE;
1448 }
1449
1450 wxMouseEvent event( event_type );
1451 InitMouseEvent( win, event, gdk_event );
1452
1453 AdjustEventButtonState(event);
1454
1455 // wxListBox actually get mouse events from the item, so we need to give it
1456 // a chance to correct this
1457 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1458
1459 // find the correct window to send the event too: it may be a different one
1460 // from the one which got it at GTK+ level because some control don't have
1461 // their own X window and thus cannot get any events.
1462 if ( !g_captureWindow )
1463 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1464
1465 gs_timeLastClick = gdk_event->time;
1466
1467 /*
1468 wxPrintf( wxT("2) OnButtonPress from ") );
1469 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1470 wxPrintf( win->GetClassInfo()->GetClassName() );
1471 wxPrintf( wxT(".\n") );
1472 */
1473
1474 if (win->GetEventHandler()->ProcessEvent( event ))
1475 {
1476 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
1477 return TRUE;
1478 }
1479
1480 return FALSE;
1481 }
1482
1483 //-----------------------------------------------------------------------------
1484 // "button_release_event"
1485 //-----------------------------------------------------------------------------
1486
1487 static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win )
1488 {
1489 DEBUG_MAIN_THREAD
1490
1491 if (g_isIdle)
1492 wxapp_install_idle_handler();
1493
1494 if (!win->m_hasVMT) return FALSE;
1495 if (g_blockEventsOnDrag) return FALSE;
1496 if (g_blockEventsOnScroll) return FALSE;
1497
1498 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1499
1500 /*
1501 printf( "OnButtonRelease from " );
1502 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1503 printf( win->GetClassInfo()->GetClassName() );
1504 printf( ".\n" );
1505 */
1506
1507 wxEventType event_type = wxEVT_NULL;
1508
1509 switch (gdk_event->button)
1510 {
1511 case 1: event_type = wxEVT_LEFT_UP; break;
1512 case 2: event_type = wxEVT_MIDDLE_UP; break;
1513 case 3: event_type = wxEVT_RIGHT_UP; break;
1514 default: return FALSE;
1515 }
1516
1517 wxMouseEvent event( event_type );
1518 InitMouseEvent( win, event, gdk_event );
1519
1520 AdjustEventButtonState(event);
1521
1522 // same wxListBox hack as above
1523 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1524
1525 if ( !g_captureWindow )
1526 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1527
1528 if (win->GetEventHandler()->ProcessEvent( event ))
1529 {
1530 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
1531 return TRUE;
1532 }
1533
1534 return FALSE;
1535 }
1536
1537 //-----------------------------------------------------------------------------
1538 // "motion_notify_event"
1539 //-----------------------------------------------------------------------------
1540
1541 static gint gtk_window_motion_notify_callback( GtkWidget *widget,
1542 GdkEventMotion *gdk_event,
1543 wxWindowGTK *win )
1544 {
1545 DEBUG_MAIN_THREAD
1546
1547 if (g_isIdle)
1548 wxapp_install_idle_handler();
1549
1550 if (!win->m_hasVMT) return FALSE;
1551 if (g_blockEventsOnDrag) return FALSE;
1552 if (g_blockEventsOnScroll) return FALSE;
1553
1554 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1555
1556 if (gdk_event->is_hint)
1557 {
1558 int x = 0;
1559 int y = 0;
1560 GdkModifierType state;
1561 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1562 gdk_event->x = x;
1563 gdk_event->y = y;
1564 }
1565
1566 /*
1567 printf( "OnMotion from " );
1568 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1569 printf( win->GetClassInfo()->GetClassName() );
1570 printf( ".\n" );
1571 */
1572
1573 wxMouseEvent event( wxEVT_MOTION );
1574 InitMouseEvent(win, event, gdk_event);
1575
1576 if ( g_captureWindow )
1577 {
1578 // synthetize a mouse enter or leave event if needed
1579 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1580 bool hasMouse = winUnderMouse == gdk_event->window;
1581 if ( hasMouse != g_captureWindowHasMouse )
1582 {
1583 // the mouse changed window
1584 g_captureWindowHasMouse = hasMouse;
1585
1586 wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1587 : wxEVT_LEAVE_WINDOW);
1588 InitMouseEvent(win, event, gdk_event);
1589 event.SetEventObject(win);
1590 win->GetEventHandler()->ProcessEvent(event);
1591 }
1592 }
1593 else // no capture
1594 {
1595 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1596 }
1597
1598 if (win->GetEventHandler()->ProcessEvent( event ))
1599 {
1600 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
1601 return TRUE;
1602 }
1603
1604 return FALSE;
1605 }
1606
1607 //-----------------------------------------------------------------------------
1608 // "focus_in_event"
1609 //-----------------------------------------------------------------------------
1610
1611 // send the wxChildFocusEvent and wxFocusEvent, common code of
1612 // gtk_window_focus_in_callback() and SetFocus()
1613 static bool DoSendFocusEvents(wxWindow *win)
1614 {
1615 // Notify the parent keeping track of focus for the kbd navigation
1616 // purposes that we got it.
1617 wxChildFocusEvent eventChildFocus(win);
1618 (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
1619
1620 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1621 eventFocus.SetEventObject(win);
1622
1623 return win->GetEventHandler()->ProcessEvent(eventFocus);
1624 }
1625
1626 static gint gtk_window_focus_in_callback( GtkWidget *widget,
1627 GdkEvent *WXUNUSED(event),
1628 wxWindow *win )
1629 {
1630 DEBUG_MAIN_THREAD
1631
1632 if (g_isIdle)
1633 wxapp_install_idle_handler();
1634
1635 if (!win->m_hasVMT) return FALSE;
1636 if (g_blockEventsOnDrag) return FALSE;
1637
1638 switch ( g_sendActivateEvent )
1639 {
1640 case -1:
1641 // we've got focus from outside, synthetize wxActivateEvent
1642 g_sendActivateEvent = 1;
1643 break;
1644
1645 case 0:
1646 // another our window just lost focus, it was already ours before
1647 // - don't send any wxActivateEvent
1648 g_sendActivateEvent = -1;
1649 break;
1650 }
1651
1652 g_focusWindowLast =
1653 g_focusWindow = win;
1654
1655 wxLogTrace(TRACE_FOCUS,
1656 _T("%s: focus in"), win->GetName().c_str());
1657
1658 #ifdef HAVE_XIM
1659 if (win->m_ic)
1660 gdk_im_begin(win->m_ic, win->m_wxwindow->window);
1661 #endif
1662
1663 #if wxUSE_CARET
1664 // caret needs to be informed about focus change
1665 wxCaret *caret = win->GetCaret();
1666 if ( caret )
1667 {
1668 caret->OnSetFocus();
1669 }
1670 #endif // wxUSE_CARET
1671
1672 g_activeFrameLostFocus = FALSE;
1673
1674 wxWindowGTK *active = wxGetTopLevelParent(win);
1675 if ( active != g_activeFrame )
1676 {
1677 if ( g_activeFrame )
1678 {
1679 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame);
1680 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
1681 event.SetEventObject(g_activeFrame);
1682 g_activeFrame->GetEventHandler()->ProcessEvent(event);
1683 }
1684
1685 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active);
1686 g_activeFrame = active;
1687 wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
1688 event.SetEventObject(g_activeFrame);
1689 g_activeFrame->GetEventHandler()->ProcessEvent(event);
1690
1691 // Don't send focus events in addition to activate
1692 // if (win == g_activeFrame)
1693 // return TRUE;
1694 }
1695
1696 // does the window itself think that it has the focus?
1697 if ( !win->m_hasFocus )
1698 {
1699 // not yet, notify it
1700 win->m_hasFocus = TRUE;
1701
1702 if ( DoSendFocusEvents(win) )
1703 {
1704 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
1705 return TRUE;
1706 }
1707 }
1708
1709 return FALSE;
1710 }
1711
1712 //-----------------------------------------------------------------------------
1713 // "focus_out_event"
1714 //-----------------------------------------------------------------------------
1715
1716 static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
1717 {
1718 DEBUG_MAIN_THREAD
1719
1720 if (g_isIdle)
1721 wxapp_install_idle_handler();
1722
1723 if (!win->m_hasVMT) return FALSE;
1724 if (g_blockEventsOnDrag) return FALSE;
1725
1726 wxLogTrace( TRACE_FOCUS,
1727 _T("%s: focus out"), win->GetName().c_str() );
1728
1729 if ( !g_activeFrameLostFocus && g_activeFrame )
1730 {
1731 // VZ: commenting this out because it does happen (although not easy
1732 // to reproduce, I only see it when using wxMiniFrame and not
1733 // always) and makes using Mahogany quite annoying
1734 #if 0
1735 wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame,
1736 wxT("unfocusing window that hasn't gained focus properly") );
1737 #endif // 0
1738
1739 g_activeFrameLostFocus = TRUE;
1740 }
1741
1742 // if the focus goes out of our app alltogether, OnIdle() will send
1743 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
1744 // g_sendActivateEvent to -1
1745 g_sendActivateEvent = 0;
1746
1747 wxWindowGTK *winFocus = wxFindFocusedChild(win);
1748 if ( winFocus )
1749 win = winFocus;
1750
1751 g_focusWindow = (wxWindowGTK *)NULL;
1752
1753 #ifdef HAVE_XIM
1754 if (win->m_ic)
1755 gdk_im_end();
1756 #endif
1757
1758 #if wxUSE_CARET
1759 // caret needs to be informed about focus change
1760 wxCaret *caret = win->GetCaret();
1761 if ( caret )
1762 {
1763 caret->OnKillFocus();
1764 }
1765 #endif // wxUSE_CARET
1766
1767 // don't send the window a kill focus event if it thinks that it doesn't
1768 // have focus already
1769 if ( win->m_hasFocus )
1770 {
1771 win->m_hasFocus = FALSE;
1772
1773 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
1774 event.SetEventObject( win );
1775
1776 if (win->GetEventHandler()->ProcessEvent( event ))
1777 {
1778 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
1779 return TRUE;
1780 }
1781 }
1782
1783 return FALSE;
1784 }
1785
1786 //-----------------------------------------------------------------------------
1787 // "enter_notify_event"
1788 //-----------------------------------------------------------------------------
1789
1790 static
1791 gint gtk_window_enter_callback( GtkWidget *widget,
1792 GdkEventCrossing *gdk_event,
1793 wxWindowGTK *win )
1794 {
1795 DEBUG_MAIN_THREAD
1796
1797 if (g_isIdle)
1798 wxapp_install_idle_handler();
1799
1800 if (!win->m_hasVMT) return FALSE;
1801 if (g_blockEventsOnDrag) return FALSE;
1802
1803 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1804
1805 int x = 0;
1806 int y = 0;
1807 GdkModifierType state = (GdkModifierType)0;
1808
1809 gdk_window_get_pointer( widget->window, &x, &y, &state );
1810
1811 wxMouseEvent event( wxEVT_ENTER_WINDOW );
1812 InitMouseEvent(win, event, gdk_event);
1813 wxPoint pt = win->GetClientAreaOrigin();
1814 event.m_x = x + pt.x;
1815 event.m_y = y + pt.y;
1816
1817 if (win->GetEventHandler()->ProcessEvent( event ))
1818 {
1819 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
1820 return TRUE;
1821 }
1822
1823 return FALSE;
1824 }
1825
1826 //-----------------------------------------------------------------------------
1827 // "leave_notify_event"
1828 //-----------------------------------------------------------------------------
1829
1830 static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
1831 {
1832 DEBUG_MAIN_THREAD
1833
1834 if (g_isIdle)
1835 wxapp_install_idle_handler();
1836
1837 if (!win->m_hasVMT) return FALSE;
1838 if (g_blockEventsOnDrag) return FALSE;
1839
1840 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1841
1842 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1843 event.SetTimestamp( gdk_event->time );
1844 event.SetEventObject( win );
1845
1846 int x = 0;
1847 int y = 0;
1848 GdkModifierType state = (GdkModifierType)0;
1849
1850 gdk_window_get_pointer( widget->window, &x, &y, &state );
1851
1852 event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
1853 event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
1854 event.m_altDown = (state & GDK_MOD1_MASK) != 0;
1855 event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
1856 event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
1857 event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
1858 event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
1859
1860 wxPoint pt = win->GetClientAreaOrigin();
1861 event.m_x = x + pt.x;
1862 event.m_y = y + pt.y;
1863
1864 if (win->GetEventHandler()->ProcessEvent( event ))
1865 {
1866 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
1867 return TRUE;
1868 }
1869
1870 return FALSE;
1871 }
1872
1873 //-----------------------------------------------------------------------------
1874 // "value_changed" from m_vAdjust
1875 //-----------------------------------------------------------------------------
1876
1877 static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
1878 SCROLLBAR_CBACK_ARG
1879 wxWindowGTK *win )
1880 {
1881 DEBUG_MAIN_THREAD
1882
1883 if (g_isIdle)
1884 wxapp_install_idle_handler();
1885
1886 if (g_blockEventsOnDrag) return;
1887
1888 if (!win->m_hasVMT) return;
1889
1890 float diff = adjust->value - win->m_oldVerticalPos;
1891 if (fabs(diff) < 0.2) return;
1892
1893 win->m_oldVerticalPos = adjust->value;
1894
1895 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
1896 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
1897
1898 int value = (int)(adjust->value+0.5);
1899
1900 wxScrollWinEvent event( command, value, wxVERTICAL );
1901 event.SetEventObject( win );
1902 win->GetEventHandler()->ProcessEvent( event );
1903 }
1904
1905 //-----------------------------------------------------------------------------
1906 // "value_changed" from m_hAdjust
1907 //-----------------------------------------------------------------------------
1908
1909 static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
1910 SCROLLBAR_CBACK_ARG
1911 wxWindowGTK *win )
1912 {
1913 DEBUG_MAIN_THREAD
1914
1915 if (g_isIdle)
1916 wxapp_install_idle_handler();
1917
1918 if (g_blockEventsOnDrag) return;
1919 if (!win->m_hasVMT) return;
1920
1921 float diff = adjust->value - win->m_oldHorizontalPos;
1922 if (fabs(diff) < 0.2) return;
1923
1924 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
1925 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
1926
1927 win->m_oldHorizontalPos = adjust->value;
1928
1929 int value = (int)(adjust->value+0.5);
1930
1931 wxScrollWinEvent event( command, value, wxHORIZONTAL );
1932 event.SetEventObject( win );
1933 win->GetEventHandler()->ProcessEvent( event );
1934 }
1935
1936 //-----------------------------------------------------------------------------
1937 // "button_press_event" from scrollbar
1938 //-----------------------------------------------------------------------------
1939
1940 static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
1941 GdkEventButton *gdk_event,
1942 wxWindowGTK *win)
1943 {
1944 DEBUG_MAIN_THREAD
1945
1946 if (g_isIdle)
1947 wxapp_install_idle_handler();
1948
1949
1950 g_blockEventsOnScroll = TRUE;
1951
1952 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
1953 #ifndef __WXGTK20__
1954 win->m_isScrolling = (gdk_event->window == widget->slider);
1955 #endif
1956
1957 return FALSE;
1958 }
1959
1960 //-----------------------------------------------------------------------------
1961 // "button_release_event" from scrollbar
1962 //-----------------------------------------------------------------------------
1963
1964 static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
1965 GdkEventButton *WXUNUSED(gdk_event),
1966 wxWindowGTK *win)
1967 {
1968 DEBUG_MAIN_THREAD
1969
1970 // don't test here as we can release the mouse while being over
1971 // a different window than the slider
1972 //
1973 // if (gdk_event->window != widget->slider) return FALSE;
1974
1975 g_blockEventsOnScroll = FALSE;
1976
1977 if (win->m_isScrolling)
1978 {
1979 wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
1980 int value = -1;
1981 int dir = -1;
1982
1983 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
1984 if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
1985 {
1986 value = (int)(win->m_hAdjust->value+0.5);
1987 dir = wxHORIZONTAL;
1988 }
1989 if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
1990 {
1991 value = (int)(win->m_vAdjust->value+0.5);
1992 dir = wxVERTICAL;
1993 }
1994
1995 wxScrollWinEvent event( command, value, dir );
1996 event.SetEventObject( win );
1997 win->GetEventHandler()->ProcessEvent( event );
1998 }
1999
2000 win->m_isScrolling = FALSE;
2001
2002 return FALSE;
2003 }
2004
2005 // ----------------------------------------------------------------------------
2006 // this wxWindowBase function is implemented here (in platform-specific file)
2007 // because it is static and so couldn't be made virtual
2008 // ----------------------------------------------------------------------------
2009
2010 wxWindow *wxWindowBase::FindFocus()
2011 {
2012 // the cast is necessary when we compile in wxUniversal mode
2013 return (wxWindow *)g_focusWindow;
2014 }
2015
2016 //-----------------------------------------------------------------------------
2017 // "destroy" event
2018 //-----------------------------------------------------------------------------
2019
2020 // VZ: Robert commented the code using out so it generates warnings: should
2021 // be either fixed or removed completely
2022 #if 0
2023
2024 static void gtk_window_destroy_callback( GtkWidget* widget, wxWindow *win )
2025 {
2026 wxWindowDestroyEvent event(win);
2027 win->GetEventHandler()->ProcessEvent(event);
2028 }
2029
2030 #endif // 0
2031
2032 //-----------------------------------------------------------------------------
2033 // "realize" from m_widget
2034 //-----------------------------------------------------------------------------
2035
2036 /* We cannot set colours and fonts before the widget has
2037 been realized, so we do this directly after realization. */
2038
2039 static gint
2040 gtk_window_realized_callback( GtkWidget *WXUNUSED(m_widget), wxWindow *win )
2041 {
2042 DEBUG_MAIN_THREAD
2043
2044 if (g_isIdle)
2045 wxapp_install_idle_handler();
2046
2047 if (win->m_delayedBackgroundColour)
2048 win->GtkSetBackgroundColour( win->GetBackgroundColour() );
2049
2050 if (win->m_delayedForegroundColour)
2051 win->GtkSetForegroundColour( win->GetForegroundColour() );
2052
2053 wxWindowCreateEvent event( win );
2054 event.SetEventObject( win );
2055 win->GetEventHandler()->ProcessEvent( event );
2056
2057 return FALSE;
2058 }
2059
2060 //-----------------------------------------------------------------------------
2061 // "size_allocate"
2062 //-----------------------------------------------------------------------------
2063
2064 static
2065 void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2066 GtkAllocation *WXUNUSED(alloc),
2067 wxWindow *win )
2068 {
2069 if (g_isIdle)
2070 wxapp_install_idle_handler();
2071
2072 if (!win->m_hasScrolling) return;
2073
2074 int client_width = 0;
2075 int client_height = 0;
2076 win->GetClientSize( &client_width, &client_height );
2077 if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2078 return;
2079
2080 win->m_oldClientWidth = client_width;
2081 win->m_oldClientHeight = client_height;
2082
2083 if (!win->m_nativeSizeEvent)
2084 {
2085 wxSizeEvent event( win->GetSize(), win->GetId() );
2086 event.SetEventObject( win );
2087 win->GetEventHandler()->ProcessEvent( event );
2088 }
2089 }
2090
2091
2092 #ifdef HAVE_XIM
2093 #define WXUNUSED_UNLESS_XIM(param) param
2094 #else
2095 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2096 #endif
2097
2098 /* Resize XIM window */
2099
2100 static
2101 void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2102 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
2103 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
2104 {
2105 if (g_isIdle)
2106 wxapp_install_idle_handler();
2107
2108 #ifdef HAVE_XIM
2109 if (!win->m_ic)
2110 return;
2111
2112 if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2113 {
2114 gint width, height;
2115
2116 gdk_window_get_size (widget->window, &width, &height);
2117 win->m_icattr->preedit_area.width = width;
2118 win->m_icattr->preedit_area.height = height;
2119 gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2120 }
2121 #endif // HAVE_XIM
2122 }
2123
2124 //-----------------------------------------------------------------------------
2125 // "realize" from m_wxwindow
2126 //-----------------------------------------------------------------------------
2127
2128 /* Initialize XIM support */
2129
2130 static gint
2131 gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
2132 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
2133 {
2134 if (g_isIdle)
2135 wxapp_install_idle_handler();
2136
2137 #ifdef HAVE_XIM
2138 if (win->m_ic) return FALSE;
2139 if (!widget) return FALSE;
2140 if (!gdk_im_ready()) return FALSE;
2141
2142 win->m_icattr = gdk_ic_attr_new();
2143 if (!win->m_icattr) return FALSE;
2144
2145 gint width, height;
2146 GdkEventMask mask;
2147 GdkColormap *colormap;
2148 GdkICAttr *attr = win->m_icattr;
2149 unsigned attrmask = GDK_IC_ALL_REQ;
2150 GdkIMStyle style;
2151 GdkIMStyle supported_style = (GdkIMStyle)
2152 (GDK_IM_PREEDIT_NONE |
2153 GDK_IM_PREEDIT_NOTHING |
2154 GDK_IM_PREEDIT_POSITION |
2155 GDK_IM_STATUS_NONE |
2156 GDK_IM_STATUS_NOTHING);
2157
2158 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2159 supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
2160
2161 attr->style = style = gdk_im_decide_style (supported_style);
2162 attr->client_window = widget->window;
2163
2164 if ((colormap = gtk_widget_get_colormap (widget)) !=
2165 gtk_widget_get_default_colormap ())
2166 {
2167 attrmask |= GDK_IC_PREEDIT_COLORMAP;
2168 attr->preedit_colormap = colormap;
2169 }
2170
2171 attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2172 attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2173 attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2174 attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2175
2176 switch (style & GDK_IM_PREEDIT_MASK)
2177 {
2178 case GDK_IM_PREEDIT_POSITION:
2179 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2180 {
2181 g_warning ("over-the-spot style requires fontset");
2182 break;
2183 }
2184
2185 gdk_window_get_size (widget->window, &width, &height);
2186
2187 attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2188 attr->spot_location.x = 0;
2189 attr->spot_location.y = height;
2190 attr->preedit_area.x = 0;
2191 attr->preedit_area.y = 0;
2192 attr->preedit_area.width = width;
2193 attr->preedit_area.height = height;
2194 attr->preedit_fontset = widget->style->font;
2195
2196 break;
2197 }
2198
2199 win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2200
2201 if (win->m_ic == NULL)
2202 g_warning ("Can't create input context.");
2203 else
2204 {
2205 mask = gdk_window_get_events (widget->window);
2206 mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2207 gdk_window_set_events (widget->window, mask);
2208
2209 if (GTK_WIDGET_HAS_FOCUS(widget))
2210 gdk_im_begin (win->m_ic, widget->window);
2211 }
2212 #endif // HAVE_XIM
2213
2214 return FALSE;
2215 }
2216
2217 //-----------------------------------------------------------------------------
2218 // InsertChild for wxWindowGTK.
2219 //-----------------------------------------------------------------------------
2220
2221 /* Callback for wxWindowGTK. This very strange beast has to be used because
2222 * C++ has no virtual methods in a constructor. We have to emulate a
2223 * virtual function here as wxNotebook requires a different way to insert
2224 * a child in it. I had opted for creating a wxNotebookPage window class
2225 * which would have made this superfluous (such in the MDI window system),
2226 * but no-one was listening to me... */
2227
2228 static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
2229 {
2230 /* the window might have been scrolled already, do we
2231 have to adapt the position */
2232 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2233 child->m_x += pizza->xoffset;
2234 child->m_y += pizza->yoffset;
2235
2236 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
2237 GTK_WIDGET(child->m_widget),
2238 child->m_x,
2239 child->m_y,
2240 child->m_width,
2241 child->m_height );
2242 }
2243
2244 //-----------------------------------------------------------------------------
2245 // global functions
2246 //-----------------------------------------------------------------------------
2247
2248 wxWindow *wxGetActiveWindow()
2249 {
2250 return wxWindow::FindFocus();
2251 }
2252
2253 //-----------------------------------------------------------------------------
2254 // wxWindowGTK
2255 //-----------------------------------------------------------------------------
2256
2257 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2258 // method
2259 #ifdef __WXUNIVERSAL__
2260 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2261 #else // __WXGTK__
2262 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
2263 #endif // __WXUNIVERSAL__/__WXGTK__
2264
2265 void wxWindowGTK::Init()
2266 {
2267 // common init
2268 InitBase();
2269
2270 // GTK specific
2271 m_widget = (GtkWidget *) NULL;
2272 m_wxwindow = (GtkWidget *) NULL;
2273 m_focusWidget = (GtkWidget *) NULL;
2274
2275 // position/size
2276 m_x = 0;
2277 m_y = 0;
2278 m_width = 0;
2279 m_height = 0;
2280
2281 m_sizeSet = FALSE;
2282 m_hasVMT = FALSE;
2283 m_needParent = TRUE;
2284 m_isBeingDeleted = FALSE;
2285
2286 m_noExpose = FALSE;
2287 m_nativeSizeEvent = FALSE;
2288
2289 m_hasScrolling = FALSE;
2290 m_isScrolling = FALSE;
2291
2292 m_hAdjust = (GtkAdjustment*) NULL;
2293 m_vAdjust = (GtkAdjustment*) NULL;
2294 m_oldHorizontalPos = 0.0;
2295 m_oldVerticalPos = 0.0;
2296
2297 m_resizing = FALSE;
2298 m_widgetStyle = (GtkStyle*) NULL;
2299
2300 m_insertCallback = (wxInsertChildFunction) NULL;
2301
2302 m_acceptsFocus = FALSE;
2303 m_hasFocus = FALSE;
2304
2305 m_clipPaintRegion = FALSE;
2306
2307 m_cursor = *wxSTANDARD_CURSOR;
2308
2309 m_delayedForegroundColour = FALSE;
2310 m_delayedBackgroundColour = FALSE;
2311
2312 #ifdef HAVE_XIM
2313 m_ic = (GdkIC*) NULL;
2314 m_icattr = (GdkICAttr*) NULL;
2315 #endif
2316 }
2317
2318 wxWindowGTK::wxWindowGTK()
2319 {
2320 Init();
2321 }
2322
2323 wxWindowGTK::wxWindowGTK( wxWindow *parent,
2324 wxWindowID id,
2325 const wxPoint &pos,
2326 const wxSize &size,
2327 long style,
2328 const wxString &name )
2329 {
2330 Init();
2331
2332 Create( parent, id, pos, size, style, name );
2333 }
2334
2335 bool wxWindowGTK::Create( wxWindow *parent,
2336 wxWindowID id,
2337 const wxPoint &pos,
2338 const wxSize &size,
2339 long style,
2340 const wxString &name )
2341 {
2342 if (!PreCreation( parent, pos, size ) ||
2343 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2344 {
2345 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2346 return FALSE;
2347 }
2348
2349 m_insertCallback = wxInsertChildInWindow;
2350
2351 // always needed for background clearing
2352 m_delayedBackgroundColour = TRUE;
2353
2354 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
2355 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
2356
2357 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2358
2359 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2360 scroll_class->scrollbar_spacing = 0;
2361
2362 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2363
2364 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2365 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
2366
2367 m_wxwindow = gtk_pizza_new();
2368
2369 #ifndef __WXUNIVERSAL__
2370 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2371
2372 if (HasFlag(wxRAISED_BORDER))
2373 {
2374 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
2375 }
2376 else if (HasFlag(wxSUNKEN_BORDER))
2377 {
2378 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
2379 }
2380 else if (HasFlag(wxSIMPLE_BORDER))
2381 {
2382 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
2383 }
2384 else
2385 {
2386 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
2387 }
2388 #endif // __WXUNIVERSAL__
2389
2390 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2391
2392 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2393 m_acceptsFocus = TRUE;
2394
2395 // I _really_ don't want scrollbars in the beginning
2396 m_vAdjust->lower = 0.0;
2397 m_vAdjust->upper = 1.0;
2398 m_vAdjust->value = 0.0;
2399 m_vAdjust->step_increment = 1.0;
2400 m_vAdjust->page_increment = 1.0;
2401 m_vAdjust->page_size = 5.0;
2402 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2403 m_hAdjust->lower = 0.0;
2404 m_hAdjust->upper = 1.0;
2405 m_hAdjust->value = 0.0;
2406 m_hAdjust->step_increment = 1.0;
2407 m_hAdjust->page_increment = 1.0;
2408 m_hAdjust->page_size = 5.0;
2409 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2410
2411 // these handlers block mouse events to any window during scrolling such as
2412 // motion events and prevent GTK and wxWindows from fighting over where the
2413 // slider should be
2414
2415 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
2416 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2417
2418 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
2419 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2420
2421 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
2422 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2423
2424 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
2425 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2426
2427 // these handlers get notified when screen updates are required either when
2428 // scrolling or when the window size (and therefore scrollbar configuration)
2429 // has changed
2430
2431 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2432 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2433 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2434 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2435
2436 gtk_widget_show( m_wxwindow );
2437
2438 if (m_parent)
2439 m_parent->DoAddChild( this );
2440
2441 m_focusWidget = m_wxwindow;
2442
2443 PostCreation();
2444
2445 Show( TRUE );
2446
2447 return TRUE;
2448 }
2449
2450 wxWindowGTK::~wxWindowGTK()
2451 {
2452 if (g_focusWindow == this)
2453 g_focusWindow = NULL;
2454
2455 if (g_activeFrame == this)
2456 g_activeFrame = NULL;
2457
2458 if ( g_delayedFocus == this )
2459 g_delayedFocus = NULL;
2460
2461 m_isBeingDeleted = TRUE;
2462 m_hasVMT = FALSE;
2463
2464 if (m_widget)
2465 Show( FALSE );
2466
2467 DestroyChildren();
2468
2469 if (m_parent)
2470 m_parent->RemoveChild( this );
2471
2472 #ifdef HAVE_XIM
2473 if (m_ic)
2474 gdk_ic_destroy (m_ic);
2475 if (m_icattr)
2476 gdk_ic_attr_destroy (m_icattr);
2477 #endif
2478
2479 if (m_widgetStyle)
2480 {
2481 #if DISABLE_STYLE_IF_BROKEN_THEME
2482 // don't delete if it's a pixmap theme style
2483 if (!m_widgetStyle->engine_data)
2484 gtk_style_unref( m_widgetStyle );
2485 #endif
2486 m_widgetStyle = (GtkStyle*) NULL;
2487 }
2488
2489 if (m_wxwindow)
2490 {
2491 gtk_widget_destroy( m_wxwindow );
2492 m_wxwindow = (GtkWidget*) NULL;
2493 }
2494
2495 if (m_widget)
2496 {
2497 gtk_widget_destroy( m_widget );
2498 m_widget = (GtkWidget*) NULL;
2499 }
2500 }
2501
2502 bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2503 {
2504 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
2505
2506 /* this turns -1 into 20 so that a minimal window is
2507 visible even although -1,-1 has been given as the
2508 size of the window. the same trick is used in other
2509 ports and should make debugging easier */
2510 m_width = WidthDefault(size.x);
2511 m_height = HeightDefault(size.y);
2512
2513 m_x = (int)pos.x;
2514 m_y = (int)pos.y;
2515
2516 /* some reasonable defaults */
2517 if (!parent)
2518 {
2519 if (m_x == -1)
2520 {
2521 m_x = (gdk_screen_width () - m_width) / 2;
2522 if (m_x < 10) m_x = 10;
2523 }
2524 if (m_y == -1)
2525 {
2526 m_y = (gdk_screen_height () - m_height) / 2;
2527 if (m_y < 10) m_y = 10;
2528 }
2529 }
2530
2531 return TRUE;
2532 }
2533
2534 void wxWindowGTK::PostCreation()
2535 {
2536 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2537
2538 if (m_wxwindow)
2539 {
2540 if (!m_noExpose)
2541 {
2542 // these get reported to wxWindows -> wxPaintEvent
2543
2544 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2545
2546 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2547 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2548
2549 #ifndef __WXGTK20__
2550 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2551 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
2552
2553 if (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE))
2554 {
2555 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2556 GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2557 }
2558 #else
2559 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ) );
2560 #endif
2561 }
2562
2563 // these are called when the "sunken" or "raised" borders are drawn
2564 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2565 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2566
2567 #ifndef __WXGTK20__
2568 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2569 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
2570 #endif
2571 }
2572
2573 // focus handling
2574
2575 if (m_focusWidget == NULL)
2576 m_focusWidget = m_widget;
2577
2578 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2579 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2580
2581 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
2582 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2583
2584 // connect to the various key and mouse handlers
2585
2586 GtkWidget *connect_widget = GetConnectWidget();
2587
2588 ConnectWidget( connect_widget );
2589
2590 /* We cannot set colours, fonts and cursors before the widget has
2591 been realized, so we do this directly after realization */
2592 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
2593 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2594
2595 if (m_wxwindow)
2596 {
2597 // Catch native resize events
2598 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2599 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2600
2601 // Initialize XIM support
2602 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2603 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
2604
2605 // And resize XIM window
2606 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2607 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
2608 }
2609
2610 if (!GTK_IS_COMBO(m_widget))
2611 {
2612 // This is needed if we want to add our windows into native
2613 // GTK control, such as the toolbar. With this callback, the
2614 // toolbar gets to know the correct size (the one set by the
2615 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2616 // when moving to GTK 2.0.
2617 gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
2618 GTK_SIGNAL_FUNC(gtk_window_size_request_callback), (gpointer) this );
2619 }
2620
2621 m_hasVMT = TRUE;
2622 }
2623
2624 void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2625 {
2626 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2627 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
2628
2629 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2630 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2631
2632 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2633 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2634
2635 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2636 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2637
2638 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2639 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2640
2641 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2642 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2643
2644 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2645 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2646
2647 // This keeps crashing on me. RR.
2648 //
2649 // gtk_signal_connect( GTK_OBJECT(widget), "destroy",
2650 // GTK_SIGNAL_FUNC(gtk_window_destroy_callback), (gpointer)this );
2651 }
2652
2653 bool wxWindowGTK::Destroy()
2654 {
2655 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2656
2657 m_hasVMT = FALSE;
2658
2659 return wxWindowBase::Destroy();
2660 }
2661
2662 void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2663 {
2664 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2665 }
2666
2667 void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2668 {
2669 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2670 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2671
2672 /*
2673 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2674 */
2675
2676 if (m_resizing) return; /* I don't like recursions */
2677 m_resizing = TRUE;
2678
2679 int currentX, currentY;
2680 GetPosition(&currentX, &currentY);
2681 if (x == -1)
2682 x = currentX;
2683 if (y == -1)
2684 y = currentY;
2685 AdjustForParentClientOrigin(x, y, sizeFlags);
2686
2687 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
2688 {
2689 /* don't set the size for children of wxNotebook, just take the values. */
2690 m_x = x;
2691 m_y = y;
2692 m_width = width;
2693 m_height = height;
2694 }
2695 else
2696 {
2697 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2698 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2699 {
2700 if (x != -1) m_x = x + pizza->xoffset;
2701 if (y != -1) m_y = y + pizza->yoffset;
2702 if (width != -1) m_width = width;
2703 if (height != -1) m_height = height;
2704 }
2705 else
2706 {
2707 m_x = x + pizza->xoffset;
2708 m_y = y + pizza->yoffset;
2709 m_width = width;
2710 m_height = height;
2711 }
2712
2713 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
2714 {
2715 if (width == -1) m_width = 80;
2716 }
2717
2718 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
2719 {
2720 if (height == -1) m_height = 26;
2721 }
2722
2723 int minWidth = GetMinWidth(),
2724 minHeight = GetMinHeight(),
2725 maxWidth = GetMaxWidth(),
2726 maxHeight = GetMaxHeight();
2727
2728 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
2729 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
2730 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
2731 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
2732
2733 int border = 0;
2734 int bottom_border = 0;
2735
2736 #ifndef __WXGTK20__
2737 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2738 {
2739 /* the default button has a border around it */
2740 border = 6;
2741 bottom_border = 5;
2742 }
2743 #endif
2744
2745 DoMoveWindow( m_x-border,
2746 m_y-border,
2747 m_width+2*border,
2748 m_height+border+bottom_border );
2749 }
2750
2751 if (m_hasScrolling)
2752 {
2753 /* Sometimes the client area changes size without the
2754 whole windows's size changing, but if the whole
2755 windows's size doesn't change, no wxSizeEvent will
2756 normally be sent. Here we add an extra test if
2757 the client test has been changed and this will
2758 be used then. */
2759 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2760 }
2761
2762 /*
2763 wxPrintf( "OnSize sent from " );
2764 if (GetClassInfo() && GetClassInfo()->GetClassName())
2765 wxPrintf( GetClassInfo()->GetClassName() );
2766 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2767 */
2768
2769 if (!m_nativeSizeEvent)
2770 {
2771 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2772 event.SetEventObject( this );
2773 GetEventHandler()->ProcessEvent( event );
2774 }
2775
2776 m_resizing = FALSE;
2777 }
2778
2779 void wxWindowGTK::OnInternalIdle()
2780 {
2781 // Update invalidated regions.
2782 GtkUpdate();
2783
2784 // Synthetize activate events.
2785 if ( g_sendActivateEvent != -1 )
2786 {
2787 bool activate = g_sendActivateEvent != 0;
2788
2789 // do it only once
2790 g_sendActivateEvent = -1;
2791
2792 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
2793 }
2794
2795 if ( g_activeFrameLostFocus )
2796 {
2797 if ( g_activeFrame )
2798 {
2799 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
2800 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
2801 event.SetEventObject(g_activeFrame);
2802 g_activeFrame->GetEventHandler()->ProcessEvent(event);
2803 g_activeFrame = NULL;
2804 }
2805 g_activeFrameLostFocus = FALSE;
2806 }
2807
2808 wxCursor cursor = m_cursor;
2809 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2810
2811 if (cursor.Ok())
2812 {
2813 /* I now set the cursor anew in every OnInternalIdle call
2814 as setting the cursor in a parent window also effects the
2815 windows above so that checking for the current cursor is
2816 not possible. */
2817
2818 if (m_wxwindow)
2819 {
2820 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
2821 if (window)
2822 gdk_window_set_cursor( window, cursor.GetCursor() );
2823
2824 if (!g_globalCursor.Ok())
2825 cursor = *wxSTANDARD_CURSOR;
2826
2827 window = m_widget->window;
2828 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2829 gdk_window_set_cursor( window, cursor.GetCursor() );
2830
2831 }
2832 else
2833 {
2834
2835 GdkWindow *window = m_widget->window;
2836 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2837 gdk_window_set_cursor( window, cursor.GetCursor() );
2838
2839 }
2840 }
2841
2842 UpdateWindowUI();
2843 }
2844
2845 void wxWindowGTK::DoGetSize( int *width, int *height ) const
2846 {
2847 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2848
2849 if (width) (*width) = m_width;
2850 if (height) (*height) = m_height;
2851 }
2852
2853 void wxWindowGTK::DoSetClientSize( int width, int height )
2854 {
2855 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2856
2857 if (!m_wxwindow)
2858 {
2859 SetSize( width, height );
2860 }
2861 else
2862 {
2863 int dw = 0;
2864 int dh = 0;
2865
2866 #ifndef __WXUNIVERSAL__
2867 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2868 {
2869 /* when using GTK 1.2 we set the shadow border size to 2 */
2870 dw += 2 * 2;
2871 dh += 2 * 2;
2872 }
2873 if (HasFlag(wxSIMPLE_BORDER))
2874 {
2875 /* when using GTK 1.2 we set the simple border size to 1 */
2876 dw += 1 * 2;
2877 dh += 1 * 2;
2878 }
2879 #endif // __WXUNIVERSAL__
2880
2881 if (m_hasScrolling)
2882 {
2883 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2884
2885 GtkRequisition vscroll_req;
2886 vscroll_req.width = 2;
2887 vscroll_req.height = 2;
2888 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
2889 (scroll_window->vscrollbar, &vscroll_req );
2890
2891 GtkRequisition hscroll_req;
2892 hscroll_req.width = 2;
2893 hscroll_req.height = 2;
2894 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
2895 (scroll_window->hscrollbar, &hscroll_req );
2896
2897 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2898
2899 if (scroll_window->vscrollbar_visible)
2900 {
2901 dw += vscroll_req.width;
2902 dw += scroll_class->scrollbar_spacing;
2903 }
2904
2905 if (scroll_window->hscrollbar_visible)
2906 {
2907 dh += hscroll_req.height;
2908 dh += scroll_class->scrollbar_spacing;
2909 }
2910 }
2911
2912 SetSize( width+dw, height+dh );
2913 }
2914 }
2915
2916 void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2917 {
2918 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2919
2920 if (!m_wxwindow)
2921 {
2922 if (width) (*width) = m_width;
2923 if (height) (*height) = m_height;
2924 }
2925 else
2926 {
2927 int dw = 0;
2928 int dh = 0;
2929
2930 #ifndef __WXUNIVERSAL__
2931 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2932 {
2933 /* when using GTK 1.2 we set the shadow border size to 2 */
2934 dw += 2 * 2;
2935 dh += 2 * 2;
2936 }
2937 if (HasFlag(wxSIMPLE_BORDER))
2938 {
2939 /* when using GTK 1.2 we set the simple border size to 1 */
2940 dw += 1 * 2;
2941 dh += 1 * 2;
2942 }
2943 #endif // __WXUNIVERSAL__
2944
2945 if (m_hasScrolling)
2946 {
2947 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2948
2949 GtkRequisition vscroll_req;
2950 vscroll_req.width = 2;
2951 vscroll_req.height = 2;
2952 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
2953 (scroll_window->vscrollbar, &vscroll_req );
2954
2955 GtkRequisition hscroll_req;
2956 hscroll_req.width = 2;
2957 hscroll_req.height = 2;
2958 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
2959 (scroll_window->hscrollbar, &hscroll_req );
2960
2961 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2962
2963 if (scroll_window->vscrollbar_visible)
2964 {
2965 dw += vscroll_req.width;
2966 dw += scroll_class->scrollbar_spacing;
2967 }
2968
2969 if (scroll_window->hscrollbar_visible)
2970 {
2971 dh += hscroll_req.height;
2972 dh += scroll_class->scrollbar_spacing;
2973 }
2974 }
2975
2976 if (width) (*width) = m_width - dw;
2977 if (height) (*height) = m_height - dh;
2978 }
2979
2980 /*
2981 printf( "GetClientSize, name %s ", GetName().c_str() );
2982 if (width) printf( " width = %d", (*width) );
2983 if (height) printf( " height = %d", (*height) );
2984 printf( "\n" );
2985 */
2986 }
2987
2988 void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2989 {
2990 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2991
2992 int dx = 0;
2993 int dy = 0;
2994 if (m_parent && m_parent->m_wxwindow)
2995 {
2996 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2997 dx = pizza->xoffset;
2998 dy = pizza->yoffset;
2999 }
3000
3001 if (x) (*x) = m_x - dx;
3002 if (y) (*y) = m_y - dy;
3003 }
3004
3005 void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
3006 {
3007 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3008
3009 if (!m_widget->window) return;
3010
3011 GdkWindow *source = (GdkWindow *) NULL;
3012 if (m_wxwindow)
3013 source = GTK_PIZZA(m_wxwindow)->bin_window;
3014 else
3015 source = m_widget->window;
3016
3017 int org_x = 0;
3018 int org_y = 0;
3019 gdk_window_get_origin( source, &org_x, &org_y );
3020
3021 if (!m_wxwindow)
3022 {
3023 if (GTK_WIDGET_NO_WINDOW (m_widget))
3024 {
3025 org_x += m_widget->allocation.x;
3026 org_y += m_widget->allocation.y;
3027 }
3028 }
3029
3030 if (x) *x += org_x;
3031 if (y) *y += org_y;
3032 }
3033
3034 void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
3035 {
3036 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3037
3038 if (!m_widget->window) return;
3039
3040 GdkWindow *source = (GdkWindow *) NULL;
3041 if (m_wxwindow)
3042 source = GTK_PIZZA(m_wxwindow)->bin_window;
3043 else
3044 source = m_widget->window;
3045
3046 int org_x = 0;
3047 int org_y = 0;
3048 gdk_window_get_origin( source, &org_x, &org_y );
3049
3050 if (!m_wxwindow)
3051 {
3052 if (GTK_WIDGET_NO_WINDOW (m_widget))
3053 {
3054 org_x += m_widget->allocation.x;
3055 org_y += m_widget->allocation.y;
3056 }
3057 }
3058
3059 if (x) *x -= org_x;
3060 if (y) *y -= org_y;
3061 }
3062
3063 bool wxWindowGTK::Show( bool show )
3064 {
3065 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3066
3067 if (!wxWindowBase::Show(show))
3068 {
3069 // nothing to do
3070 return FALSE;
3071 }
3072
3073 if (show)
3074 gtk_widget_show( m_widget );
3075 else
3076 gtk_widget_hide( m_widget );
3077
3078 return TRUE;
3079 }
3080
3081 static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
3082 {
3083 win->OnParentEnable(enable);
3084
3085 // Recurse, so that children have the opportunity to Do The Right Thing
3086 // and reset colours that have been messed up by a parent's (really ancestor's)
3087 // Enable call
3088 for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
3089 node;
3090 node = node->GetNext() )
3091 {
3092 wxWindow *child = node->GetData();
3093 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3094 wxWindowNotifyEnable(child, enable);
3095 }
3096 }
3097
3098 bool wxWindowGTK::Enable( bool enable )
3099 {
3100 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3101
3102 if (!wxWindowBase::Enable(enable))
3103 {
3104 // nothing to do
3105 return FALSE;
3106 }
3107
3108 gtk_widget_set_sensitive( m_widget, enable );
3109 if ( m_wxwindow )
3110 gtk_widget_set_sensitive( m_wxwindow, enable );
3111
3112 wxWindowNotifyEnable(this, enable);
3113
3114 return TRUE;
3115 }
3116
3117 int wxWindowGTK::GetCharHeight() const
3118 {
3119 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3120
3121 wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
3122
3123 GdkFont *font = m_font.GetInternalFont( 1.0 );
3124
3125 return font->ascent + font->descent;
3126 }
3127
3128 int wxWindowGTK::GetCharWidth() const
3129 {
3130 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3131
3132 wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
3133
3134 GdkFont *font = m_font.GetInternalFont( 1.0 );
3135
3136 return gdk_string_width( font, "H" );
3137 }
3138
3139 void wxWindowGTK::GetTextExtent( const wxString& string,
3140 int *x,
3141 int *y,
3142 int *descent,
3143 int *externalLeading,
3144 const wxFont *theFont ) const
3145 {
3146 wxFont fontToUse = m_font;
3147 if (theFont) fontToUse = *theFont;
3148
3149 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3150
3151 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
3152 if (x) (*x) = gdk_string_width( font, string.mbc_str() );
3153 if (y) (*y) = font->ascent + font->descent;
3154 if (descent) (*descent) = font->descent;
3155 if (externalLeading) (*externalLeading) = 0; // ??
3156 }
3157
3158 void wxWindowGTK::SetFocus()
3159 {
3160 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3161
3162 if ( m_hasFocus )
3163 {
3164 // don't do anything if we already have focus
3165 return;
3166 }
3167
3168 if (m_wxwindow)
3169 {
3170 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3171 {
3172 gtk_widget_grab_focus (m_wxwindow);
3173 }
3174 }
3175 else if (m_widget)
3176 {
3177 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3178 {
3179 if (!GTK_WIDGET_REALIZED(m_widget))
3180 {
3181 // we can't set the focus to the widget now so we remember that
3182 // it should be focused and will do it later, during the idle
3183 // time, as soon as we can
3184 wxLogTrace(TRACE_FOCUS,
3185 _T("Delaying setting focus to %s(%s)"),
3186 GetClassInfo()->GetClassName(), GetLabel().c_str());
3187
3188 g_delayedFocus = this;
3189 }
3190 else
3191 {
3192 wxLogTrace(TRACE_FOCUS,
3193 _T("Setting focus to %s(%s)"),
3194 GetClassInfo()->GetClassName(), GetLabel().c_str());
3195
3196 gtk_widget_grab_focus (m_widget);
3197 }
3198 }
3199 else if (GTK_IS_CONTAINER(m_widget))
3200 {
3201 SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );
3202 }
3203 else
3204 {
3205 wxLogTrace(TRACE_FOCUS,
3206 _T("Can't set focus to %s(%s)"),
3207 GetClassInfo()->GetClassName(), GetLabel().c_str());
3208 }
3209 }
3210 }
3211
3212 bool wxWindowGTK::AcceptsFocus() const
3213 {
3214 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
3215 }
3216
3217 bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3218 {
3219 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3220
3221 wxWindowGTK *oldParent = m_parent,
3222 *newParent = (wxWindowGTK *)newParentBase;
3223
3224 wxASSERT( GTK_IS_WIDGET(m_widget) );
3225
3226 if ( !wxWindowBase::Reparent(newParent) )
3227 return FALSE;
3228
3229 wxASSERT( GTK_IS_WIDGET(m_widget) );
3230
3231 /* prevent GTK from deleting the widget arbitrarily */
3232 gtk_widget_ref( m_widget );
3233
3234 if (oldParent)
3235 {
3236 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3237 }
3238
3239 wxASSERT( GTK_IS_WIDGET(m_widget) );
3240
3241 if (newParent)
3242 {
3243 /* insert GTK representation */
3244 (*(newParent->m_insertCallback))(newParent, this);
3245 }
3246
3247 /* reverse: prevent GTK from deleting the widget arbitrarily */
3248 gtk_widget_unref( m_widget );
3249
3250 return TRUE;
3251 }
3252
3253 void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3254 {
3255 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3256
3257 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3258
3259 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3260
3261 /* add to list */
3262 AddChild( child );
3263
3264 /* insert GTK representation */
3265 (*m_insertCallback)(this, child);
3266 }
3267
3268 void wxWindowGTK::Raise()
3269 {
3270 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3271
3272 if (!m_widget->window) return;
3273
3274 gdk_window_raise( m_widget->window );
3275 }
3276
3277 void wxWindowGTK::Lower()
3278 {
3279 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3280
3281 if (!m_widget->window) return;
3282
3283 gdk_window_lower( m_widget->window );
3284 }
3285
3286 bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3287 {
3288 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3289
3290 if (cursor == m_cursor)
3291 return FALSE;
3292
3293 if (g_isIdle)
3294 wxapp_install_idle_handler();
3295
3296 if (cursor == wxNullCursor)
3297 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3298 else
3299 return wxWindowBase::SetCursor( cursor );
3300 }
3301
3302 void wxWindowGTK::WarpPointer( int x, int y )
3303 {
3304 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3305
3306 // We provide this function ourselves as it is
3307 // missing in GDK (top of this file).
3308
3309 GdkWindow *window = (GdkWindow*) NULL;
3310 if (m_wxwindow)
3311 window = GTK_PIZZA(m_wxwindow)->bin_window;
3312 else
3313 window = GetConnectWidget()->window;
3314
3315 if (window)
3316 gdk_window_warp_pointer( window, x, y );
3317 }
3318
3319 void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3320 {
3321 if (!m_widget) return;
3322 if (!m_widget->window) return;
3323
3324 #ifndef __WXGTK20__
3325 if (g_isIdle)
3326 wxapp_install_idle_handler();
3327
3328 if (eraseBackground && m_wxwindow && m_wxwindow->window)
3329 {
3330 if (rect)
3331 {
3332 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3333 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
3334 }
3335 else
3336 {
3337 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3338 m_clearRegion.Clear();
3339 m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3340 }
3341 }
3342
3343 if (rect)
3344 {
3345 if (m_wxwindow)
3346 {
3347 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3348 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
3349 }
3350 else
3351 {
3352 GdkRectangle gdk_rect;
3353 gdk_rect.x = rect->x;
3354 gdk_rect.y = rect->y;
3355 gdk_rect.width = rect->width;
3356 gdk_rect.height = rect->height;
3357 gtk_widget_draw( m_widget, &gdk_rect );
3358 }
3359 }
3360 else
3361 {
3362 if (m_wxwindow)
3363 {
3364 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3365 m_updateRegion.Clear();
3366 m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3367 }
3368 else
3369 {
3370 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
3371 }
3372 }
3373 #else
3374 if (m_wxwindow)
3375 {
3376 if (rect)
3377 {
3378 GdkRectangle gdk_rect;
3379 gdk_rect.x = rect->x;
3380 gdk_rect.y = rect->y;
3381 gdk_rect.width = rect->width;
3382 gdk_rect.height = rect->height;
3383 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
3384 }
3385 else
3386 {
3387 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
3388 }
3389 }
3390 #endif
3391 }
3392
3393 void wxWindowGTK::Update()
3394 {
3395 GtkUpdate();
3396 }
3397
3398 void wxWindowGTK::GtkUpdate()
3399 {
3400 #ifdef __WXGTK20__
3401 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3402 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
3403 #endif
3404
3405 if (!m_updateRegion.IsEmpty())
3406 GtkSendPaintEvents();
3407 }
3408
3409 void wxWindowGTK::GtkSendPaintEvents()
3410 {
3411 if (!m_wxwindow)
3412 {
3413 m_clearRegion.Clear();
3414 m_updateRegion.Clear();
3415 return;
3416 }
3417
3418 // widget to draw on
3419 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
3420
3421 // Clip to paint region in wxClientDC
3422 m_clipPaintRegion = TRUE;
3423
3424 if (GetThemeEnabled())
3425 {
3426 // find ancestor from which to steal background
3427 wxWindow *parent = GetParent();
3428 while (parent && !parent->IsTopLevel())
3429 parent = parent->GetParent();
3430 if (!parent)
3431 parent = (wxWindow*)this;
3432
3433 wxRegionIterator upd( m_updateRegion );
3434 while (upd)
3435 {
3436 GdkRectangle rect;
3437 rect.x = upd.GetX();
3438 rect.y = upd.GetY();
3439 rect.width = upd.GetWidth();
3440 rect.height = upd.GetHeight();
3441
3442 gtk_paint_flat_box( parent->m_widget->style,
3443 pizza->bin_window,
3444 GTK_STATE_NORMAL,
3445 GTK_SHADOW_NONE,
3446 &rect,
3447 parent->m_widget,
3448 (char *)"base",
3449 0, 0, -1, -1 );
3450
3451 upd ++;
3452 }
3453 }
3454 else
3455 // if (!m_clearRegion.IsEmpty()) // always send an erase event
3456 {
3457 // If the clear region is empty, and the update region isn't,
3458 // then we're going to clear more than we repaint,
3459 // so let's make sure the two regions are in sync.
3460 if (m_clearRegion.IsEmpty() && !m_updateRegion.IsEmpty())
3461 {
3462 m_clearRegion = m_updateRegion ;
3463 }
3464
3465 wxWindowDC dc( (wxWindow*)this );
3466 dc.SetClippingRegion( m_clearRegion );
3467
3468 wxEraseEvent erase_event( GetId(), &dc );
3469 erase_event.SetEventObject( this );
3470
3471 if (!GetEventHandler()->ProcessEvent(erase_event))
3472 {
3473 if (!g_eraseGC)
3474 {
3475 g_eraseGC = gdk_gc_new( pizza->bin_window );
3476 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
3477 }
3478 gdk_gc_set_foreground( g_eraseGC, m_backgroundColour.GetColor() );
3479
3480 wxRegionIterator upd( m_clearRegion );
3481 while (upd)
3482 {
3483 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
3484 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
3485 upd ++;
3486 }
3487 }
3488 m_clearRegion.Clear();
3489 }
3490
3491 wxNcPaintEvent nc_paint_event( GetId() );
3492 nc_paint_event.SetEventObject( this );
3493 GetEventHandler()->ProcessEvent( nc_paint_event );
3494
3495 wxPaintEvent paint_event( GetId() );
3496 paint_event.SetEventObject( this );
3497 GetEventHandler()->ProcessEvent( paint_event );
3498
3499 m_clipPaintRegion = FALSE;
3500
3501 #ifndef __WXUNIVERSAL__
3502 #ifndef __WXGTK20__
3503 // The following code will result in all window-less widgets
3504 // being redrawn because the wxWindows class is allowed to
3505 // paint over the window-less widgets.
3506
3507 GList *children = pizza->children;
3508 while (children)
3509 {
3510 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
3511 children = children->next;
3512
3513 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
3514 GTK_WIDGET_DRAWABLE (child->widget))
3515 {
3516 // Get intersection of widget area and update region
3517 wxRegion region( m_updateRegion );
3518
3519 GdkEventExpose gdk_event;
3520 gdk_event.type = GDK_EXPOSE;
3521 gdk_event.window = pizza->bin_window;
3522 gdk_event.count = 0;
3523
3524 wxRegionIterator upd( m_updateRegion );
3525 while (upd)
3526 {
3527 GdkRectangle rect;
3528 rect.x = upd.GetX();
3529 rect.y = upd.GetY();
3530 rect.width = upd.GetWidth();
3531 rect.height = upd.GetHeight();
3532
3533 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
3534 {
3535 gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
3536 }
3537
3538 upd ++;
3539 }
3540 }
3541 }
3542 #endif
3543 #endif
3544
3545 m_updateRegion.Clear();
3546 }
3547
3548 void wxWindowGTK::Clear()
3549 {
3550 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3551
3552 if (m_wxwindow && m_wxwindow->window)
3553 {
3554 m_clearRegion.Clear();
3555 wxSize size( GetClientSize() );
3556 m_clearRegion.Union( 0,0,size.x,size.y );
3557
3558 // Better do this in idle?
3559 GtkUpdate();
3560 }
3561 }
3562
3563 #if wxUSE_TOOLTIPS
3564 void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3565 {
3566 wxWindowBase::DoSetToolTip(tip);
3567
3568 if (m_tooltip)
3569 m_tooltip->Apply( (wxWindow *)this );
3570 }
3571
3572 void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
3573 {
3574 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
3575 }
3576 #endif // wxUSE_TOOLTIPS
3577
3578 void wxWindowGTK::GtkSetBackgroundColour( const wxColour &colour )
3579 {
3580 GdkWindow *window = (GdkWindow*) NULL;
3581 if (m_wxwindow)
3582 window = GTK_PIZZA(m_wxwindow)->bin_window;
3583 else
3584 window = GetConnectWidget()->window;
3585
3586 wxASSERT( window );
3587
3588 // We need the pixel value e.g. for background clearing.
3589 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
3590
3591 if (m_wxwindow)
3592 {
3593 // wxMSW doesn't clear the window here, either.
3594 gdk_window_set_background( window, m_backgroundColour.GetColor() );
3595 }
3596
3597 ApplyWidgetStyle();
3598 }
3599
3600 bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3601 {
3602 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3603
3604 if (!wxWindowBase::SetBackgroundColour(colour))
3605 return FALSE;
3606
3607 GdkWindow *window = (GdkWindow*) NULL;
3608 if (m_wxwindow)
3609 window = GTK_PIZZA(m_wxwindow)->bin_window;
3610 else
3611 window = GetConnectWidget()->window;
3612
3613 if (!window)
3614 {
3615 // indicate that a new style has been set
3616 // but it couldn't get applied as the
3617 // widget hasn't been realized yet.
3618 m_delayedBackgroundColour = TRUE;
3619 return TRUE;
3620 }
3621 else
3622 {
3623 GtkSetBackgroundColour( colour );
3624 }
3625
3626 return TRUE;
3627 }
3628
3629 void wxWindowGTK::GtkSetForegroundColour( const wxColour &colour )
3630 {
3631 GdkWindow *window = (GdkWindow*) NULL;
3632 if (m_wxwindow)
3633 window = GTK_PIZZA(m_wxwindow)->bin_window;
3634 else
3635 window = GetConnectWidget()->window;
3636
3637 wxASSERT( window );
3638
3639 ApplyWidgetStyle();
3640 }
3641
3642 bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3643 {
3644 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3645
3646 if (!wxWindowBase::SetForegroundColour(colour))
3647 {
3648 // don't leave if the GTK widget has just
3649 // been realized
3650 if (!m_delayedForegroundColour) return FALSE;
3651 }
3652
3653 GdkWindow *window = (GdkWindow*) NULL;
3654 if (m_wxwindow)
3655 window = GTK_PIZZA(m_wxwindow)->bin_window;
3656 else
3657 window = GetConnectWidget()->window;
3658
3659 if (!window)
3660 {
3661 // indicate that a new style has been set
3662 // but it couldn't get applied as the
3663 // widget hasn't been realized yet.
3664 m_delayedForegroundColour = TRUE;
3665 }
3666 else
3667 {
3668 GtkSetForegroundColour( colour );
3669 }
3670
3671 return TRUE;
3672 }
3673
3674 GtkStyle *wxWindowGTK::GetWidgetStyle()
3675 {
3676 if (m_widgetStyle)
3677 {
3678 GtkStyle *remake = gtk_style_copy( m_widgetStyle );
3679
3680 // FIXME: no more klass in 2.0
3681 #ifndef __WXGTK20__
3682 remake->klass = m_widgetStyle->klass;
3683 #endif
3684
3685 gtk_style_unref( m_widgetStyle );
3686 m_widgetStyle = remake;
3687 }
3688 else
3689 {
3690 GtkStyle *def = gtk_rc_get_style( m_widget );
3691
3692 if (!def)
3693 def = gtk_widget_get_default_style();
3694
3695 m_widgetStyle = gtk_style_copy( def );
3696
3697 // FIXME: no more klass in 2.0
3698 #ifndef __WXGTK20__
3699 m_widgetStyle->klass = def->klass;
3700 #endif
3701 }
3702
3703 return m_widgetStyle;
3704 }
3705
3706 void wxWindowGTK::SetWidgetStyle()
3707 {
3708 #if DISABLE_STYLE_IF_BROKEN_THEME
3709 if (m_widget->style->engine_data)
3710 {
3711 static bool s_warningPrinted = FALSE;
3712 if (!s_warningPrinted)
3713 {
3714 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
3715 s_warningPrinted = TRUE;
3716 }
3717 m_widgetStyle = m_widget->style;
3718 return;
3719 }
3720 #endif
3721
3722 GtkStyle *style = GetWidgetStyle();
3723
3724 if (m_font != wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ))
3725 {
3726 SET_STYLE_FONT(style, m_font.GetInternalFont( 1.0 ));
3727 }
3728
3729 if (m_foregroundColour.Ok())
3730 {
3731 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
3732 if (m_foregroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT))
3733 {
3734 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
3735 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
3736 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
3737 }
3738 else
3739 {
3740 // Try to restore the gtk default style. This is still a little
3741 // oversimplified for what is probably really needed here for controls
3742 // other than buttons, but is better than not being able to (re)set a
3743 // control's foreground colour to *wxBLACK -- RL
3744 GtkStyle *def = gtk_rc_get_style( m_widget );
3745
3746 if (!def)
3747 def = gtk_widget_get_default_style();
3748
3749 style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
3750 style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
3751 style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
3752 }
3753 }
3754
3755 if (m_backgroundColour.Ok())
3756 {
3757 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
3758 if (m_backgroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE))
3759 {
3760 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
3761 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
3762 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
3763 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
3764 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
3765 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
3766 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
3767 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
3768 }
3769 else
3770 {
3771 // Try to restore the gtk default style. This is still a little
3772 // oversimplified for what is probably really needed here for controls
3773 // other than buttons, but is better than not being able to (re)set a
3774 // control's background colour to default grey and means resetting a
3775 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
3776 // behavior -- RL
3777 GtkStyle *def = gtk_rc_get_style( m_widget );
3778
3779 if (!def)
3780 def = gtk_widget_get_default_style();
3781
3782 style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
3783 style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
3784 style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
3785 style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
3786 style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
3787 style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
3788 style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
3789 style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
3790 }
3791 }
3792 }
3793
3794 void wxWindowGTK::ApplyWidgetStyle()
3795 {
3796 }
3797
3798 //-----------------------------------------------------------------------------
3799 // Pop-up menu stuff
3800 //-----------------------------------------------------------------------------
3801
3802 #if wxUSE_MENUS_NATIVE
3803
3804 extern "C"
3805 void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
3806 {
3807 *is_waiting = FALSE;
3808 }
3809
3810 static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
3811 {
3812 menu->SetInvokingWindow( win );
3813 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
3814 while (node)
3815 {
3816 wxMenuItem *menuitem = node->GetData();
3817 if (menuitem->IsSubMenu())
3818 {
3819 SetInvokingWindow( menuitem->GetSubMenu(), win );
3820 }
3821
3822 node = node->GetNext();
3823 }
3824 }
3825
3826 // used to pass the coordinates from wxWindowGTK::DoPopupMenu() to
3827 // wxPopupMenuPositionCallback()
3828 //
3829 // should be safe even in the MT case as the user can hardly popup 2 menus
3830 // simultaneously, can he?
3831 static gint gs_pop_x = 0;
3832 static gint gs_pop_y = 0;
3833
3834 extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
3835 gint *x, gint *y,
3836 #ifdef __WXGTK20__
3837 gboolean * WXUNUSED(whatever),
3838 #endif
3839 gpointer WXUNUSED(user_data) )
3840 {
3841 // ensure that the menu appears entirely on screen
3842 GtkRequisition req;
3843 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
3844
3845 wxSize sizeScreen = wxGetDisplaySize();
3846
3847 gint xmax = sizeScreen.x - req.width,
3848 ymax = sizeScreen.y - req.height;
3849
3850 *x = gs_pop_x < xmax ? gs_pop_x : xmax;
3851 *y = gs_pop_y < ymax ? gs_pop_y : ymax;
3852 }
3853
3854 bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
3855 {
3856 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3857
3858 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
3859
3860 SetInvokingWindow( menu, this );
3861
3862 menu->UpdateUI();
3863
3864 gs_pop_x = x;
3865 gs_pop_y = y;
3866 ClientToScreen( &gs_pop_x, &gs_pop_y );
3867
3868 bool is_waiting = TRUE;
3869
3870 gtk_signal_connect( GTK_OBJECT(menu->m_menu),
3871 "hide",
3872 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
3873 (gpointer)&is_waiting );
3874
3875 gtk_menu_popup(
3876 GTK_MENU(menu->m_menu),
3877 (GtkWidget *) NULL, // parent menu shell
3878 (GtkWidget *) NULL, // parent menu item
3879 wxPopupMenuPositionCallback, // function to position it
3880 NULL, // client data
3881 0, // button used to activate it
3882 gs_timeLastClick // the time of activation
3883 );
3884
3885 while (is_waiting)
3886 {
3887 while (gtk_events_pending())
3888 gtk_main_iteration();
3889 }
3890
3891 return TRUE;
3892 }
3893
3894 #endif // wxUSE_MENUS_NATIVE
3895
3896 #if wxUSE_DRAG_AND_DROP
3897
3898 void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
3899 {
3900 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3901
3902 GtkWidget *dnd_widget = GetConnectWidget();
3903
3904 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
3905
3906 if (m_dropTarget) delete m_dropTarget;
3907 m_dropTarget = dropTarget;
3908
3909 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
3910 }
3911
3912 #endif // wxUSE_DRAG_AND_DROP
3913
3914 GtkWidget* wxWindowGTK::GetConnectWidget()
3915 {
3916 GtkWidget *connect_widget = m_widget;
3917 if (m_wxwindow) connect_widget = m_wxwindow;
3918
3919 return connect_widget;
3920 }
3921
3922 bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
3923 {
3924 if (m_wxwindow)
3925 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
3926
3927 return (window == m_widget->window);
3928 }
3929
3930 bool wxWindowGTK::SetFont( const wxFont &font )
3931 {
3932 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3933
3934 if (!wxWindowBase::SetFont(font))
3935 {
3936 return FALSE;
3937 }
3938
3939 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
3940 if ( sysbg == m_backgroundColour )
3941 {
3942 m_backgroundColour = wxNullColour;
3943 ApplyWidgetStyle();
3944 m_backgroundColour = sysbg;
3945 }
3946 else
3947 {
3948 ApplyWidgetStyle();
3949 }
3950
3951 return TRUE;
3952 }
3953
3954 void wxWindowGTK::DoCaptureMouse()
3955 {
3956 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3957
3958 GdkWindow *window = (GdkWindow*) NULL;
3959 if (m_wxwindow)
3960 window = GTK_PIZZA(m_wxwindow)->bin_window;
3961 else
3962 window = GetConnectWidget()->window;
3963
3964 wxCHECK_RET( window, _T("CaptureMouse() failed") );
3965
3966 wxCursor* cursor = & m_cursor;
3967 if (!cursor->Ok())
3968 cursor = wxSTANDARD_CURSOR;
3969
3970 gdk_pointer_grab( window, FALSE,
3971 (GdkEventMask)
3972 (GDK_BUTTON_PRESS_MASK |
3973 GDK_BUTTON_RELEASE_MASK |
3974 GDK_POINTER_MOTION_HINT_MASK |
3975 GDK_POINTER_MOTION_MASK),
3976 (GdkWindow *) NULL,
3977 cursor->GetCursor(),
3978 (guint32)GDK_CURRENT_TIME );
3979 g_captureWindow = this;
3980 g_captureWindowHasMouse = TRUE;
3981 }
3982
3983 void wxWindowGTK::DoReleaseMouse()
3984 {
3985 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3986
3987 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
3988
3989 g_captureWindow = (wxWindowGTK*) NULL;
3990
3991 GdkWindow *window = (GdkWindow*) NULL;
3992 if (m_wxwindow)
3993 window = GTK_PIZZA(m_wxwindow)->bin_window;
3994 else
3995 window = GetConnectWidget()->window;
3996
3997 if (!window)
3998 return;
3999
4000 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
4001 }
4002
4003 /* static */
4004 wxWindow *wxWindowBase::GetCapture()
4005 {
4006 return (wxWindow *)g_captureWindow;
4007 }
4008
4009 bool wxWindowGTK::IsRetained() const
4010 {
4011 return FALSE;
4012 }
4013
4014 void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
4015 int range, bool refresh )
4016 {
4017 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4018
4019 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4020
4021 m_hasScrolling = TRUE;
4022
4023 if (orient == wxHORIZONTAL)
4024 {
4025 float fpos = (float)pos;
4026 float frange = (float)range;
4027 float fthumb = (float)thumbVisible;
4028 if (fpos > frange-fthumb) fpos = frange-fthumb;
4029 if (fpos < 0.0) fpos = 0.0;
4030
4031 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
4032 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
4033 {
4034 SetScrollPos( orient, pos, refresh );
4035 return;
4036 }
4037
4038 m_oldHorizontalPos = fpos;
4039
4040 m_hAdjust->lower = 0.0;
4041 m_hAdjust->upper = frange;
4042 m_hAdjust->value = fpos;
4043 m_hAdjust->step_increment = 1.0;
4044 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
4045 m_hAdjust->page_size = fthumb;
4046 }
4047 else
4048 {
4049 float fpos = (float)pos;
4050 float frange = (float)range;
4051 float fthumb = (float)thumbVisible;
4052 if (fpos > frange-fthumb) fpos = frange-fthumb;
4053 if (fpos < 0.0) fpos = 0.0;
4054
4055 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4056 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4057 {
4058 SetScrollPos( orient, pos, refresh );
4059 return;
4060 }
4061
4062 m_oldVerticalPos = fpos;
4063
4064 m_vAdjust->lower = 0.0;
4065 m_vAdjust->upper = frange;
4066 m_vAdjust->value = fpos;
4067 m_vAdjust->step_increment = 1.0;
4068 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4069 m_vAdjust->page_size = fthumb;
4070 }
4071
4072 if (orient == wxHORIZONTAL)
4073 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4074 else
4075 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
4076 }
4077
4078 void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
4079 {
4080 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4081
4082 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4083
4084 if (orient == wxHORIZONTAL)
4085 {
4086 float fpos = (float)pos;
4087 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
4088 if (fpos < 0.0) fpos = 0.0;
4089 m_oldHorizontalPos = fpos;
4090
4091 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
4092 m_hAdjust->value = fpos;
4093 }
4094 else
4095 {
4096 float fpos = (float)pos;
4097 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
4098 if (fpos < 0.0) fpos = 0.0;
4099 m_oldVerticalPos = fpos;
4100
4101 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
4102 m_vAdjust->value = fpos;
4103 }
4104
4105 if (m_wxwindow->window)
4106 {
4107 if (orient == wxHORIZONTAL)
4108 {
4109 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
4110 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4111
4112 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
4113
4114 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
4115 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4116 }
4117 else
4118 {
4119 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
4120 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4121
4122 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
4123
4124 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
4125 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4126 }
4127 }
4128 }
4129
4130 int wxWindowGTK::GetScrollThumb( int orient ) const
4131 {
4132 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4133
4134 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4135
4136 if (orient == wxHORIZONTAL)
4137 return (int)(m_hAdjust->page_size+0.5);
4138 else
4139 return (int)(m_vAdjust->page_size+0.5);
4140 }
4141
4142 int wxWindowGTK::GetScrollPos( int orient ) const
4143 {
4144 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4145
4146 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4147
4148 if (orient == wxHORIZONTAL)
4149 return (int)(m_hAdjust->value+0.5);
4150 else
4151 return (int)(m_vAdjust->value+0.5);
4152 }
4153
4154 int wxWindowGTK::GetScrollRange( int orient ) const
4155 {
4156 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4157
4158 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4159
4160 if (orient == wxHORIZONTAL)
4161 return (int)(m_hAdjust->upper+0.5);
4162 else
4163 return (int)(m_vAdjust->upper+0.5);
4164 }
4165
4166 void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4167 {
4168 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4169
4170 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4171
4172 // No scrolling requested.
4173 if ((dx == 0) && (dy == 0)) return;
4174
4175 #ifndef __WXGTK20__
4176 if (!m_updateRegion.IsEmpty())
4177 {
4178 m_updateRegion.Offset( dx, dy );
4179
4180 int cw = 0;
4181 int ch = 0;
4182 GetClientSize( &cw, &ch );
4183 m_updateRegion.Intersect( 0, 0, cw, ch );
4184 }
4185
4186 if (!m_clearRegion.IsEmpty())
4187 {
4188 m_clearRegion.Offset( dx, dy );
4189
4190 int cw = 0;
4191 int ch = 0;
4192 GetClientSize( &cw, &ch );
4193 m_clearRegion.Intersect( 0, 0, cw, ch );
4194 }
4195 m_clipPaintRegion = TRUE;
4196
4197 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
4198
4199 m_clipPaintRegion = FALSE;
4200 #else
4201
4202 gdk_window_scroll( GTK_PIZZA(m_wxwindow)->bin_window, dx, dy );
4203
4204 GTK_PIZZA(m_wxwindow)->xoffset += dx;
4205 GTK_PIZZA(m_wxwindow)->yoffset += dy;
4206
4207 #endif
4208
4209 }
4210
4211
4212 // Find the wxWindow at the current mouse position, also returning the mouse
4213 // position.
4214 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4215 {
4216 pt = wxGetMousePosition();
4217 wxWindow* found = wxFindWindowAtPoint(pt);
4218 return found;
4219 }
4220
4221 // Get the current mouse position.
4222 wxPoint wxGetMousePosition()
4223 {
4224 /* This crashes when used within wxHelpContext,
4225 so we have to use the X-specific implementation below.
4226 gint x, y;
4227 GdkModifierType *mask;
4228 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4229
4230 return wxPoint(x, y);
4231 */
4232
4233 int x, y;
4234 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4235 if (!windowAtPtr)
4236 return wxPoint(-999, -999);
4237
4238 Display *display = GDK_WINDOW_XDISPLAY(windowAtPtr);
4239 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4240 Window rootReturn, childReturn;
4241 int rootX, rootY, winX, winY;
4242 unsigned int maskReturn;
4243
4244 XQueryPointer (display,
4245 rootWindow,
4246 &rootReturn,
4247 &childReturn,
4248 &rootX, &rootY, &winX, &winY, &maskReturn);
4249 return wxPoint(rootX, rootY);
4250
4251 }
4252
4253 // ----------------------------------------------------------------------------
4254 // wxDCModule
4255 // ----------------------------------------------------------------------------
4256
4257 class wxWinModule : public wxModule
4258 {
4259 public:
4260 bool OnInit();
4261 void OnExit();
4262
4263 private:
4264 DECLARE_DYNAMIC_CLASS(wxWinModule)
4265 };
4266
4267 IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4268
4269 bool wxWinModule::OnInit()
4270 {
4271 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4272 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4273
4274 return TRUE;
4275 }
4276
4277 void wxWinModule::OnExit()
4278 {
4279 if (g_eraseGC)
4280 gdk_gc_unref( g_eraseGC );
4281 }
4282
4283 // vi:sts=4:sw=4:et
wxWidgets (Impactor)