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