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