]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/window.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
compilation fixes for wxUniv (moved wxDlgProc back to toplevel.cpp)
[wxWidgets.git] / src / gtk1 / window.cpp
... / ...
CommitLineData
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__
81extern 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
218extern wxList wxPendingDelete;
219extern bool g_blockEventsOnDrag;
220extern bool g_blockEventsOnScroll;
221extern wxCursor g_globalCursor;
222
223static GdkGC *g_eraseGC = NULL;
224
225// mouse capture state: the window which has it and if the mouse is currently
226// inside it
227static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
228static 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
235static 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
239static wxWindowGTK *g_activeFrame = (wxWindowGTK*) NULL;
240static 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.
244wxWindowGTK *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
250static 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 */
254static guint32 gs_timeLastClick = 0;
255
256extern 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
284void
285gdk_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
323extern void wxapp_install_idle_handler();
324extern 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.
333wxWindow *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
354static 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
443gint 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
463static 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
474static 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
489static 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
542gint 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
564static 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
663static 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
933static inline bool wxIsAsciiKeysym(KeySym ks)
934{
935 return ks < 256;
936}
937
938static bool
939wxTranslateGTKKeyEventToWx(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 = %d"),
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 %d"), 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
1055static 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
1217static 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#define InitMouseEvent(win, event, gdk_event) \
1256 { \
1257 event.SetTimestamp( gdk_event->time ); \
1258 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); \
1259 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); \
1260 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); \
1261 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK); \
1262 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); \
1263 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); \
1264 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); \
1265\
1266 wxPoint pt = win->GetClientAreaOrigin(); \
1267 event.m_x = (wxCoord)gdk_event->x - pt.x; \
1268 event.m_y = (wxCoord)gdk_event->y - pt.y; \
1269 }
1270
1271static void AdjustEventButtonState(wxMouseEvent& event)
1272{
1273 // GDK reports the old state of the button for a button press event, but
1274 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1275 // for a LEFT_DOWN event, not FALSE, so we will invert
1276 // left/right/middleDown for the corresponding click events
1277
1278 if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1279 (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1280 (event.GetEventType() == wxEVT_LEFT_UP))
1281 {
1282 event.m_leftDown = !event.m_leftDown;
1283 return;
1284 }
1285
1286 if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1287 (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1288 (event.GetEventType() == wxEVT_MIDDLE_UP))
1289 {
1290 event.m_middleDown = !event.m_middleDown;
1291 return;
1292 }
1293
1294 if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1295 (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1296 (event.GetEventType() == wxEVT_RIGHT_UP))
1297 {
1298 event.m_rightDown = !event.m_rightDown;
1299 return;
1300 }
1301}
1302
1303// find the window to send the mouse event too
1304static
1305wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1306{
1307 wxCoord xx = x;
1308 wxCoord yy = y;
1309
1310 if (win->m_wxwindow)
1311 {
1312 GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
1313 xx += pizza->xoffset;
1314 yy += pizza->yoffset;
1315 }
1316
1317 wxNode *node = win->GetChildren().First();
1318 while (node)
1319 {
1320 wxWindowGTK *child = (wxWindowGTK*)node->Data();
1321
1322 node = node->Next();
1323 if (!child->IsShown())
1324 continue;
1325
1326 if (child->IsTransparentForMouse())
1327 {
1328 // wxStaticBox is transparent in the box itself
1329 int xx1 = child->m_x;
1330 int yy1 = child->m_y;
1331 int xx2 = child->m_x + child->m_width;
1332 int yy2 = child->m_x + child->m_height;
1333
1334 // left
1335 if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
1336 // right
1337 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
1338 // top
1339 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
1340 // bottom
1341 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
1342 {
1343 win = child;
1344 x -= child->m_x;
1345 y -= child->m_y;
1346 break;
1347 }
1348
1349 }
1350 else
1351 {
1352 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
1353 (child->m_x <= xx) &&
1354 (child->m_y <= yy) &&
1355 (child->m_x+child->m_width >= xx) &&
1356 (child->m_y+child->m_height >= yy))
1357 {
1358 win = child;
1359 x -= child->m_x;
1360 y -= child->m_y;
1361 break;
1362 }
1363 }
1364 }
1365
1366 return win;
1367}
1368
1369//-----------------------------------------------------------------------------
1370// "button_press_event"
1371//-----------------------------------------------------------------------------
1372
1373static gint gtk_window_button_press_callback( GtkWidget *widget,
1374 GdkEventButton *gdk_event,
1375 wxWindowGTK *win )
1376{
1377 DEBUG_MAIN_THREAD
1378
1379 if (g_isIdle)
1380 wxapp_install_idle_handler();
1381
1382/*
1383 wxPrintf( wxT("1) OnButtonPress from ") );
1384 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1385 wxPrintf( win->GetClassInfo()->GetClassName() );
1386 wxPrintf( wxT(".\n") );
1387*/
1388 if (!win->m_hasVMT) return FALSE;
1389 if (g_blockEventsOnDrag) return TRUE;
1390 if (g_blockEventsOnScroll) return TRUE;
1391
1392 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1393
1394 if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())
1395 {
1396 gtk_widget_grab_focus( win->m_wxwindow );
1397/*
1398 wxPrintf( wxT("GrabFocus from ") );
1399 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1400 wxPrintf( win->GetClassInfo()->GetClassName() );
1401 wxPrintf( wxT(".\n") );
1402*/
1403 }
1404
1405 wxEventType event_type = wxEVT_NULL;
1406
1407 if (gdk_event->button == 1)
1408 {
1409 switch (gdk_event->type)
1410 {
1411 case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
1412 case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
1413 default: break;
1414 }
1415 }
1416 else if (gdk_event->button == 2)
1417 {
1418 switch (gdk_event->type)
1419 {
1420 case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
1421 case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
1422 default: break;
1423 }
1424 }
1425 else if (gdk_event->button == 3)
1426 {
1427 switch (gdk_event->type)
1428 {
1429 case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
1430 case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
1431 default: break;
1432 }
1433 }
1434
1435 if ( event_type == wxEVT_NULL )
1436 {
1437 // unknown mouse button or click type
1438 return FALSE;
1439 }
1440
1441 wxMouseEvent event( event_type );
1442 InitMouseEvent( win, event, gdk_event );
1443
1444 AdjustEventButtonState(event);
1445
1446 // wxListBox actually get mouse events from the item, so we need to give it
1447 // a chance to correct this
1448 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1449
1450 // find the correct window to send the event too: it may be a different one
1451 // from the one which got it at GTK+ level because some control don't have
1452 // their own X window and thus cannot get any events.
1453 if ( !g_captureWindow )
1454 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1455
1456 event.SetEventObject( win );
1457
1458 gs_timeLastClick = gdk_event->time;
1459
1460/*
1461 wxPrintf( wxT("2) OnButtonPress from ") );
1462 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1463 wxPrintf( win->GetClassInfo()->GetClassName() );
1464 wxPrintf( wxT(".\n") );
1465*/
1466
1467 if (win->GetEventHandler()->ProcessEvent( event ))
1468 {
1469 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
1470 return TRUE;
1471 }
1472
1473 return FALSE;
1474}
1475
1476//-----------------------------------------------------------------------------
1477// "button_release_event"
1478//-----------------------------------------------------------------------------
1479
1480static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win )
1481{
1482 DEBUG_MAIN_THREAD
1483
1484 if (g_isIdle)
1485 wxapp_install_idle_handler();
1486
1487 if (!win->m_hasVMT) return FALSE;
1488 if (g_blockEventsOnDrag) return FALSE;
1489 if (g_blockEventsOnScroll) return FALSE;
1490
1491 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1492
1493/*
1494 printf( "OnButtonRelease from " );
1495 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1496 printf( win->GetClassInfo()->GetClassName() );
1497 printf( ".\n" );
1498*/
1499
1500 wxEventType event_type = wxEVT_NULL;
1501
1502 switch (gdk_event->button)
1503 {
1504 case 1: event_type = wxEVT_LEFT_UP; break;
1505 case 2: event_type = wxEVT_MIDDLE_UP; break;
1506 case 3: event_type = wxEVT_RIGHT_UP; break;
1507 default: return FALSE;
1508 }
1509
1510 wxMouseEvent event( event_type );
1511 InitMouseEvent( win, event, gdk_event );
1512
1513 AdjustEventButtonState(event);
1514
1515 // same wxListBox hack as above
1516 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
1517
1518 if ( !g_captureWindow )
1519 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1520
1521 event.SetEventObject( win );
1522
1523 if (win->GetEventHandler()->ProcessEvent( event ))
1524 {
1525 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
1526 return TRUE;
1527 }
1528
1529 return FALSE;
1530}
1531
1532//-----------------------------------------------------------------------------
1533// "motion_notify_event"
1534//-----------------------------------------------------------------------------
1535
1536static gint gtk_window_motion_notify_callback( GtkWidget *widget,
1537 GdkEventMotion *gdk_event,
1538 wxWindowGTK *win )
1539{
1540 DEBUG_MAIN_THREAD
1541
1542 if (g_isIdle)
1543 wxapp_install_idle_handler();
1544
1545 if (!win->m_hasVMT) return FALSE;
1546 if (g_blockEventsOnDrag) return FALSE;
1547 if (g_blockEventsOnScroll) return FALSE;
1548
1549 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1550
1551 if (gdk_event->is_hint)
1552 {
1553 int x = 0;
1554 int y = 0;
1555 GdkModifierType state;
1556 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1557 gdk_event->x = x;
1558 gdk_event->y = y;
1559 }
1560
1561/*
1562 printf( "OnMotion from " );
1563 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1564 printf( win->GetClassInfo()->GetClassName() );
1565 printf( ".\n" );
1566*/
1567
1568 wxMouseEvent event( wxEVT_MOTION );
1569 InitMouseEvent(win, event, gdk_event);
1570
1571 if ( g_captureWindow )
1572 {
1573 // synthetize a mouse enter or leave event if needed
1574 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
1575 bool hasMouse = winUnderMouse == gdk_event->window;
1576 if ( hasMouse != g_captureWindowHasMouse )
1577 {
1578 // the mouse changed window
1579 g_captureWindowHasMouse = hasMouse;
1580
1581 wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1582 : wxEVT_LEAVE_WINDOW);
1583 InitMouseEvent(win, event, gdk_event);
1584 event.SetEventObject(win);
1585 win->GetEventHandler()->ProcessEvent(event);
1586 }
1587 }
1588 else // no capture
1589 {
1590 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
1591 }
1592
1593 event.SetEventObject( win );
1594
1595 if (win->GetEventHandler()->ProcessEvent( event ))
1596 {
1597 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
1598 return TRUE;
1599 }
1600
1601 return FALSE;
1602}
1603
1604//-----------------------------------------------------------------------------
1605// "focus_in_event"
1606//-----------------------------------------------------------------------------
1607
1608// send the wxChildFocusEvent and wxFocusEvent, common code of
1609// gtk_window_focus_in_callback() and SetFocus()
1610static bool DoSendFocusEvents(wxWindow *win)
1611{
1612 // Notify the parent keeping track of focus for the kbd navigation
1613 // purposes that we got it.
1614 wxChildFocusEvent eventChildFocus(win);
1615 (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
1616
1617 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1618 eventFocus.SetEventObject(win);
1619
1620 return win->GetEventHandler()->ProcessEvent(eventFocus);
1621}
1622
1623static gint gtk_window_focus_in_callback( GtkWidget *widget,
1624 GdkEvent *WXUNUSED(event),
1625 wxWindow *win )
1626{
1627 DEBUG_MAIN_THREAD
1628
1629 if (g_isIdle)
1630 wxapp_install_idle_handler();
1631
1632 if (!win->m_hasVMT) return FALSE;
1633 if (g_blockEventsOnDrag) return FALSE;
1634
1635 switch ( g_sendActivateEvent )
1636 {
1637 case -1:
1638 // we've got focus from outside, synthetize wxActivateEvent
1639 g_sendActivateEvent = 1;
1640 break;
1641
1642 case 0:
1643 // another our window just lost focus, it was already ours before
1644 // - don't send any wxActivateEvent
1645 g_sendActivateEvent = -1;
1646 break;
1647 }
1648
1649 g_focusWindowLast =
1650 g_focusWindow = win;
1651
1652 wxLogTrace(TRACE_FOCUS,
1653 _T("%s: focus in"), win->GetName().c_str());
1654
1655#ifdef HAVE_XIM
1656 if (win->m_ic)
1657 gdk_im_begin(win->m_ic, win->m_wxwindow->window);
1658#endif
1659
1660#if wxUSE_CARET
1661 // caret needs to be informed about focus change
1662 wxCaret *caret = win->GetCaret();
1663 if ( caret )
1664 {
1665 caret->OnSetFocus();
1666 }
1667#endif // wxUSE_CARET
1668
1669 g_activeFrameLostFocus = FALSE;
1670
1671 wxWindowGTK *active = wxGetTopLevelParent(win);
1672 if ( active != g_activeFrame )
1673 {
1674 if ( g_activeFrame )
1675 {
1676 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame);
1677 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
1678 event.SetEventObject(g_activeFrame);
1679 g_activeFrame->GetEventHandler()->ProcessEvent(event);
1680 }
1681
1682 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active);
1683 g_activeFrame = active;
1684 wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
1685 event.SetEventObject(g_activeFrame);
1686 g_activeFrame->GetEventHandler()->ProcessEvent(event);
1687
1688 // Don't send focus events in addition to activate
1689 // if (win == g_activeFrame)
1690 // return TRUE;
1691 }
1692
1693 // does the window itself think that it has the focus?
1694 if ( !win->m_hasFocus )
1695 {
1696 // not yet, notify it
1697 win->m_hasFocus = TRUE;
1698
1699 if ( DoSendFocusEvents(win) )
1700 {
1701 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
1702 return TRUE;
1703 }
1704 }
1705
1706 return FALSE;
1707}
1708
1709//-----------------------------------------------------------------------------
1710// "focus_out_event"
1711//-----------------------------------------------------------------------------
1712
1713static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
1714{
1715 DEBUG_MAIN_THREAD
1716
1717 if (g_isIdle)
1718 wxapp_install_idle_handler();
1719
1720 if (!win->m_hasVMT) return FALSE;
1721 if (g_blockEventsOnDrag) return FALSE;
1722
1723 wxLogTrace( TRACE_FOCUS,
1724 _T("%s: focus out"), win->GetName().c_str() );
1725
1726 if ( !g_activeFrameLostFocus && g_activeFrame )
1727 {
1728 // VZ: commenting this out because it does happen (although not easy
1729 // to reproduce, I only see it when using wxMiniFrame and not
1730 // always) and makes using Mahogany quite annoying
1731#if 0
1732 wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame,
1733 wxT("unfocusing window that hasn't gained focus properly") );
1734#endif // 0
1735
1736 g_activeFrameLostFocus = TRUE;
1737 }
1738
1739 // if the focus goes out of our app alltogether, OnIdle() will send
1740 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
1741 // g_sendActivateEvent to -1
1742 g_sendActivateEvent = 0;
1743
1744 wxWindowGTK *winFocus = wxFindFocusedChild(win);
1745 if ( winFocus )
1746 win = winFocus;
1747
1748 g_focusWindow = (wxWindowGTK *)NULL;
1749
1750#ifdef HAVE_XIM
1751 if (win->m_ic)
1752 gdk_im_end();
1753#endif
1754
1755#if wxUSE_CARET
1756 // caret needs to be informed about focus change
1757 wxCaret *caret = win->GetCaret();
1758 if ( caret )
1759 {
1760 caret->OnKillFocus();
1761 }
1762#endif // wxUSE_CARET
1763
1764 // don't send the window a kill focus event if it thinks that it doesn't
1765 // have focus already
1766 if ( win->m_hasFocus )
1767 {
1768 win->m_hasFocus = FALSE;
1769
1770 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
1771 event.SetEventObject( win );
1772
1773 if (win->GetEventHandler()->ProcessEvent( event ))
1774 {
1775 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
1776 return TRUE;
1777 }
1778 }
1779
1780 return FALSE;
1781}
1782
1783//-----------------------------------------------------------------------------
1784// "enter_notify_event"
1785//-----------------------------------------------------------------------------
1786
1787static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
1788{
1789 DEBUG_MAIN_THREAD
1790
1791 if (g_isIdle)
1792 wxapp_install_idle_handler();
1793
1794 if (!win->m_hasVMT) return FALSE;
1795 if (g_blockEventsOnDrag) return FALSE;
1796
1797 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1798
1799 wxMouseEvent event( wxEVT_ENTER_WINDOW );
1800 event.SetTimestamp( gdk_event->time );
1801 event.SetEventObject( win );
1802
1803 int x = 0;
1804 int y = 0;
1805 GdkModifierType state = (GdkModifierType)0;
1806
1807 gdk_window_get_pointer( widget->window, &x, &y, &state );
1808
1809 InitMouseEvent(win, event, gdk_event);
1810 wxPoint pt = win->GetClientAreaOrigin();
1811 event.m_x = x + pt.x;
1812 event.m_y = y + pt.y;
1813
1814 if (win->GetEventHandler()->ProcessEvent( event ))
1815 {
1816 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
1817 return TRUE;
1818 }
1819
1820 return FALSE;
1821}
1822
1823//-----------------------------------------------------------------------------
1824// "leave_notify_event"
1825//-----------------------------------------------------------------------------
1826
1827static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
1828{
1829 DEBUG_MAIN_THREAD
1830
1831 if (g_isIdle)
1832 wxapp_install_idle_handler();
1833
1834 if (!win->m_hasVMT) return FALSE;
1835 if (g_blockEventsOnDrag) return FALSE;
1836
1837 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1838
1839 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
1840 event.SetTimestamp( gdk_event->time );
1841 event.SetEventObject( win );
1842
1843 int x = 0;
1844 int y = 0;
1845 GdkModifierType state = (GdkModifierType)0;
1846
1847 gdk_window_get_pointer( widget->window, &x, &y, &state );
1848
1849 event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
1850 event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
1851 event.m_altDown = (state & GDK_MOD1_MASK) != 0;
1852 event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
1853 event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
1854 event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
1855 event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
1856
1857 wxPoint pt = win->GetClientAreaOrigin();
1858 event.m_x = x + pt.x;
1859 event.m_y = y + pt.y;
1860
1861 if (win->GetEventHandler()->ProcessEvent( event ))
1862 {
1863 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
1864 return TRUE;
1865 }
1866
1867 return FALSE;
1868}
1869
1870//-----------------------------------------------------------------------------
1871// "value_changed" from m_vAdjust
1872//-----------------------------------------------------------------------------
1873
1874static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
1875 SCROLLBAR_CBACK_ARG
1876 wxWindowGTK *win )
1877{
1878 DEBUG_MAIN_THREAD
1879
1880 if (g_isIdle)
1881 wxapp_install_idle_handler();
1882
1883 if (g_blockEventsOnDrag) return;
1884
1885 if (!win->m_hasVMT) return;
1886
1887 float diff = adjust->value - win->m_oldVerticalPos;
1888 if (fabs(diff) < 0.2) return;
1889
1890 win->m_oldVerticalPos = adjust->value;
1891
1892 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
1893 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
1894
1895 int value = (int)(adjust->value+0.5);
1896
1897 wxScrollWinEvent event( command, value, wxVERTICAL );
1898 event.SetEventObject( win );
1899 win->GetEventHandler()->ProcessEvent( event );
1900}
1901
1902//-----------------------------------------------------------------------------
1903// "value_changed" from m_hAdjust
1904//-----------------------------------------------------------------------------
1905
1906static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
1907 SCROLLBAR_CBACK_ARG
1908 wxWindowGTK *win )
1909{
1910 DEBUG_MAIN_THREAD
1911
1912 if (g_isIdle)
1913 wxapp_install_idle_handler();
1914
1915 if (g_blockEventsOnDrag) return;
1916 if (!win->m_hasVMT) return;
1917
1918 float diff = adjust->value - win->m_oldHorizontalPos;
1919 if (fabs(diff) < 0.2) return;
1920
1921 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
1922 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
1923
1924 win->m_oldHorizontalPos = adjust->value;
1925
1926 int value = (int)(adjust->value+0.5);
1927
1928 wxScrollWinEvent event( command, value, wxHORIZONTAL );
1929 event.SetEventObject( win );
1930 win->GetEventHandler()->ProcessEvent( event );
1931}
1932
1933//-----------------------------------------------------------------------------
1934// "button_press_event" from scrollbar
1935//-----------------------------------------------------------------------------
1936
1937static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
1938 GdkEventButton *gdk_event,
1939 wxWindowGTK *win)
1940{
1941 DEBUG_MAIN_THREAD
1942
1943 if (g_isIdle)
1944 wxapp_install_idle_handler();
1945
1946
1947 g_blockEventsOnScroll = TRUE;
1948
1949 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
1950#ifndef __WXGTK20__
1951 win->m_isScrolling = (gdk_event->window == widget->slider);
1952#endif
1953
1954 return FALSE;
1955}
1956
1957//-----------------------------------------------------------------------------
1958// "button_release_event" from scrollbar
1959//-----------------------------------------------------------------------------
1960
1961static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
1962 GdkEventButton *WXUNUSED(gdk_event),
1963 wxWindowGTK *win)
1964{
1965 DEBUG_MAIN_THREAD
1966
1967// don't test here as we can release the mouse while being over
1968// a different window than the slider
1969//
1970// if (gdk_event->window != widget->slider) return FALSE;
1971
1972 g_blockEventsOnScroll = FALSE;
1973
1974 if (win->m_isScrolling)
1975 {
1976 wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
1977 int value = -1;
1978 int dir = -1;
1979
1980 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
1981 if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
1982 {
1983 value = (int)(win->m_hAdjust->value+0.5);
1984 dir = wxHORIZONTAL;
1985 }
1986 if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
1987 {
1988 value = (int)(win->m_vAdjust->value+0.5);
1989 dir = wxVERTICAL;
1990 }
1991
1992 wxScrollWinEvent event( command, value, dir );
1993 event.SetEventObject( win );
1994 win->GetEventHandler()->ProcessEvent( event );
1995 }
1996
1997 win->m_isScrolling = FALSE;
1998
1999 return FALSE;
2000}
2001
2002// ----------------------------------------------------------------------------
2003// this wxWindowBase function is implemented here (in platform-specific file)
2004// because it is static and so couldn't be made virtual
2005// ----------------------------------------------------------------------------
2006
2007wxWindow *wxWindowBase::FindFocus()
2008{
2009 // the cast is necessary when we compile in wxUniversal mode
2010 return (wxWindow *)g_focusWindow;
2011}
2012
2013//-----------------------------------------------------------------------------
2014// "destroy" event
2015//-----------------------------------------------------------------------------
2016
2017// VZ: Robert commented the code using out so it generates warnings: should
2018// be either fixed or removed completely
2019#if 0
2020
2021static void gtk_window_destroy_callback( GtkWidget* widget, wxWindow *win )
2022{
2023 wxWindowDestroyEvent event(win);
2024 win->GetEventHandler()->ProcessEvent(event);
2025}
2026
2027#endif // 0
2028
2029//-----------------------------------------------------------------------------
2030// "realize" from m_widget
2031//-----------------------------------------------------------------------------
2032
2033/* We cannot set colours and fonts before the widget has
2034 been realized, so we do this directly after realization. */
2035
2036static gint
2037gtk_window_realized_callback( GtkWidget *WXUNUSED(m_widget), wxWindow *win )
2038{
2039 DEBUG_MAIN_THREAD
2040
2041 if (g_isIdle)
2042 wxapp_install_idle_handler();
2043
2044 if (win->m_delayedBackgroundColour)
2045 win->GtkSetBackgroundColour( win->GetBackgroundColour() );
2046
2047 if (win->m_delayedForegroundColour)
2048 win->GtkSetForegroundColour( win->GetForegroundColour() );
2049
2050 wxWindowCreateEvent event( win );
2051 event.SetEventObject( win );
2052 win->GetEventHandler()->ProcessEvent( event );
2053
2054 return FALSE;
2055}
2056
2057//-----------------------------------------------------------------------------
2058// "size_allocate"
2059//-----------------------------------------------------------------------------
2060
2061static
2062void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2063 GtkAllocation *WXUNUSED(alloc),
2064 wxWindow *win )
2065{
2066 if (g_isIdle)
2067 wxapp_install_idle_handler();
2068
2069 if (!win->m_hasScrolling) return;
2070
2071 int client_width = 0;
2072 int client_height = 0;
2073 win->GetClientSize( &client_width, &client_height );
2074 if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2075 return;
2076
2077 win->m_oldClientWidth = client_width;
2078 win->m_oldClientHeight = client_height;
2079
2080 if (!win->m_nativeSizeEvent)
2081 {
2082 wxSizeEvent event( win->GetSize(), win->GetId() );
2083 event.SetEventObject( win );
2084 win->GetEventHandler()->ProcessEvent( event );
2085 }
2086}
2087
2088
2089#ifdef HAVE_XIM
2090 #define WXUNUSED_UNLESS_XIM(param) param
2091#else
2092 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2093#endif
2094
2095/* Resize XIM window */
2096
2097static
2098void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2099 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
2100 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
2101{
2102 if (g_isIdle)
2103 wxapp_install_idle_handler();
2104
2105#ifdef HAVE_XIM
2106 if (!win->m_ic)
2107 return;
2108
2109 if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2110 {
2111 gint width, height;
2112
2113 gdk_window_get_size (widget->window, &width, &height);
2114 win->m_icattr->preedit_area.width = width;
2115 win->m_icattr->preedit_area.height = height;
2116 gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2117 }
2118#endif // HAVE_XIM
2119}
2120
2121//-----------------------------------------------------------------------------
2122// "realize" from m_wxwindow
2123//-----------------------------------------------------------------------------
2124
2125/* Initialize XIM support */
2126
2127static gint
2128gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
2129 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
2130{
2131 if (g_isIdle)
2132 wxapp_install_idle_handler();
2133
2134#ifdef HAVE_XIM
2135 if (win->m_ic) return FALSE;
2136 if (!widget) return FALSE;
2137 if (!gdk_im_ready()) return FALSE;
2138
2139 win->m_icattr = gdk_ic_attr_new();
2140 if (!win->m_icattr) return FALSE;
2141
2142 gint width, height;
2143 GdkEventMask mask;
2144 GdkColormap *colormap;
2145 GdkICAttr *attr = win->m_icattr;
2146 unsigned attrmask = GDK_IC_ALL_REQ;
2147 GdkIMStyle style;
2148 GdkIMStyle supported_style = (GdkIMStyle)
2149 (GDK_IM_PREEDIT_NONE |
2150 GDK_IM_PREEDIT_NOTHING |
2151 GDK_IM_PREEDIT_POSITION |
2152 GDK_IM_STATUS_NONE |
2153 GDK_IM_STATUS_NOTHING);
2154
2155 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2156 supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
2157
2158 attr->style = style = gdk_im_decide_style (supported_style);
2159 attr->client_window = widget->window;
2160
2161 if ((colormap = gtk_widget_get_colormap (widget)) !=
2162 gtk_widget_get_default_colormap ())
2163 {
2164 attrmask |= GDK_IC_PREEDIT_COLORMAP;
2165 attr->preedit_colormap = colormap;
2166 }
2167
2168 attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2169 attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2170 attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2171 attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2172
2173 switch (style & GDK_IM_PREEDIT_MASK)
2174 {
2175 case GDK_IM_PREEDIT_POSITION:
2176 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2177 {
2178 g_warning ("over-the-spot style requires fontset");
2179 break;
2180 }
2181
2182 gdk_window_get_size (widget->window, &width, &height);
2183
2184 attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2185 attr->spot_location.x = 0;
2186 attr->spot_location.y = height;
2187 attr->preedit_area.x = 0;
2188 attr->preedit_area.y = 0;
2189 attr->preedit_area.width = width;
2190 attr->preedit_area.height = height;
2191 attr->preedit_fontset = widget->style->font;
2192
2193 break;
2194 }
2195
2196 win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2197
2198 if (win->m_ic == NULL)
2199 g_warning ("Can't create input context.");
2200 else
2201 {
2202 mask = gdk_window_get_events (widget->window);
2203 mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2204 gdk_window_set_events (widget->window, mask);
2205
2206 if (GTK_WIDGET_HAS_FOCUS(widget))
2207 gdk_im_begin (win->m_ic, widget->window);
2208 }
2209#endif // HAVE_XIM
2210
2211 return FALSE;
2212}
2213
2214//-----------------------------------------------------------------------------
2215// InsertChild for wxWindowGTK.
2216//-----------------------------------------------------------------------------
2217
2218/* Callback for wxWindowGTK. This very strange beast has to be used because
2219 * C++ has no virtual methods in a constructor. We have to emulate a
2220 * virtual function here as wxNotebook requires a different way to insert
2221 * a child in it. I had opted for creating a wxNotebookPage window class
2222 * which would have made this superfluous (such in the MDI window system),
2223 * but no-one was listening to me... */
2224
2225static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
2226{
2227 /* the window might have been scrolled already, do we
2228 have to adapt the position */
2229 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2230 child->m_x += pizza->xoffset;
2231 child->m_y += pizza->yoffset;
2232
2233 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
2234 GTK_WIDGET(child->m_widget),
2235 child->m_x,
2236 child->m_y,
2237 child->m_width,
2238 child->m_height );
2239}
2240
2241//-----------------------------------------------------------------------------
2242// global functions
2243//-----------------------------------------------------------------------------
2244
2245wxWindow *wxGetActiveWindow()
2246{
2247 return wxWindow::FindFocus();
2248}
2249
2250//-----------------------------------------------------------------------------
2251// wxWindowGTK
2252//-----------------------------------------------------------------------------
2253
2254// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2255// method
2256#ifdef __WXUNIVERSAL__
2257 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2258#else // __WXGTK__
2259 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
2260#endif // __WXUNIVERSAL__/__WXGTK__
2261
2262void wxWindowGTK::Init()
2263{
2264 // common init
2265 InitBase();
2266
2267 // GTK specific
2268 m_widget = (GtkWidget *) NULL;
2269 m_wxwindow = (GtkWidget *) NULL;
2270 m_focusWidget = (GtkWidget *) NULL;
2271
2272 // position/size
2273 m_x = 0;
2274 m_y = 0;
2275 m_width = 0;
2276 m_height = 0;
2277
2278 m_sizeSet = FALSE;
2279 m_hasVMT = FALSE;
2280 m_needParent = TRUE;
2281 m_isBeingDeleted = FALSE;
2282
2283 m_noExpose = FALSE;
2284 m_nativeSizeEvent = FALSE;
2285
2286 m_hasScrolling = FALSE;
2287 m_isScrolling = FALSE;
2288
2289 m_hAdjust = (GtkAdjustment*) NULL;
2290 m_vAdjust = (GtkAdjustment*) NULL;
2291 m_oldHorizontalPos = 0.0;
2292 m_oldVerticalPos = 0.0;
2293
2294 m_resizing = FALSE;
2295 m_widgetStyle = (GtkStyle*) NULL;
2296
2297 m_insertCallback = (wxInsertChildFunction) NULL;
2298
2299 m_acceptsFocus = FALSE;
2300 m_hasFocus = FALSE;
2301
2302 m_clipPaintRegion = FALSE;
2303
2304 m_cursor = *wxSTANDARD_CURSOR;
2305
2306 m_delayedForegroundColour = FALSE;
2307 m_delayedBackgroundColour = FALSE;
2308
2309#ifdef HAVE_XIM
2310 m_ic = (GdkIC*) NULL;
2311 m_icattr = (GdkICAttr*) NULL;
2312#endif
2313}
2314
2315wxWindowGTK::wxWindowGTK()
2316{
2317 Init();
2318}
2319
2320wxWindowGTK::wxWindowGTK( wxWindow *parent,
2321 wxWindowID id,
2322 const wxPoint &pos,
2323 const wxSize &size,
2324 long style,
2325 const wxString &name )
2326{
2327 Init();
2328
2329 Create( parent, id, pos, size, style, name );
2330}
2331
2332bool wxWindowGTK::Create( wxWindow *parent,
2333 wxWindowID id,
2334 const wxPoint &pos,
2335 const wxSize &size,
2336 long style,
2337 const wxString &name )
2338{
2339 if (!PreCreation( parent, pos, size ) ||
2340 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2341 {
2342 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
2343 return FALSE;
2344 }
2345
2346 m_insertCallback = wxInsertChildInWindow;
2347
2348 // always needed for background clearing
2349 m_delayedBackgroundColour = TRUE;
2350
2351 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
2352 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
2353
2354 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
2355
2356 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2357 scroll_class->scrollbar_spacing = 0;
2358
2359 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
2360
2361 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2362 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
2363
2364 m_wxwindow = gtk_pizza_new();
2365
2366#ifndef __WXUNIVERSAL__
2367 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2368
2369 if (HasFlag(wxRAISED_BORDER))
2370 {
2371 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
2372 }
2373 else if (HasFlag(wxSUNKEN_BORDER))
2374 {
2375 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
2376 }
2377 else if (HasFlag(wxSIMPLE_BORDER))
2378 {
2379 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
2380 }
2381 else
2382 {
2383 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
2384 }
2385#endif // __WXUNIVERSAL__
2386
2387 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2388
2389 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2390 m_acceptsFocus = TRUE;
2391
2392 // I _really_ don't want scrollbars in the beginning
2393 m_vAdjust->lower = 0.0;
2394 m_vAdjust->upper = 1.0;
2395 m_vAdjust->value = 0.0;
2396 m_vAdjust->step_increment = 1.0;
2397 m_vAdjust->page_increment = 1.0;
2398 m_vAdjust->page_size = 5.0;
2399 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2400 m_hAdjust->lower = 0.0;
2401 m_hAdjust->upper = 1.0;
2402 m_hAdjust->value = 0.0;
2403 m_hAdjust->step_increment = 1.0;
2404 m_hAdjust->page_increment = 1.0;
2405 m_hAdjust->page_size = 5.0;
2406 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
2407
2408 // these handlers block mouse events to any window during scrolling such as
2409 // motion events and prevent GTK and wxWindows from fighting over where the
2410 // slider should be
2411
2412 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
2413 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2414
2415 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
2416 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2417
2418 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
2419 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2420
2421 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
2422 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2423
2424 // these handlers get notified when screen updates are required either when
2425 // scrolling or when the window size (and therefore scrollbar configuration)
2426 // has changed
2427
2428 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2429 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2430 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2431 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2432
2433 gtk_widget_show( m_wxwindow );
2434
2435 if (m_parent)
2436 m_parent->DoAddChild( this );
2437
2438 m_focusWidget = m_wxwindow;
2439
2440 PostCreation();
2441
2442 Show( TRUE );
2443
2444 return TRUE;
2445}
2446
2447wxWindowGTK::~wxWindowGTK()
2448{
2449 if (g_focusWindow == this)
2450 g_focusWindow = NULL;
2451
2452 if (g_activeFrame == this)
2453 g_activeFrame = NULL;
2454
2455 if ( g_delayedFocus == this )
2456 g_delayedFocus = NULL;
2457
2458 m_isBeingDeleted = TRUE;
2459 m_hasVMT = FALSE;
2460
2461 if (m_widget)
2462 Show( FALSE );
2463
2464 DestroyChildren();
2465
2466 if (m_parent)
2467 m_parent->RemoveChild( this );
2468
2469#ifdef HAVE_XIM
2470 if (m_ic)
2471 gdk_ic_destroy (m_ic);
2472 if (m_icattr)
2473 gdk_ic_attr_destroy (m_icattr);
2474#endif
2475
2476 if (m_widgetStyle)
2477 {
2478#if DISABLE_STYLE_IF_BROKEN_THEME
2479 // don't delete if it's a pixmap theme style
2480 if (!m_widgetStyle->engine_data)
2481 gtk_style_unref( m_widgetStyle );
2482#endif
2483 m_widgetStyle = (GtkStyle*) NULL;
2484 }
2485
2486 if (m_wxwindow)
2487 {
2488 gtk_widget_destroy( m_wxwindow );
2489 m_wxwindow = (GtkWidget*) NULL;
2490 }
2491
2492 if (m_widget)
2493 {
2494 gtk_widget_destroy( m_widget );
2495 m_widget = (GtkWidget*) NULL;
2496 }
2497}
2498
2499bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
2500{
2501 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
2502
2503 /* this turns -1 into 20 so that a minimal window is
2504 visible even although -1,-1 has been given as the
2505 size of the window. the same trick is used in other
2506 ports and should make debugging easier */
2507 m_width = WidthDefault(size.x);
2508 m_height = HeightDefault(size.y);
2509
2510 m_x = (int)pos.x;
2511 m_y = (int)pos.y;
2512
2513 /* some reasonable defaults */
2514 if (!parent)
2515 {
2516 if (m_x == -1)
2517 {
2518 m_x = (gdk_screen_width () - m_width) / 2;
2519 if (m_x < 10) m_x = 10;
2520 }
2521 if (m_y == -1)
2522 {
2523 m_y = (gdk_screen_height () - m_height) / 2;
2524 if (m_y < 10) m_y = 10;
2525 }
2526 }
2527
2528 return TRUE;
2529}
2530
2531void wxWindowGTK::PostCreation()
2532{
2533 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2534
2535 if (m_wxwindow)
2536 {
2537 if (!m_noExpose)
2538 {
2539 // these get reported to wxWindows -> wxPaintEvent
2540
2541 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2542
2543 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2544 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2545
2546#ifndef __WXGTK20__
2547 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2548 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
2549
2550 if (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE))
2551 {
2552 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2553 GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2554 }
2555#else
2556 gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ) );
2557#endif
2558 }
2559
2560 // these are called when the "sunken" or "raised" borders are drawn
2561 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2562 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2563
2564#ifndef __WXGTK20__
2565 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2566 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
2567#endif
2568 }
2569
2570 // focus handling
2571
2572 if (m_focusWidget == NULL)
2573 m_focusWidget = m_widget;
2574
2575 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2576 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2577
2578 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
2579 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2580
2581 // connect to the various key and mouse handlers
2582
2583 GtkWidget *connect_widget = GetConnectWidget();
2584
2585 ConnectWidget( connect_widget );
2586
2587 /* We cannot set colours, fonts and cursors before the widget has
2588 been realized, so we do this directly after realization */
2589 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
2590 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2591
2592 if (m_wxwindow)
2593 {
2594 // Catch native resize events
2595 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2596 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2597
2598 // Initialize XIM support
2599 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2600 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
2601
2602 // And resize XIM window
2603 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2604 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
2605 }
2606
2607 if (!GTK_IS_COMBO(m_widget))
2608 {
2609 // This is needed if we want to add our windows into native
2610 // GTK control, such as the toolbar. With this callback, the
2611 // toolbar gets to know the correct size (the one set by the
2612 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2613 // when moving to GTK 2.0.
2614 gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
2615 GTK_SIGNAL_FUNC(gtk_window_size_request_callback), (gpointer) this );
2616 }
2617
2618 m_hasVMT = TRUE;
2619}
2620
2621void wxWindowGTK::ConnectWidget( GtkWidget *widget )
2622{
2623 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2624 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
2625
2626 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2627 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2628
2629 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2630 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
2631
2632 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2633 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
2634
2635 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2636 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
2637
2638 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2639 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
2640
2641 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2642 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
2643
2644 // This keeps crashing on me. RR.
2645 //
2646 // gtk_signal_connect( GTK_OBJECT(widget), "destroy",
2647 // GTK_SIGNAL_FUNC(gtk_window_destroy_callback), (gpointer)this );
2648}
2649
2650bool wxWindowGTK::Destroy()
2651{
2652 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2653
2654 m_hasVMT = FALSE;
2655
2656 return wxWindowBase::Destroy();
2657}
2658
2659void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
2660{
2661 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2662}
2663
2664void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
2665{
2666 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2667 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
2668
2669/*
2670 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
2671*/
2672
2673 if (m_resizing) return; /* I don't like recursions */
2674 m_resizing = TRUE;
2675
2676 int currentX, currentY;
2677 GetPosition(&currentX, &currentY);
2678 if (x == -1)
2679 x = currentX;
2680 if (y == -1)
2681 y = currentY;
2682 AdjustForParentClientOrigin(x, y, sizeFlags);
2683
2684 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
2685 {
2686 /* don't set the size for children of wxNotebook, just take the values. */
2687 m_x = x;
2688 m_y = y;
2689 m_width = width;
2690 m_height = height;
2691 }
2692 else
2693 {
2694 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2695 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
2696 {
2697 if (x != -1) m_x = x + pizza->xoffset;
2698 if (y != -1) m_y = y + pizza->yoffset;
2699 if (width != -1) m_width = width;
2700 if (height != -1) m_height = height;
2701 }
2702 else
2703 {
2704 m_x = x + pizza->xoffset;
2705 m_y = y + pizza->yoffset;
2706 m_width = width;
2707 m_height = height;
2708 }
2709
2710 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
2711 {
2712 if (width == -1) m_width = 80;
2713 }
2714
2715 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
2716 {
2717 if (height == -1) m_height = 26;
2718 }
2719
2720 int minWidth = GetMinWidth(),
2721 minHeight = GetMinHeight(),
2722 maxWidth = GetMaxWidth(),
2723 maxHeight = GetMaxHeight();
2724
2725 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
2726 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
2727 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
2728 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
2729
2730 int border = 0;
2731 int bottom_border = 0;
2732
2733#ifndef __WXGTK20__
2734 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
2735 {
2736 /* the default button has a border around it */
2737 border = 6;
2738 bottom_border = 5;
2739 }
2740#endif
2741
2742 DoMoveWindow( m_x-border,
2743 m_y-border,
2744 m_width+2*border,
2745 m_height+border+bottom_border );
2746 }
2747
2748 if (m_hasScrolling)
2749 {
2750 /* Sometimes the client area changes size without the
2751 whole windows's size changing, but if the whole
2752 windows's size doesn't change, no wxSizeEvent will
2753 normally be sent. Here we add an extra test if
2754 the client test has been changed and this will
2755 be used then. */
2756 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
2757 }
2758
2759/*
2760 wxPrintf( "OnSize sent from " );
2761 if (GetClassInfo() && GetClassInfo()->GetClassName())
2762 wxPrintf( GetClassInfo()->GetClassName() );
2763 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2764*/
2765
2766 if (!m_nativeSizeEvent)
2767 {
2768 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2769 event.SetEventObject( this );
2770 GetEventHandler()->ProcessEvent( event );
2771 }
2772
2773 m_resizing = FALSE;
2774}
2775
2776void wxWindowGTK::OnInternalIdle()
2777{
2778 // Update invalidated regions.
2779 GtkUpdate();
2780
2781 // Synthetize activate events.
2782 if ( g_sendActivateEvent != -1 )
2783 {
2784 bool activate = g_sendActivateEvent != 0;
2785
2786 // do it only once
2787 g_sendActivateEvent = -1;
2788
2789 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
2790 }
2791
2792 if ( g_activeFrameLostFocus )
2793 {
2794 if ( g_activeFrame )
2795 {
2796 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
2797 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
2798 event.SetEventObject(g_activeFrame);
2799 g_activeFrame->GetEventHandler()->ProcessEvent(event);
2800 g_activeFrame = NULL;
2801 }
2802 g_activeFrameLostFocus = FALSE;
2803 }
2804
2805 wxCursor cursor = m_cursor;
2806 if (g_globalCursor.Ok()) cursor = g_globalCursor;
2807
2808 if (cursor.Ok())
2809 {
2810 /* I now set the cursor anew in every OnInternalIdle call
2811 as setting the cursor in a parent window also effects the
2812 windows above so that checking for the current cursor is
2813 not possible. */
2814
2815 if (m_wxwindow)
2816 {
2817 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
2818 if (window)
2819 gdk_window_set_cursor( window, cursor.GetCursor() );
2820
2821 if (!g_globalCursor.Ok())
2822 cursor = *wxSTANDARD_CURSOR;
2823
2824 window = m_widget->window;
2825 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2826 gdk_window_set_cursor( window, cursor.GetCursor() );
2827
2828 }
2829 else
2830 {
2831
2832 GdkWindow *window = m_widget->window;
2833 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
2834 gdk_window_set_cursor( window, cursor.GetCursor() );
2835
2836 }
2837 }
2838
2839 UpdateWindowUI();
2840}
2841
2842void wxWindowGTK::DoGetSize( int *width, int *height ) const
2843{
2844 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2845
2846 if (width) (*width) = m_width;
2847 if (height) (*height) = m_height;
2848}
2849
2850void wxWindowGTK::DoSetClientSize( int width, int height )
2851{
2852 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2853
2854 if (!m_wxwindow)
2855 {
2856 SetSize( width, height );
2857 }
2858 else
2859 {
2860 int dw = 0;
2861 int dh = 0;
2862
2863#ifndef __WXUNIVERSAL__
2864 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2865 {
2866 /* when using GTK 1.2 we set the shadow border size to 2 */
2867 dw += 2 * 2;
2868 dh += 2 * 2;
2869 }
2870 if (HasFlag(wxSIMPLE_BORDER))
2871 {
2872 /* when using GTK 1.2 we set the simple border size to 1 */
2873 dw += 1 * 2;
2874 dh += 1 * 2;
2875 }
2876#endif // __WXUNIVERSAL__
2877
2878 if (m_hasScrolling)
2879 {
2880 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2881
2882 GtkRequisition vscroll_req;
2883 vscroll_req.width = 2;
2884 vscroll_req.height = 2;
2885 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
2886 (scroll_window->vscrollbar, &vscroll_req );
2887
2888 GtkRequisition hscroll_req;
2889 hscroll_req.width = 2;
2890 hscroll_req.height = 2;
2891 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
2892 (scroll_window->hscrollbar, &hscroll_req );
2893
2894 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2895
2896 if (scroll_window->vscrollbar_visible)
2897 {
2898 dw += vscroll_req.width;
2899 dw += scroll_class->scrollbar_spacing;
2900 }
2901
2902 if (scroll_window->hscrollbar_visible)
2903 {
2904 dh += hscroll_req.height;
2905 dh += scroll_class->scrollbar_spacing;
2906 }
2907 }
2908
2909 SetSize( width+dw, height+dh );
2910 }
2911}
2912
2913void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
2914{
2915 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2916
2917 if (!m_wxwindow)
2918 {
2919 if (width) (*width) = m_width;
2920 if (height) (*height) = m_height;
2921 }
2922 else
2923 {
2924 int dw = 0;
2925 int dh = 0;
2926
2927#ifndef __WXUNIVERSAL__
2928 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2929 {
2930 /* when using GTK 1.2 we set the shadow border size to 2 */
2931 dw += 2 * 2;
2932 dh += 2 * 2;
2933 }
2934 if (HasFlag(wxSIMPLE_BORDER))
2935 {
2936 /* when using GTK 1.2 we set the simple border size to 1 */
2937 dw += 1 * 2;
2938 dh += 1 * 2;
2939 }
2940#endif // __WXUNIVERSAL__
2941
2942 if (m_hasScrolling)
2943 {
2944 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2945
2946 GtkRequisition vscroll_req;
2947 vscroll_req.width = 2;
2948 vscroll_req.height = 2;
2949 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
2950 (scroll_window->vscrollbar, &vscroll_req );
2951
2952 GtkRequisition hscroll_req;
2953 hscroll_req.width = 2;
2954 hscroll_req.height = 2;
2955 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
2956 (scroll_window->hscrollbar, &hscroll_req );
2957
2958 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
2959
2960 if (scroll_window->vscrollbar_visible)
2961 {
2962 dw += vscroll_req.width;
2963 dw += scroll_class->scrollbar_spacing;
2964 }
2965
2966 if (scroll_window->hscrollbar_visible)
2967 {
2968 dh += hscroll_req.height;
2969 dh += scroll_class->scrollbar_spacing;
2970 }
2971 }
2972
2973 if (width) (*width) = m_width - dw;
2974 if (height) (*height) = m_height - dh;
2975 }
2976
2977/*
2978 printf( "GetClientSize, name %s ", GetName().c_str() );
2979 if (width) printf( " width = %d", (*width) );
2980 if (height) printf( " height = %d", (*height) );
2981 printf( "\n" );
2982*/
2983}
2984
2985void wxWindowGTK::DoGetPosition( int *x, int *y ) const
2986{
2987 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
2988
2989 int dx = 0;
2990 int dy = 0;
2991 if (m_parent && m_parent->m_wxwindow)
2992 {
2993 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
2994 dx = pizza->xoffset;
2995 dy = pizza->yoffset;
2996 }
2997
2998 if (x) (*x) = m_x - dx;
2999 if (y) (*y) = m_y - dy;
3000}
3001
3002void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
3003{
3004 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3005
3006 if (!m_widget->window) return;
3007
3008 GdkWindow *source = (GdkWindow *) NULL;
3009 if (m_wxwindow)
3010 source = GTK_PIZZA(m_wxwindow)->bin_window;
3011 else
3012 source = m_widget->window;
3013
3014 int org_x = 0;
3015 int org_y = 0;
3016 gdk_window_get_origin( source, &org_x, &org_y );
3017
3018 if (!m_wxwindow)
3019 {
3020 if (GTK_WIDGET_NO_WINDOW (m_widget))
3021 {
3022 org_x += m_widget->allocation.x;
3023 org_y += m_widget->allocation.y;
3024 }
3025 }
3026
3027 if (x) *x += org_x;
3028 if (y) *y += org_y;
3029}
3030
3031void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
3032{
3033 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3034
3035 if (!m_widget->window) return;
3036
3037 GdkWindow *source = (GdkWindow *) NULL;
3038 if (m_wxwindow)
3039 source = GTK_PIZZA(m_wxwindow)->bin_window;
3040 else
3041 source = m_widget->window;
3042
3043 int org_x = 0;
3044 int org_y = 0;
3045 gdk_window_get_origin( source, &org_x, &org_y );
3046
3047 if (!m_wxwindow)
3048 {
3049 if (GTK_WIDGET_NO_WINDOW (m_widget))
3050 {
3051 org_x += m_widget->allocation.x;
3052 org_y += m_widget->allocation.y;
3053 }
3054 }
3055
3056 if (x) *x -= org_x;
3057 if (y) *y -= org_y;
3058}
3059
3060bool wxWindowGTK::Show( bool show )
3061{
3062 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3063
3064 if (!wxWindowBase::Show(show))
3065 {
3066 // nothing to do
3067 return FALSE;
3068 }
3069
3070 if (show)
3071 gtk_widget_show( m_widget );
3072 else
3073 gtk_widget_hide( m_widget );
3074
3075 return TRUE;
3076}
3077
3078static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
3079{
3080 win->OnParentEnable(enable);
3081
3082 // Recurse, so that children have the opportunity to Do The Right Thing
3083 // and reset colours that have been messed up by a parent's (really ancestor's)
3084 // Enable call
3085 for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
3086 node;
3087 node = node->GetNext() )
3088 {
3089 wxWindow *child = node->GetData();
3090 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3091 wxWindowNotifyEnable(child, enable);
3092 }
3093}
3094
3095bool wxWindowGTK::Enable( bool enable )
3096{
3097 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3098
3099 if (!wxWindowBase::Enable(enable))
3100 {
3101 // nothing to do
3102 return FALSE;
3103 }
3104
3105 gtk_widget_set_sensitive( m_widget, enable );
3106 if ( m_wxwindow )
3107 gtk_widget_set_sensitive( m_wxwindow, enable );
3108
3109 wxWindowNotifyEnable(this, enable);
3110
3111 return TRUE;
3112}
3113
3114int wxWindowGTK::GetCharHeight() const
3115{
3116 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
3117
3118 wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
3119
3120 GdkFont *font = m_font.GetInternalFont( 1.0 );
3121
3122 return font->ascent + font->descent;
3123}
3124
3125int wxWindowGTK::GetCharWidth() const
3126{
3127 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
3128
3129 wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
3130
3131 GdkFont *font = m_font.GetInternalFont( 1.0 );
3132
3133 return gdk_string_width( font, "H" );
3134}
3135
3136void wxWindowGTK::GetTextExtent( const wxString& string,
3137 int *x,
3138 int *y,
3139 int *descent,
3140 int *externalLeading,
3141 const wxFont *theFont ) const
3142{
3143 wxFont fontToUse = m_font;
3144 if (theFont) fontToUse = *theFont;
3145
3146 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
3147
3148 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
3149 if (x) (*x) = gdk_string_width( font, string.mbc_str() );
3150 if (y) (*y) = font->ascent + font->descent;
3151 if (descent) (*descent) = font->descent;
3152 if (externalLeading) (*externalLeading) = 0; // ??
3153}
3154
3155void wxWindowGTK::SetFocus()
3156{
3157 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3158
3159 if ( m_hasFocus )
3160 {
3161 // don't do anything if we already have focus
3162 return;
3163 }
3164
3165 if (m_wxwindow)
3166 {
3167 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
3168 {
3169 gtk_widget_grab_focus (m_wxwindow);
3170 }
3171 }
3172 else if (m_widget)
3173 {
3174 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
3175 {
3176 if (!GTK_WIDGET_REALIZED(m_widget))
3177 {
3178 // we can't set the focus to the widget now so we remember that
3179 // it should be focused and will do it later, during the idle
3180 // time, as soon as we can
3181 wxLogTrace(TRACE_FOCUS,
3182 _T("Delaying setting focus to %s(%s)"),
3183 GetClassInfo()->GetClassName(), GetLabel().c_str());
3184
3185 g_delayedFocus = this;
3186 }
3187 else
3188 {
3189 wxLogTrace(TRACE_FOCUS,
3190 _T("Setting focus to %s(%s)"),
3191 GetClassInfo()->GetClassName(), GetLabel().c_str());
3192
3193 gtk_widget_grab_focus (m_widget);
3194 }
3195 }
3196 else if (GTK_IS_CONTAINER(m_widget))
3197 {
3198 SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );
3199 }
3200 else
3201 {
3202 wxLogTrace(TRACE_FOCUS,
3203 _T("Can't set focus to %s(%s)"),
3204 GetClassInfo()->GetClassName(), GetLabel().c_str());
3205 }
3206 }
3207}
3208
3209bool wxWindowGTK::AcceptsFocus() const
3210{
3211 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
3212}
3213
3214bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
3215{
3216 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3217
3218 wxWindowGTK *oldParent = m_parent,
3219 *newParent = (wxWindowGTK *)newParentBase;
3220
3221 wxASSERT( GTK_IS_WIDGET(m_widget) );
3222
3223 if ( !wxWindowBase::Reparent(newParent) )
3224 return FALSE;
3225
3226 wxASSERT( GTK_IS_WIDGET(m_widget) );
3227
3228 /* prevent GTK from deleting the widget arbitrarily */
3229 gtk_widget_ref( m_widget );
3230
3231 if (oldParent)
3232 {
3233 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
3234 }
3235
3236 wxASSERT( GTK_IS_WIDGET(m_widget) );
3237
3238 if (newParent)
3239 {
3240 /* insert GTK representation */
3241 (*(newParent->m_insertCallback))(newParent, this);
3242 }
3243
3244 /* reverse: prevent GTK from deleting the widget arbitrarily */
3245 gtk_widget_unref( m_widget );
3246
3247 return TRUE;
3248}
3249
3250void wxWindowGTK::DoAddChild(wxWindowGTK *child)
3251{
3252 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
3253
3254 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
3255
3256 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
3257
3258 /* add to list */
3259 AddChild( child );
3260
3261 /* insert GTK representation */
3262 (*m_insertCallback)(this, child);
3263}
3264
3265void wxWindowGTK::Raise()
3266{
3267 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3268
3269 if (!m_widget->window) return;
3270
3271 gdk_window_raise( m_widget->window );
3272}
3273
3274void wxWindowGTK::Lower()
3275{
3276 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3277
3278 if (!m_widget->window) return;
3279
3280 gdk_window_lower( m_widget->window );
3281}
3282
3283bool wxWindowGTK::SetCursor( const wxCursor &cursor )
3284{
3285 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
3286
3287 if (cursor == m_cursor)
3288 return FALSE;
3289
3290 if (g_isIdle)
3291 wxapp_install_idle_handler();
3292
3293 if (cursor == wxNullCursor)
3294 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3295 else
3296 return wxWindowBase::SetCursor( cursor );
3297}
3298
3299void wxWindowGTK::WarpPointer( int x, int y )
3300{
3301 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
3302
3303 // We provide this function ourselves as it is
3304 // missing in GDK (top of this file).
3305
3306 GdkWindow *window = (GdkWindow*) NULL;
3307 if (m_wxwindow)
3308 window = GTK_PIZZA(m_wxwindow)->bin_window;
3309 else
3310 window = GetConnectWidget()->window;
3311
3312 if (window)
3313 gdk_window_warp_pointer( window, x, y );
3314}
3315
3316void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
3317{
3318 if (!m_widget) return;
3319 if (!m_widget->window) return;
3320
3321#ifndef __WXGTK20__
3322 if (g_isIdle)
3323 wxapp_install_idle_handler();
3324
3325 if (eraseBackground && m_wxwindow && m_wxwindow->window)
3326 {
3327 if (rect)
3328 {
3329 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3330 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
3331 }
3332 else
3333 {
3334 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3335 m_clearRegion.Clear();
3336 m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3337 }
3338 }
3339
3340 if (rect)
3341 {
3342 if (m_wxwindow)
3343 {
3344 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3345 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
3346 }
3347 else
3348 {
3349 GdkRectangle gdk_rect;
3350 gdk_rect.x = rect->x;
3351 gdk_rect.y = rect->y;
3352 gdk_rect.width = rect->width;
3353 gdk_rect.height = rect->height;
3354 gtk_widget_draw( m_widget, &gdk_rect );
3355 }
3356 }
3357 else
3358 {
3359 if (m_wxwindow)
3360 {
3361 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3362 m_updateRegion.Clear();
3363 m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
3364 }
3365 else
3366 {
3367 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
3368 }
3369 }
3370#else
3371 if (m_wxwindow)
3372 {
3373 if (rect)
3374 {
3375 GdkRectangle gdk_rect;
3376 gdk_rect.x = rect->x;
3377 gdk_rect.y = rect->y;
3378 gdk_rect.width = rect->width;
3379 gdk_rect.height = rect->height;
3380 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
3381 }
3382 else
3383 {
3384 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
3385 }
3386 }
3387#endif
3388}
3389
3390void wxWindowGTK::Update()
3391{
3392 GtkUpdate();
3393}
3394
3395void wxWindowGTK::GtkUpdate()
3396{
3397#ifdef __WXGTK20__
3398 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3399 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
3400#endif
3401
3402 if (!m_updateRegion.IsEmpty())
3403 GtkSendPaintEvents();
3404}
3405
3406void wxWindowGTK::GtkSendPaintEvents()
3407{
3408 if (!m_wxwindow)
3409 {
3410 m_clearRegion.Clear();
3411 m_updateRegion.Clear();
3412 return;
3413 }
3414
3415 // widget to draw on
3416 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
3417
3418 // Clip to paint region in wxClientDC
3419 m_clipPaintRegion = TRUE;
3420
3421 if (GetThemeEnabled())
3422 {
3423 // find ancestor from which to steal background
3424 wxWindow *parent = GetParent();
3425 while (parent && !parent->IsTopLevel())
3426 parent = parent->GetParent();
3427 if (!parent)
3428 parent = (wxWindow*)this;
3429
3430 wxRegionIterator upd( m_updateRegion );
3431 while (upd)
3432 {
3433 GdkRectangle rect;
3434 rect.x = upd.GetX();
3435 rect.y = upd.GetY();
3436 rect.width = upd.GetWidth();
3437 rect.height = upd.GetHeight();
3438
3439 gtk_paint_flat_box( parent->m_widget->style,
3440 pizza->bin_window,
3441 GTK_STATE_NORMAL,
3442 GTK_SHADOW_NONE,
3443 &rect,
3444 parent->m_widget,
3445 (char *)"base",
3446 0, 0, -1, -1 );
3447
3448 upd ++;
3449 }
3450 }
3451 else
3452 // if (!m_clearRegion.IsEmpty()) // always send an erase event
3453 {
3454 wxWindowDC dc( (wxWindow*)this );
3455 dc.SetClippingRegion( m_clearRegion );
3456
3457 wxEraseEvent erase_event( GetId(), &dc );
3458 erase_event.SetEventObject( this );
3459
3460 if (!GetEventHandler()->ProcessEvent(erase_event))
3461 {
3462 if (!g_eraseGC)
3463 {
3464 g_eraseGC = gdk_gc_new( pizza->bin_window );
3465 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
3466 }
3467 gdk_gc_set_foreground( g_eraseGC, m_backgroundColour.GetColor() );
3468
3469 wxRegionIterator upd( m_clearRegion );
3470 while (upd)
3471 {
3472 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
3473 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
3474 upd ++;
3475 }
3476 }
3477 m_clearRegion.Clear();
3478 }
3479
3480 wxNcPaintEvent nc_paint_event( GetId() );
3481 nc_paint_event.SetEventObject( this );
3482 GetEventHandler()->ProcessEvent( nc_paint_event );
3483
3484 wxPaintEvent paint_event( GetId() );
3485 paint_event.SetEventObject( this );
3486 GetEventHandler()->ProcessEvent( paint_event );
3487
3488 m_clipPaintRegion = FALSE;
3489
3490#ifndef __WXUNIVERSAL__
3491#ifndef __WXGTK20__
3492 // The following code will result in all window-less widgets
3493 // being redrawn because the wxWindows class is allowed to
3494 // paint over the window-less widgets.
3495
3496 GList *children = pizza->children;
3497 while (children)
3498 {
3499 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
3500 children = children->next;
3501
3502 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
3503 GTK_WIDGET_DRAWABLE (child->widget))
3504 {
3505 // Get intersection of widget area and update region
3506 wxRegion region( m_updateRegion );
3507
3508 GdkEventExpose gdk_event;
3509 gdk_event.type = GDK_EXPOSE;
3510 gdk_event.window = pizza->bin_window;
3511 gdk_event.count = 0;
3512
3513 wxRegionIterator upd( m_updateRegion );
3514 while (upd)
3515 {
3516 GdkRectangle rect;
3517 rect.x = upd.GetX();
3518 rect.y = upd.GetY();
3519 rect.width = upd.GetWidth();
3520 rect.height = upd.GetHeight();
3521
3522 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
3523 {
3524 gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
3525 }
3526
3527 upd ++;
3528 }
3529 }
3530 }
3531#endif
3532#endif
3533
3534 m_updateRegion.Clear();
3535}
3536
3537void wxWindowGTK::Clear()
3538{
3539 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3540
3541 if (m_wxwindow && m_wxwindow->window)
3542 {
3543 m_clearRegion.Clear();
3544 wxSize size( GetClientSize() );
3545 m_clearRegion.Union( 0,0,size.x,size.y );
3546
3547 // Better do this in idle?
3548 GtkUpdate();
3549 }
3550}
3551
3552#if wxUSE_TOOLTIPS
3553void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
3554{
3555 wxWindowBase::DoSetToolTip(tip);
3556
3557 if (m_tooltip)
3558 m_tooltip->Apply( (wxWindow *)this );
3559}
3560
3561void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
3562{
3563 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
3564}
3565#endif // wxUSE_TOOLTIPS
3566
3567void wxWindowGTK::GtkSetBackgroundColour( const wxColour &colour )
3568{
3569 GdkWindow *window = (GdkWindow*) NULL;
3570 if (m_wxwindow)
3571 window = GTK_PIZZA(m_wxwindow)->bin_window;
3572 else
3573 window = GetConnectWidget()->window;
3574
3575 wxASSERT( window );
3576
3577 // We need the pixel value e.g. for background clearing.
3578 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
3579
3580 if (m_wxwindow)
3581 {
3582 // wxMSW doesn't clear the window here, either.
3583 gdk_window_set_background( window, m_backgroundColour.GetColor() );
3584 }
3585
3586 ApplyWidgetStyle();
3587}
3588
3589bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
3590{
3591 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3592
3593 if (!wxWindowBase::SetBackgroundColour(colour))
3594 return FALSE;
3595
3596 GdkWindow *window = (GdkWindow*) NULL;
3597 if (m_wxwindow)
3598 window = GTK_PIZZA(m_wxwindow)->bin_window;
3599 else
3600 window = GetConnectWidget()->window;
3601
3602 if (!window)
3603 {
3604 // indicate that a new style has been set
3605 // but it couldn't get applied as the
3606 // widget hasn't been realized yet.
3607 m_delayedBackgroundColour = TRUE;
3608 return TRUE;
3609 }
3610 else
3611 {
3612 GtkSetBackgroundColour( colour );
3613 }
3614
3615 return TRUE;
3616}
3617
3618void wxWindowGTK::GtkSetForegroundColour( const wxColour &colour )
3619{
3620 GdkWindow *window = (GdkWindow*) NULL;
3621 if (m_wxwindow)
3622 window = GTK_PIZZA(m_wxwindow)->bin_window;
3623 else
3624 window = GetConnectWidget()->window;
3625
3626 wxASSERT( window );
3627
3628 ApplyWidgetStyle();
3629}
3630
3631bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
3632{
3633 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3634
3635 if (!wxWindowBase::SetForegroundColour(colour))
3636 {
3637 // don't leave if the GTK widget has just
3638 // been realized
3639 if (!m_delayedForegroundColour) return FALSE;
3640 }
3641
3642 GdkWindow *window = (GdkWindow*) NULL;
3643 if (m_wxwindow)
3644 window = GTK_PIZZA(m_wxwindow)->bin_window;
3645 else
3646 window = GetConnectWidget()->window;
3647
3648 if (!window)
3649 {
3650 // indicate that a new style has been set
3651 // but it couldn't get applied as the
3652 // widget hasn't been realized yet.
3653 m_delayedForegroundColour = TRUE;
3654 }
3655 else
3656 {
3657 GtkSetForegroundColour( colour );
3658 }
3659
3660 return TRUE;
3661}
3662
3663GtkStyle *wxWindowGTK::GetWidgetStyle()
3664{
3665 if (m_widgetStyle)
3666 {
3667 GtkStyle *remake = gtk_style_copy( m_widgetStyle );
3668
3669 // FIXME: no more klass in 2.0
3670#ifndef __WXGTK20__
3671 remake->klass = m_widgetStyle->klass;
3672#endif
3673
3674 gtk_style_unref( m_widgetStyle );
3675 m_widgetStyle = remake;
3676 }
3677 else
3678 {
3679 GtkStyle *def = gtk_rc_get_style( m_widget );
3680
3681 if (!def)
3682 def = gtk_widget_get_default_style();
3683
3684 m_widgetStyle = gtk_style_copy( def );
3685
3686 // FIXME: no more klass in 2.0
3687#ifndef __WXGTK20__
3688 m_widgetStyle->klass = def->klass;
3689#endif
3690 }
3691
3692 return m_widgetStyle;
3693}
3694
3695void wxWindowGTK::SetWidgetStyle()
3696{
3697#if DISABLE_STYLE_IF_BROKEN_THEME
3698 if (m_widget->style->engine_data)
3699 {
3700 static bool s_warningPrinted = FALSE;
3701 if (!s_warningPrinted)
3702 {
3703 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
3704 s_warningPrinted = TRUE;
3705 }
3706 m_widgetStyle = m_widget->style;
3707 return;
3708 }
3709#endif
3710
3711 GtkStyle *style = GetWidgetStyle();
3712
3713 if (m_font != wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ))
3714 {
3715 SET_STYLE_FONT(style, m_font.GetInternalFont( 1.0 ));
3716 }
3717
3718 if (m_foregroundColour.Ok())
3719 {
3720 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
3721 if (m_foregroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT))
3722 {
3723 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
3724 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
3725 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
3726 }
3727 else
3728 {
3729 // Try to restore the gtk default style. This is still a little
3730 // oversimplified for what is probably really needed here for controls
3731 // other than buttons, but is better than not being able to (re)set a
3732 // control's foreground colour to *wxBLACK -- RL
3733 GtkStyle *def = gtk_rc_get_style( m_widget );
3734
3735 if (!def)
3736 def = gtk_widget_get_default_style();
3737
3738 style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
3739 style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
3740 style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
3741 }
3742 }
3743
3744 if (m_backgroundColour.Ok())
3745 {
3746 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
3747 if (m_backgroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE))
3748 {
3749 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
3750 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
3751 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
3752 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
3753 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
3754 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
3755 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
3756 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
3757 }
3758 else
3759 {
3760 // Try to restore the gtk default style. This is still a little
3761 // oversimplified for what is probably really needed here for controls
3762 // other than buttons, but is better than not being able to (re)set a
3763 // control's background colour to default grey and means resetting a
3764 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
3765 // behavior -- RL
3766 GtkStyle *def = gtk_rc_get_style( m_widget );
3767
3768 if (!def)
3769 def = gtk_widget_get_default_style();
3770
3771 style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
3772 style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
3773 style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
3774 style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
3775 style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
3776 style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
3777 style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
3778 style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
3779 }
3780 }
3781}
3782
3783void wxWindowGTK::ApplyWidgetStyle()
3784{
3785}
3786
3787//-----------------------------------------------------------------------------
3788// Pop-up menu stuff
3789//-----------------------------------------------------------------------------
3790
3791#if wxUSE_MENUS_NATIVE
3792
3793extern "C"
3794void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
3795{
3796 *is_waiting = FALSE;
3797}
3798
3799static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
3800{
3801 menu->SetInvokingWindow( win );
3802 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
3803 while (node)
3804 {
3805 wxMenuItem *menuitem = node->GetData();
3806 if (menuitem->IsSubMenu())
3807 {
3808 SetInvokingWindow( menuitem->GetSubMenu(), win );
3809 }
3810
3811 node = node->GetNext();
3812 }
3813}
3814
3815// used to pass the coordinates from wxWindowGTK::DoPopupMenu() to
3816// wxPopupMenuPositionCallback()
3817//
3818// should be safe even in the MT case as the user can hardly popup 2 menus
3819// simultaneously, can he?
3820static gint gs_pop_x = 0;
3821static gint gs_pop_y = 0;
3822
3823extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
3824 gint *x, gint *y,
3825#ifdef __WXGTK20__
3826 gboolean * WXUNUSED(whatever),
3827#endif
3828 gpointer WXUNUSED(user_data) )
3829{
3830 // ensure that the menu appears entirely on screen
3831 GtkRequisition req;
3832 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
3833
3834 wxSize sizeScreen = wxGetDisplaySize();
3835
3836 gint xmax = sizeScreen.x - req.width,
3837 ymax = sizeScreen.y - req.height;
3838
3839 *x = gs_pop_x < xmax ? gs_pop_x : xmax;
3840 *y = gs_pop_y < ymax ? gs_pop_y : ymax;
3841}
3842
3843bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
3844{
3845 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3846
3847 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
3848
3849 SetInvokingWindow( menu, this );
3850
3851 menu->UpdateUI();
3852
3853 gs_pop_x = x;
3854 gs_pop_y = y;
3855 ClientToScreen( &gs_pop_x, &gs_pop_y );
3856
3857 bool is_waiting = TRUE;
3858
3859 gtk_signal_connect( GTK_OBJECT(menu->m_menu),
3860 "hide",
3861 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
3862 (gpointer)&is_waiting );
3863
3864 gtk_menu_popup(
3865 GTK_MENU(menu->m_menu),
3866 (GtkWidget *) NULL, // parent menu shell
3867 (GtkWidget *) NULL, // parent menu item
3868 wxPopupMenuPositionCallback, // function to position it
3869 NULL, // client data
3870 0, // button used to activate it
3871 gs_timeLastClick // the time of activation
3872 );
3873
3874 while (is_waiting)
3875 {
3876 while (gtk_events_pending())
3877 gtk_main_iteration();
3878 }
3879
3880 return TRUE;
3881}
3882
3883#endif // wxUSE_MENUS_NATIVE
3884
3885#if wxUSE_DRAG_AND_DROP
3886
3887void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
3888{
3889 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3890
3891 GtkWidget *dnd_widget = GetConnectWidget();
3892
3893 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
3894
3895 if (m_dropTarget) delete m_dropTarget;
3896 m_dropTarget = dropTarget;
3897
3898 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
3899}
3900
3901#endif // wxUSE_DRAG_AND_DROP
3902
3903GtkWidget* wxWindowGTK::GetConnectWidget()
3904{
3905 GtkWidget *connect_widget = m_widget;
3906 if (m_wxwindow) connect_widget = m_wxwindow;
3907
3908 return connect_widget;
3909}
3910
3911bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
3912{
3913 if (m_wxwindow)
3914 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
3915
3916 return (window == m_widget->window);
3917}
3918
3919bool wxWindowGTK::SetFont( const wxFont &font )
3920{
3921 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
3922
3923 if (!wxWindowBase::SetFont(font))
3924 {
3925 return FALSE;
3926 }
3927
3928 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
3929 if ( sysbg == m_backgroundColour )
3930 {
3931 m_backgroundColour = wxNullColour;
3932 ApplyWidgetStyle();
3933 m_backgroundColour = sysbg;
3934 }
3935 else
3936 {
3937 ApplyWidgetStyle();
3938 }
3939
3940 return TRUE;
3941}
3942
3943void wxWindowGTK::DoCaptureMouse()
3944{
3945 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3946
3947 GdkWindow *window = (GdkWindow*) NULL;
3948 if (m_wxwindow)
3949 window = GTK_PIZZA(m_wxwindow)->bin_window;
3950 else
3951 window = GetConnectWidget()->window;
3952
3953 wxCHECK_RET( window, _T("CaptureMouse() failed") );
3954
3955 wxCursor* cursor = & m_cursor;
3956 if (!cursor->Ok())
3957 cursor = wxSTANDARD_CURSOR;
3958
3959 gdk_pointer_grab( window, FALSE,
3960 (GdkEventMask)
3961 (GDK_BUTTON_PRESS_MASK |
3962 GDK_BUTTON_RELEASE_MASK |
3963 GDK_POINTER_MOTION_HINT_MASK |
3964 GDK_POINTER_MOTION_MASK),
3965 (GdkWindow *) NULL,
3966 cursor->GetCursor(),
3967 (guint32)GDK_CURRENT_TIME );
3968 g_captureWindow = this;
3969 g_captureWindowHasMouse = TRUE;
3970}
3971
3972void wxWindowGTK::DoReleaseMouse()
3973{
3974 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3975
3976 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
3977
3978 g_captureWindow = (wxWindowGTK*) NULL;
3979
3980 GdkWindow *window = (GdkWindow*) NULL;
3981 if (m_wxwindow)
3982 window = GTK_PIZZA(m_wxwindow)->bin_window;
3983 else
3984 window = GetConnectWidget()->window;
3985
3986 if (!window)
3987 return;
3988
3989 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
3990}
3991
3992/* static */
3993wxWindow *wxWindowBase::GetCapture()
3994{
3995 return (wxWindow *)g_captureWindow;
3996}
3997
3998bool wxWindowGTK::IsRetained() const
3999{
4000 return FALSE;
4001}
4002
4003void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
4004 int range, bool refresh )
4005{
4006 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4007
4008 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4009
4010 m_hasScrolling = TRUE;
4011
4012 if (orient == wxHORIZONTAL)
4013 {
4014 float fpos = (float)pos;
4015 float frange = (float)range;
4016 float fthumb = (float)thumbVisible;
4017 if (fpos > frange-fthumb) fpos = frange-fthumb;
4018 if (fpos < 0.0) fpos = 0.0;
4019
4020 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
4021 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
4022 {
4023 SetScrollPos( orient, pos, refresh );
4024 return;
4025 }
4026
4027 m_oldHorizontalPos = fpos;
4028
4029 m_hAdjust->lower = 0.0;
4030 m_hAdjust->upper = frange;
4031 m_hAdjust->value = fpos;
4032 m_hAdjust->step_increment = 1.0;
4033 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
4034 m_hAdjust->page_size = fthumb;
4035 }
4036 else
4037 {
4038 float fpos = (float)pos;
4039 float frange = (float)range;
4040 float fthumb = (float)thumbVisible;
4041 if (fpos > frange-fthumb) fpos = frange-fthumb;
4042 if (fpos < 0.0) fpos = 0.0;
4043
4044 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4045 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4046 {
4047 SetScrollPos( orient, pos, refresh );
4048 return;
4049 }
4050
4051 m_oldVerticalPos = fpos;
4052
4053 m_vAdjust->lower = 0.0;
4054 m_vAdjust->upper = frange;
4055 m_vAdjust->value = fpos;
4056 m_vAdjust->step_increment = 1.0;
4057 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4058 m_vAdjust->page_size = fthumb;
4059 }
4060
4061 if (orient == wxHORIZONTAL)
4062 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4063 else
4064 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
4065}
4066
4067void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
4068{
4069 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4070
4071 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4072
4073 if (orient == wxHORIZONTAL)
4074 {
4075 float fpos = (float)pos;
4076 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
4077 if (fpos < 0.0) fpos = 0.0;
4078 m_oldHorizontalPos = fpos;
4079
4080 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
4081 m_hAdjust->value = fpos;
4082 }
4083 else
4084 {
4085 float fpos = (float)pos;
4086 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
4087 if (fpos < 0.0) fpos = 0.0;
4088 m_oldVerticalPos = fpos;
4089
4090 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
4091 m_vAdjust->value = fpos;
4092 }
4093
4094 if (m_wxwindow->window)
4095 {
4096 if (orient == wxHORIZONTAL)
4097 {
4098 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
4099 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4100
4101 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
4102
4103 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
4104 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4105 }
4106 else
4107 {
4108 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
4109 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4110
4111 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
4112
4113 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
4114 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4115 }
4116 }
4117}
4118
4119int wxWindowGTK::GetScrollThumb( int orient ) const
4120{
4121 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4122
4123 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4124
4125 if (orient == wxHORIZONTAL)
4126 return (int)(m_hAdjust->page_size+0.5);
4127 else
4128 return (int)(m_vAdjust->page_size+0.5);
4129}
4130
4131int wxWindowGTK::GetScrollPos( int orient ) const
4132{
4133 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4134
4135 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4136
4137 if (orient == wxHORIZONTAL)
4138 return (int)(m_hAdjust->value+0.5);
4139 else
4140 return (int)(m_vAdjust->value+0.5);
4141}
4142
4143int wxWindowGTK::GetScrollRange( int orient ) const
4144{
4145 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
4146
4147 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
4148
4149 if (orient == wxHORIZONTAL)
4150 return (int)(m_hAdjust->upper+0.5);
4151 else
4152 return (int)(m_vAdjust->upper+0.5);
4153}
4154
4155void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
4156{
4157 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4158
4159 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
4160
4161 // No scrolling requested.
4162 if ((dx == 0) && (dy == 0)) return;
4163
4164#ifndef __WXGTK20__
4165 if (!m_updateRegion.IsEmpty())
4166 {
4167 m_updateRegion.Offset( dx, dy );
4168
4169 int cw = 0;
4170 int ch = 0;
4171 GetClientSize( &cw, &ch );
4172 m_updateRegion.Intersect( 0, 0, cw, ch );
4173 }
4174
4175 if (!m_clearRegion.IsEmpty())
4176 {
4177 m_clearRegion.Offset( dx, dy );
4178
4179 int cw = 0;
4180 int ch = 0;
4181 GetClientSize( &cw, &ch );
4182 m_clearRegion.Intersect( 0, 0, cw, ch );
4183 }
4184 m_clipPaintRegion = TRUE;
4185
4186 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
4187
4188 m_clipPaintRegion = FALSE;
4189#else
4190
4191 gdk_window_scroll( GTK_PIZZA(m_wxwindow)->bin_window, dx, dy );
4192
4193 GTK_PIZZA(m_wxwindow)->xoffset += dx;
4194 GTK_PIZZA(m_wxwindow)->yoffset += dy;
4195
4196#endif
4197
4198}
4199
4200
4201// Find the wxWindow at the current mouse position, also returning the mouse
4202// position.
4203wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4204{
4205 pt = wxGetMousePosition();
4206 wxWindow* found = wxFindWindowAtPoint(pt);
4207 return found;
4208}
4209
4210// Get the current mouse position.
4211wxPoint wxGetMousePosition()
4212{
4213 /* This crashes when used within wxHelpContext,
4214 so we have to use the X-specific implementation below.
4215 gint x, y;
4216 GdkModifierType *mask;
4217 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4218
4219 return wxPoint(x, y);
4220 */
4221
4222 int x, y;
4223 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
4224 if (!windowAtPtr)
4225 return wxPoint(-999, -999);
4226
4227 Display *display = GDK_WINDOW_XDISPLAY(windowAtPtr);
4228 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4229 Window rootReturn, childReturn;
4230 int rootX, rootY, winX, winY;
4231 unsigned int maskReturn;
4232
4233 XQueryPointer (display,
4234 rootWindow,
4235 &rootReturn,
4236 &childReturn,
4237 &rootX, &rootY, &winX, &winY, &maskReturn);
4238 return wxPoint(rootX, rootY);
4239
4240}
4241
4242// ----------------------------------------------------------------------------
4243// wxDCModule
4244// ----------------------------------------------------------------------------
4245
4246class wxWinModule : public wxModule
4247{
4248public:
4249 bool OnInit();
4250 void OnExit();
4251
4252private:
4253 DECLARE_DYNAMIC_CLASS(wxWinModule)
4254};
4255
4256IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4257
4258bool wxWinModule::OnInit()
4259{
4260 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4261 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
4262
4263 return TRUE;
4264}
4265
4266void wxWinModule::OnExit()
4267{
4268 if (g_eraseGC)
4269 gdk_gc_unref( g_eraseGC );
4270}
4271
4272// vi:sts=4:sw=4:et
wxWidgets (Impactor)