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