]> git.saurik.com Git - wxWidgets.git/blame - src/gtk/window.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Calling a Refresh() before the window is created no longer
[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
3ed2e7ce
VZ		 1657#ifdef HAVE_XIM
1658 #define WXUNUSED_UNLESS_XIM(param) param
1659#else
1660 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
1661#endif
1662
b79395c5
RR		 1663/* Resize XIM window */
1664
3ed2e7ce
VZ		 1665static
1666void gtk_wxwindow_size_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
1667 GtkAllocation * WXUNUSED_UNLESS_XIM(alloc),
1668 wxFrame * WXUNUSED_UNLESS_XIM(win) )
b79395c5
RR		 1669{
1670 if (g_isIdle)
1671 wxapp_install_idle_handler();
1672
9a8c7620 1673#ifdef HAVE_XIM
b79395c5
RR		 1674 if (!win->m_ic)
1675 return;
1676
b79395c5
RR		 1677 if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
1678 {
1679 gint width, height;
1680
3ed2e7ce 1681 gdk_window_get_size (widget->window, &width, &height);
b79395c5
RR		 1682 win->m_icattr->preedit_area.width = width;
1683 win->m_icattr->preedit_area.height = height;
1684 gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
1685 }
9a8c7620 1686#endif // HAVE_XIM
b79395c5
RR		 1687}
1688
63081513
RR		 1689//-----------------------------------------------------------------------------
1690// "realize" from m_wxwindow
1691//-----------------------------------------------------------------------------
1692
1693/* Initialize XIM support */
1694
1695static gint
3ed2e7ce
VZ		 1696gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
1697 wxWindow * WXUNUSED_UNLESS_XIM(win) )
63081513
RR		 1698{
1699 if (g_isIdle)
1700 wxapp_install_idle_handler();
1701
d06800f1 1702#ifdef HAVE_XIM
63081513
RR		 1703 if (win->m_ic) return FALSE;
1704 if (!widget) return FALSE;
1705 if (!gdk_im_ready()) return FALSE;
1706
1707 win->m_icattr = gdk_ic_attr_new();
1708 if (!win->m_icattr) return FALSE;
1709
1710 gint width, height;
1711 GdkEventMask mask;
1712 GdkColormap *colormap;
1713 GdkICAttr *attr = win->m_icattr;
b58b1dfc 1714 unsigned attrmask = GDK_IC_ALL_REQ;
63081513 1715 GdkIMStyle style;
b79395c5
RR		 1716 GdkIMStyle supported_style = (GdkIMStyle)
1717 (GDK_IM_PREEDIT_NONE |
63081513
RR		 1718 GDK_IM_PREEDIT_NOTHING |
1719 GDK_IM_PREEDIT_POSITION |
1720 GDK_IM_STATUS_NONE |
b79395c5 1721 GDK_IM_STATUS_NOTHING);
63081513
RR		 1722
1723 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
b79395c5 1724 supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
63081513
RR		 1725
1726 attr->style = style = gdk_im_decide_style (supported_style);
1727 attr->client_window = widget->window;
1728
1729 if ((colormap = gtk_widget_get_colormap (widget)) !=
1730 gtk_widget_get_default_colormap ())
1731 {
1732 attrmask |= GDK_IC_PREEDIT_COLORMAP;
1733 attr->preedit_colormap = colormap;
1734 }
1735
1736 attrmask |= GDK_IC_PREEDIT_FOREGROUND;
1737 attrmask |= GDK_IC_PREEDIT_BACKGROUND;
1738 attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
1739 attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
1740
1741 switch (style & GDK_IM_PREEDIT_MASK)
1742 {
1743 case GDK_IM_PREEDIT_POSITION:
1744 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
1745 {
1746 g_warning ("over-the-spot style requires fontset");
1747 break;
1748 }
1749
1750 gdk_window_get_size (widget->window, &width, &height);
1751
1752 attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
1753 attr->spot_location.x = 0;
1754 attr->spot_location.y = height;
1755 attr->preedit_area.x = 0;
1756 attr->preedit_area.y = 0;
1757 attr->preedit_area.width = width;
1758 attr->preedit_area.height = height;
1759 attr->preedit_fontset = widget->style->font;
1760
1761 break;
b79395c5
RR		 1762 }
1763
b58b1dfc 1764 win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
63081513
RR		 1765
1766 if (win->m_ic == NULL)
1767 g_warning ("Can't create input context.");
1768 else
1769 {
1770 mask = gdk_window_get_events (widget->window);
b79395c5 1771 mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
63081513
RR		 1772 gdk_window_set_events (widget->window, mask);
1773
1774 if (GTK_WIDGET_HAS_FOCUS(widget))
1775 gdk_im_begin (win->m_ic, widget->window);
1776 }
63081513
RR		 1777#endif
1778
1779 return FALSE;
1780}
1781
6ca41e57
RR		 1782//-----------------------------------------------------------------------------
1783// InsertChild for wxWindow.
1784//-----------------------------------------------------------------------------
1785
b1170810
RR		 1786/* Callback for wxWindow. This very strange beast has to be used because
1787 * C++ has no virtual methods in a constructor. We have to emulate a
1788 * virtual function here as wxNotebook requires a different way to insert
1789 * a child in it. I had opted for creating a wxNotebookPage window class
1790 * which would have made this superfluous (such in the MDI window system),
1791 * but no-one was listening to me... */
6ca41e57
RR		 1792
1793static void wxInsertChildInWindow( wxWindow* parent, wxWindow* child )
1794{
bf0c00c6
RR		 1795 /* the window might have been scrolled already, do we
1796 have to adapt the position */
da048e3d
RR		 1797 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
1798 child->m_x += pizza->xoffset;
1799 child->m_y += pizza->yoffset;
148cd9b6 1800
da048e3d 1801 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
a2053b27
RR		 1802 GTK_WIDGET(child->m_widget),
1803 child->m_x,
1804 child->m_y,
1805 child->m_width,
1806 child->m_height );
6ca41e57
RR		 1807}
1808
bbe0af5b
RR		 1809//-----------------------------------------------------------------------------
1810// global functions
1811//-----------------------------------------------------------------------------
1812
1813wxWindow* wxGetActiveWindow()
1814{
f03fc89f 1815 return g_focusWindow;
bbe0af5b
RR		 1816}
1817
c801d85f 1818//-----------------------------------------------------------------------------
2f2aa628 1819// wxWindow
c801d85f
KB		 1820//-----------------------------------------------------------------------------
1821
f03fc89f 1822IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
c801d85f 1823
68995f26 1824void wxWindow::Init()
c801d85f 1825{
f03fc89f
VZ		 1826 // common init
1827 InitBase();
68995f26 1828
f03fc89f 1829 // GTK specific
a2053b27 1830 m_widget = (GtkWidget *) NULL;
e380f72b 1831 m_wxwindow = (GtkWidget *) NULL;
8bbe427f 1832
f03fc89f 1833 // position/size
a2053b27
RR		 1834 m_x = 0;
1835 m_y = 0;
1836 m_width = 0;
e380f72b 1837 m_height = 0;
8bbe427f 1838
e380f72b
RR		 1839 m_sizeSet = FALSE;
1840 m_hasVMT = FALSE;
1841 m_needParent = TRUE;
31c6b4fc 1842 m_isBeingDeleted = FALSE;
148cd9b6 1843
147bc491 1844 m_noExpose = FALSE;
30760ce7 1845 m_nativeSizeEvent = FALSE;
148cd9b6 1846
a2053b27 1847 m_hasScrolling = FALSE;
e380f72b 1848 m_isScrolling = FALSE;
f03fc89f 1849
a2053b27 1850 m_hAdjust = (GtkAdjustment*) NULL;
e380f72b 1851 m_vAdjust = (GtkAdjustment*) NULL;
a2053b27 1852 m_oldHorizontalPos = 0.0;
e380f72b 1853 m_oldVerticalPos = 0.0;
8bbe427f 1854
e380f72b 1855 m_resizing = FALSE;
e380f72b 1856 m_widgetStyle = (GtkStyle*) NULL;
8bbe427f 1857
ddb6bc71 1858 m_insertCallback = (wxInsertChildFunction) NULL;
8bbe427f 1859
1ecc4d80 1860 m_isStaticBox = FALSE;
953704c1 1861 m_isRadioButton = FALSE;
54517652 1862 m_isFrame = FALSE;
b292e2f5 1863 m_acceptsFocus = FALSE;
148cd9b6 1864
5e014a0c 1865 m_cursor = *wxSTANDARD_CURSOR;
63081513
RR		 1866
1867#ifdef HAVE_XIM
1868 m_ic = (GdkIC*) NULL;
1869 m_icattr = (GdkICAttr*) NULL;
1870#endif
362c6693 1871}
c801d85f 1872
68995f26
VZ		 1873wxWindow::wxWindow()
1874{
1875 Init();
1876}
1877
6ca41e57 1878wxWindow::wxWindow( wxWindow *parent, wxWindowID id,
e380f72b
RR		 1879 const wxPoint &pos, const wxSize &size,
1880 long style, const wxString &name )
6ca41e57 1881{
68995f26
VZ		 1882 Init();
1883
e380f72b 1884 Create( parent, id, pos, size, style, name );
6ca41e57 1885}
8bbe427f 1886
debe6624 1887bool wxWindow::Create( wxWindow *parent, wxWindowID id,
e380f72b
RR		 1888 const wxPoint &pos, const wxSize &size,
1889 long style, const wxString &name )
c801d85f 1890{
4dcaf11a
RR		 1891 if (!PreCreation( parent, pos, size ) ||
1892 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
1893 {
223d09f6 1894 wxFAIL_MSG( wxT("wxWindow creation failed") );
b02da6b1 1895 return FALSE;
4dcaf11a 1896 }
47d67540 1897
ddb6bc71
RR		 1898 m_insertCallback = wxInsertChildInWindow;
1899
e380f72b 1900 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
38c7b3d3 1901 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
ff8bfdbb 1902
2e563988 1903#ifdef __WXDEBUG__
223d09f6 1904 debug_focus_in( m_widget, wxT("wxWindow::m_widget"), name );
2e563988
RR		 1905#endif
1906
f03fc89f 1907 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
47d67540 1908
2e563988 1909#ifdef __WXDEBUG__
223d09f6
KB		 1910 debug_focus_in( scrolledWindow->hscrollbar, wxT("wxWindow::hsrcollbar"), name );
1911 debug_focus_in( scrolledWindow->vscrollbar, wxT("wxWindow::vsrcollbar"), name );
2e563988
RR		 1912#endif
1913
e380f72b
RR		 1914 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
1915 scroll_class->scrollbar_spacing = 0;
47d67540 1916
f03fc89f 1917 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
47d67540 1918
f03fc89f
VZ		 1919 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
1920 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
47d67540 1921
da048e3d 1922 m_wxwindow = gtk_pizza_new();
38c7b3d3 1923
2e563988 1924#ifdef __WXDEBUG__
223d09f6 1925 debug_focus_in( m_wxwindow, wxT("wxWindow::m_wxwindow"), name );
2e563988
RR		 1926#endif
1927
034be888 1928 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
58dea4b0 1929
034be888 1930#if (GTK_MINOR_VERSION > 0)
da048e3d 1931 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
b292e2f5 1932
f03fc89f 1933 if (HasFlag(wxRAISED_BORDER))
034be888 1934 {
da048e3d 1935 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
034be888 1936 }
f03fc89f 1937 else if (HasFlag(wxSUNKEN_BORDER))
034be888 1938 {
da048e3d 1939 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
5e014a0c
RR		 1940 }
1941 else if (HasFlag(wxSIMPLE_BORDER))
1942 {
da048e3d 1943 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
034be888
RR		 1944 }
1945 else
1946 {
da048e3d 1947 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
034be888 1948 }
f03fc89f
VZ		 1949#else // GTK_MINOR_VERSION == 0
1950 GtkViewport *viewport = GTK_VIEWPORT(scrolledWindow->viewport);
b292e2f5 1951
f03fc89f 1952 if (HasFlag(wxRAISED_BORDER))
e380f72b
RR		 1953 {
1954 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_OUT );
1955 }
f03fc89f 1956 else if (HasFlag(wxSUNKEN_BORDER))
e380f72b
RR		 1957 {
1958 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_IN );
1959 }
1960 else
1961 {
1962 gtk_viewport_set_shadow_type( viewport, GTK_SHADOW_NONE );
1963 }
f03fc89f 1964#endif // GTK_MINOR_VERSION
47d67540 1965
3da17724
RR		 1966 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
1967 m_acceptsFocus = TRUE;
ca298c88 1968
034be888 1969#if (GTK_MINOR_VERSION == 0)
e380f72b
RR		 1970 // shut the viewport up
1971 gtk_viewport_set_hadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
1972 gtk_viewport_set_vadjustment( viewport, (GtkAdjustment*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
f03fc89f 1973#endif // GTK_MINOR_VERSION == 0
e380f72b
RR		 1974
1975 // I _really_ don't want scrollbars in the beginning
a2053b27
RR		 1976 m_vAdjust->lower = 0.0;
1977 m_vAdjust->upper = 1.0;
1978 m_vAdjust->value = 0.0;
1979 m_vAdjust->step_increment = 1.0;
1980 m_vAdjust->page_increment = 1.0;
1981 m_vAdjust->page_size = 5.0;
1982 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
1983 m_hAdjust->lower = 0.0;
1984 m_hAdjust->upper = 1.0;
1985 m_hAdjust->value = 0.0;
1986 m_hAdjust->step_increment = 1.0;
1987 m_hAdjust->page_increment = 1.0;
1988 m_hAdjust->page_size = 5.0;
1989 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
f03fc89f
VZ		 1990
1991 // these handlers block mouse events to any window during scrolling such as
1992 // motion events and prevent GTK and wxWindows from fighting over where the
1993 // slider should be
1994
1995 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
76ed8f8d
RR		 1996 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
1997
f03fc89f 1998 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
76ed8f8d
RR		 1999 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2000
f03fc89f 2001 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
76ed8f8d
RR		 2002 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2003
f03fc89f 2004 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
76ed8f8d 2005 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
8bbe427f 2006
034be888 2007 // these handlers get notified when screen updates are required either when
76ed8f8d
RR		 2008 // scrolling or when the window size (and therefore scrollbar configuration)
2009 // has changed
2010
2011 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2012 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2013 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2014 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2015
2016 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "changed",
2017 (GtkSignalFunc) gtk_window_hscroll_change_callback, (gpointer) this );
2018 gtk_signal_connect(GTK_OBJECT(m_vAdjust), "changed",
2019 (GtkSignalFunc) gtk_window_vscroll_change_callback, (gpointer) this );
2020
f03fc89f 2021 gtk_widget_show( m_wxwindow );
47d67540 2022
f03fc89f
VZ		 2023 if (m_parent)
2024 m_parent->DoAddChild( this );
8bbe427f 2025
e380f72b 2026 PostCreation();
8bbe427f 2027
e380f72b 2028 Show( TRUE );
c801d85f 2029
e380f72b 2030 return TRUE;
362c6693 2031}
c801d85f 2032
68dda785 2033wxWindow::~wxWindow()
c801d85f 2034{
31c6b4fc 2035 m_isBeingDeleted = TRUE;
43a18898 2036 m_hasVMT = FALSE;
47d67540 2037
f03fc89f
VZ		 2038 if (m_widget)
2039 Show( FALSE );
8bbe427f 2040
a2053b27
RR		 2041 DestroyChildren();
2042
f03fc89f
VZ		 2043 if (m_parent)
2044 m_parent->RemoveChild( this );
c801d85f 2045
63081513
RR		 2046#ifdef HAVE_XIM
2047 if (m_ic)
2048 gdk_ic_destroy (m_ic);
2049 if (m_icattr)
2050 gdk_ic_attr_destroy (m_icattr);
2051#endif
2052
f03fc89f 2053 if (m_widgetStyle)
a2053b27 2054 {
f03fc89f 2055 gtk_style_unref( m_widgetStyle );
c50f1fb9 2056 m_widgetStyle = (GtkStyle*) NULL;
a2053b27 2057 }
c801d85f 2058
f03fc89f 2059 if (m_wxwindow)
a2053b27 2060 {
f03fc89f 2061 gtk_widget_destroy( m_wxwindow );
c50f1fb9 2062 m_wxwindow = (GtkWidget*) NULL;
a2053b27 2063 }
8bbe427f 2064
f03fc89f 2065 if (m_widget)
a2053b27 2066 {
f03fc89f 2067 gtk_widget_destroy( m_widget );
c50f1fb9 2068 m_widget = (GtkWidget*) NULL;
a2053b27 2069 }
362c6693 2070}
c801d85f 2071
4dcaf11a 2072bool wxWindow::PreCreation( wxWindow *parent, const wxPoint &pos, const wxSize &size )
c801d85f 2073{
223d09f6 2074 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
8bbe427f 2075
4dcaf11a
RR		 2076 /* this turns -1 into 20 so that a minimal window is
2077 visible even although -1,-1 has been given as the
2078 size of the window. the same trick is used in other
2079 ports and should make debugging easier */
f03fc89f
VZ		 2080 m_width = WidthDefault(size.x);
2081 m_height = HeightDefault(size.y);
8bbe427f 2082
43a18898
RR		 2083 m_x = (int)pos.x;
2084 m_y = (int)pos.y;
8bbe427f 2085
4dcaf11a 2086 /* some reasonable defaults */
148cd9b6 2087 if (!parent)
6ca41e57 2088 {
43a18898
RR		 2089 if (m_x == -1)
2090 {
2091 m_x = (gdk_screen_width () - m_width) / 2;
2092 if (m_x < 10) m_x = 10;
2093 }
2094 if (m_y == -1)
2095 {
2096 m_y = (gdk_screen_height () - m_height) / 2;
2097 if (m_y < 10) m_y = 10;
2098 }
6ca41e57 2099 }
148cd9b6 2100
4dcaf11a 2101 return TRUE;
c801d85f
KB		 2102}
2103
68dda785 2104void wxWindow::PostCreation()
c801d85f 2105{
223d09f6 2106 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
ca298c88 2107
43a18898
RR		 2108 if (m_wxwindow)
2109 {
147bc491 2110 if (!m_noExpose)
b02da6b1 2111 {
147bc491
RR		 2112 /* these get reported to wxWindows -> wxPaintEvent */
2113 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2114 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2115
2116 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2117 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
b02da6b1 2118 }
148cd9b6 2119
ef47f9b3 2120#if (GTK_MINOR_VERSION > 0)
ed673c6a 2121 /* these are called when the "sunken" or "raised" borders are drawn */
034be888
RR		 2122 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2123 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2124
2125 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2126 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
ef47f9b3 2127#endif
43a18898 2128 }
47d67540 2129
63081513
RR		 2130 if (m_wxwindow && m_needParent)
2131 {
2132 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "focus_in_event",
2133 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2134
2135 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "focus_out_event",
2136 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2137 }
2138 else
2139 {
2140 // For dialogs and frames, we are interested mainly in
2141 // m_widget's focus.
2142
2143 gtk_signal_connect( GTK_OBJECT(m_widget), "focus_in_event",
2144 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2145
2146 gtk_signal_connect( GTK_OBJECT(m_widget), "focus_out_event",
2147 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2148 }
2149
a2053b27 2150 GtkWidget *connect_widget = GetConnectWidget();
f03fc89f 2151
a2053b27 2152 ConnectWidget( connect_widget );
47d67540 2153
63081513 2154 /* We cannot set colours, fonts and cursors before the widget has
a2053b27
RR		 2155 been realized, so we do this directly after realization */
2156 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
c50f1fb9 2157 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
63081513 2158
63081513
RR		 2159 if (m_wxwindow)
2160 {
b79395c5 2161 /* Initialize XIM support. */
63081513
RR		 2162 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2163 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
b79395c5
RR		 2164
2165 /* And resize XIM window. */
2166 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2167 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
63081513
RR		 2168 }
2169
43a18898 2170 m_hasVMT = TRUE;
b4071e91
RR		 2171}
2172
2173void wxWindow::ConnectWidget( GtkWidget *widget )
2174{
43a18898
RR		 2175 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2176 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
c801d85f 2177
b666df2c
RR		 2178 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2179 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2180
43a18898
RR		 2181 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2182 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
47d67540 2183
43a18898
RR		 2184 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2185 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
47d67540 2186
43a18898
RR		 2187 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2188 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
47d67540 2189
43a18898
RR		 2190 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2191 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
47d67540 2192
43a18898
RR		 2193 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2194 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
362c6693 2195}
c801d85f 2196
68dda785 2197bool wxWindow::Destroy()
c801d85f 2198{
223d09f6 2199 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
47d67540 2200
43a18898 2201 m_hasVMT = FALSE;
c801d85f 2202
f03fc89f 2203 return wxWindowBase::Destroy();
362c6693 2204}
c801d85f 2205
bfc6fde4 2206void wxWindow::DoSetSize( int x, int y, int width, int height, int sizeFlags )
c801d85f 2207{
223d09f6
KB		 2208 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
2209 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindow::SetSize requires parent.\n") );
8bbe427f 2210
e27ce4e9 2211 if (m_resizing) return; /* I don't like recursions */
fb1585ae 2212 m_resizing = TRUE;
47d67540 2213
a2053b27 2214 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
fb1585ae 2215 {
e27ce4e9 2216 /* don't set the size for children of wxNotebook, just take the values. */
fb1585ae
RR		 2217 m_x = x;
2218 m_y = y;
2219 m_width = width;
ba4e3652 2220 m_height = height;
fb1585ae 2221 }
ba4e3652 2222 else
fb1585ae 2223 {
da048e3d 2224 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
148cd9b6 2225
85ad5eb5 2226 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
ba4e3652 2227 {
da048e3d
RR		 2228 if (x != -1) m_x = x + pizza->xoffset;
2229 if (y != -1) m_y = y + pizza->yoffset;
ba4e3652
RR		 2230 if (width != -1) m_width = width;
2231 if (height != -1) m_height = height;
2232 }
2233 else
2234 {
da048e3d
RR		 2235 m_x = x + pizza->xoffset;
2236 m_y = y + pizza->yoffset;
ba4e3652
RR		 2237 m_width = width;
2238 m_height = height;
2239 }
47d67540 2240
ba4e3652
RR		 2241 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
2242 {
2243 if (width == -1) m_width = 80;
2244 }
2245
2246 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
2247 {
2248 if (height == -1) m_height = 26;
2249 }
8bbe427f 2250
ba4e3652
RR		 2251 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
2252 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
d3b4d113
RR		 2253 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
2254 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
47d67540 2255
a2053b27 2256 int border = 0;
c50f1fb9 2257 int bottom_border = 0;
f03fc89f 2258
29f538ce 2259 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
c50f1fb9
VZ		 2260 {
2261 /* the default button has a border around it */
2262 border = 6;
2263 bottom_border = 5;
2264 }
2265
da048e3d 2266 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow),
c50f1fb9
VZ		 2267 m_widget,
2268 m_x-border,
2269 m_y-border,
2270 m_width+2*border,
2271 m_height+border+bottom_border );
54517652 2272 }
148cd9b6 2273
54517652 2274/*
6d693bb4
RR		 2275 wxPrintf( "OnSize sent from " );
2276 if (GetClassInfo() && GetClassInfo()->GetClassName())
2277 wxPrintf( GetClassInfo()->GetClassName() );
2278 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2279*/
2280
30760ce7
RR		 2281 if (!m_nativeSizeEvent)
2282 {
2283 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
2284 event.SetEventObject( this );
2285 GetEventHandler()->ProcessEvent( event );
2286 }
6d693bb4 2287
fb1585ae 2288 m_resizing = FALSE;
362c6693 2289}
c801d85f 2290
9390a202
RR		 2291void wxWindow::OnInternalIdle()
2292{
148cd9b6
VZ		 2293 if ( g_sendActivateEvent != -1 )
2294 {
2295 bool activate = g_sendActivateEvent != 0;
2296
2297 // do it only once
2298 g_sendActivateEvent = -1;
2299
2300 wxActivateEvent event(wxEVT_ACTIVATE, activate, GetId());
2301 event.SetEventObject(this);
2302
2303 (void)GetEventHandler()->ProcessEvent(event);
2304 }
2305
9146082c
RR		 2306 wxCursor cursor = m_cursor;
2307 if (g_globalCursor.Ok()) cursor = g_globalCursor;
c50f1fb9 2308
f7a11f8c 2309 if (cursor.Ok())
9146082c 2310 {
3017f78d 2311 /* I now set the cursor anew in every OnInternalIdle call
b02da6b1
VZ		 2312 as setting the cursor in a parent window also effects the
2313 windows above so that checking for the current cursor is
2314 not possible. */
148cd9b6 2315
9146082c 2316 if (m_wxwindow)
6a008b33 2317 {
da048e3d 2318 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
6a008b33 2319 if (window)
c50f1fb9 2320 gdk_window_set_cursor( window, cursor.GetCursor() );
6a008b33
VZ		 2321
2322 if (!g_globalCursor.Ok())
2323 cursor = *wxSTANDARD_CURSOR;
2324
2325 window = m_widget->window;
5e014a0c 2326 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
9146082c 2327 gdk_window_set_cursor( window, cursor.GetCursor() );
5e014a0c 2328
6a008b33
VZ		 2329 }
2330 else
2331 {
5e014a0c 2332
9146082c 2333 GdkWindow *window = m_widget->window;
5e014a0c 2334 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
9146082c 2335 gdk_window_set_cursor( window, cursor.GetCursor() );
5e014a0c 2336
6a008b33 2337 }
9146082c 2338 }
6a008b33 2339
9390a202
RR		 2340 UpdateWindowUI();
2341}
2342
f03fc89f 2343void wxWindow::DoGetSize( int *width, int *height ) const
c801d85f 2344{
223d09f6 2345 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2346
fb1585ae
RR		 2347 if (width) (*width) = m_width;
2348 if (height) (*height) = m_height;
362c6693 2349}
c801d85f 2350
bfc6fde4 2351void wxWindow::DoSetClientSize( int width, int height )
c801d85f 2352{
223d09f6 2353 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2354
1ecc4d80 2355 if (!m_wxwindow)
c801d85f 2356 {
1ecc4d80 2357 SetSize( width, height );
c801d85f
KB		 2358 }
2359 else
2360 {
1ecc4d80
RR		 2361 int dw = 0;
2362 int dh = 0;
2363
034be888 2364#if (GTK_MINOR_VERSION == 0)
98d3fdbe
RR		 2365 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2366 {
324dbfec
RR		 2367 if (HasScrolling())
2368 {
2369 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
014b0d06 2370#if 0 // unused - if this is ok, just remove this line (VZ)
324dbfec 2371 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
014b0d06 2372#endif // 0
324dbfec
RR		 2373
2374 GtkWidget *viewport = scroll_window->viewport;
2375 GtkStyleClass *viewport_class = viewport->style->klass;
2376
2377 dw += 2 * viewport_class->xthickness;
2378 dh += 2 * viewport_class->ythickness;
2379 }
98d3fdbe
RR		 2380 }
2381#else
2382 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2383 {
5e014a0c 2384 /* when using GTK 1.2 we set the shadow border size to 2 */
6a008b33 2385 dw += 2 * 2;
98d3fdbe
RR		 2386 dh += 2 * 2;
2387 }
5e014a0c
RR		 2388 if (HasFlag(wxSIMPLE_BORDER))
2389 {
2390 /* when using GTK 1.2 we set the simple border size to 1 */
2391 dw += 1 * 2;
2392 dh += 1 * 2;
2393 }
034be888
RR		 2394#endif
2395
98d3fdbe
RR		 2396 if (HasScrolling())
2397 {
034be888
RR		 2398/*
2399 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2400 GtkWidget *vscrollbar = scroll_window->vscrollbar;
ca298c88 2401
f03fc89f 2402 we use this instead: range.slider_width = 11 + 2*2pts edge
034be888 2403*/
47d67540 2404
324dbfec
RR		 2405 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2406 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
2407
1ecc4d80
RR		 2408 if (scroll_window->vscrollbar_visible)
2409 {
034be888 2410 dw += 15; /* dw += vscrollbar->allocation.width; */
1ecc4d80
RR		 2411 dw += scroll_class->scrollbar_spacing;
2412 }
2413
2414 if (scroll_window->hscrollbar_visible)
2415 {
034be888 2416 dh += 15; /* dh += hscrollbar->allocation.height; */
63cc5d9d 2417 dh += scroll_class->scrollbar_spacing;
1ecc4d80
RR		 2418 }
2419 }
2420
034be888 2421 SetSize( width+dw, height+dh );
1ecc4d80 2422 }
362c6693 2423}
c801d85f 2424
f03fc89f 2425void wxWindow::DoGetClientSize( int *width, int *height ) const
c801d85f 2426{
223d09f6 2427 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2428
1ecc4d80
RR		 2429 if (!m_wxwindow)
2430 {
2431 if (width) (*width) = m_width;
2432 if (height) (*height) = m_height;
c801d85f
KB		 2433 }
2434 else
2435 {
1ecc4d80
RR		 2436 int dw = 0;
2437 int dh = 0;
2438
034be888 2439#if (GTK_MINOR_VERSION == 0)
98d3fdbe
RR		 2440 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2441 {
6a008b33
VZ		 2442 if (HasScrolling())
2443 {
2444 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
ec6e0a19 2445#if 0 // unused - if this is ok, just remove this line (VZ)
6a008b33 2446 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
ec6e0a19 2447#endif // 0
6a008b33
VZ		 2448
2449 GtkWidget *viewport = scroll_window->viewport;
2450 GtkStyleClass *viewport_class = viewport->style->klass;
2451
2452 dw += 2 * viewport_class->xthickness;
2453 dh += 2 * viewport_class->ythickness;
2454 }
98d3fdbe
RR		 2455 }
2456#else
2457 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
2458 {
5e014a0c 2459 /* when using GTK 1.2 we set the shadow border size to 2 */
6a008b33 2460 dw += 2 * 2;
98d3fdbe
RR		 2461 dh += 2 * 2;
2462 }
5e014a0c
RR		 2463 if (HasFlag(wxSIMPLE_BORDER))
2464 {
2465 /* when using GTK 1.2 we set the simple border size to 1 */
2466 dw += 1 * 2;
2467 dh += 1 * 2;
2468 }
034be888 2469#endif
98d3fdbe
RR		 2470 if (HasScrolling())
2471 {
034be888
RR		 2472/*
2473 GtkWidget *hscrollbar = scroll_window->hscrollbar;
2474 GtkWidget *vscrollbar = scroll_window->vscrollbar;
ca298c88 2475
f03fc89f 2476 we use this instead: range.slider_width = 11 + 2*2pts edge
034be888 2477*/
1ecc4d80 2478
6a008b33
VZ		 2479 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2480 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget)->klass );
2481
1ecc4d80
RR		 2482 if (scroll_window->vscrollbar_visible)
2483 {
034be888 2484 dw += 15; /* dw += vscrollbar->allocation.width; */
1ecc4d80
RR		 2485 dw += scroll_class->scrollbar_spacing;
2486 }
2487
2488 if (scroll_window->hscrollbar_visible)
2489 {
034be888 2490 dh += 15; /* dh += hscrollbar->allocation.height; */
1ecc4d80
RR		 2491 dh += scroll_class->scrollbar_spacing;
2492 }
6a008b33 2493 }
47d67540 2494
1ecc4d80
RR		 2495 if (width) (*width) = m_width - dw;
2496 if (height) (*height) = m_height - dh;
2497 }
362c6693 2498}
c801d85f 2499
f03fc89f 2500void wxWindow::DoGetPosition( int *x, int *y ) const
c801d85f 2501{
223d09f6 2502 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2503
bf0c00c6
RR		 2504 int dx = 0;
2505 int dy = 0;
2506 if (m_parent && m_parent->m_wxwindow)
2507 {
da048e3d 2508 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
b02da6b1
VZ		 2509 dx = pizza->xoffset;
2510 dy = pizza->yoffset;
bf0c00c6
RR		 2511 }
2512
2513 if (x) (*x) = m_x - dx;
2514 if (y) (*y) = m_y - dy;
362c6693 2515}
c801d85f 2516
dabc0cd5 2517void wxWindow::DoClientToScreen( int *x, int *y ) const
c801d85f 2518{
223d09f6 2519 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2520
a2053b27
RR		 2521 if (!m_widget->window) return;
2522
43a18898
RR		 2523 GdkWindow *source = (GdkWindow *) NULL;
2524 if (m_wxwindow)
da048e3d 2525 source = GTK_PIZZA(m_wxwindow)->bin_window;
43a18898
RR		 2526 else
2527 source = m_widget->window;
47d67540 2528
43a18898
RR		 2529 int org_x = 0;
2530 int org_y = 0;
2531 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 2532
43a18898 2533 if (!m_wxwindow)
c801d85f 2534 {
43a18898
RR		 2535 if (GTK_WIDGET_NO_WINDOW (m_widget))
2536 {
2537 org_x += m_widget->allocation.x;
2538 org_y += m_widget->allocation.y;
2539 }
362c6693 2540 }
47d67540 2541
43a18898
RR		 2542 if (x) *x += org_x;
2543 if (y) *y += org_y;
362c6693 2544}
c801d85f 2545
dabc0cd5 2546void wxWindow::DoScreenToClient( int *x, int *y ) const
c801d85f 2547{
223d09f6 2548 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2549
a2053b27
RR		 2550 if (!m_widget->window) return;
2551
1ecc4d80
RR		 2552 GdkWindow *source = (GdkWindow *) NULL;
2553 if (m_wxwindow)
da048e3d 2554 source = GTK_PIZZA(m_wxwindow)->bin_window;
1ecc4d80
RR		 2555 else
2556 source = m_widget->window;
47d67540 2557
1ecc4d80
RR		 2558 int org_x = 0;
2559 int org_y = 0;
2560 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 2561
1ecc4d80 2562 if (!m_wxwindow)
c801d85f 2563 {
1ecc4d80
RR		 2564 if (GTK_WIDGET_NO_WINDOW (m_widget))
2565 {
2566 org_x += m_widget->allocation.x;
2567 org_y += m_widget->allocation.y;
2568 }
362c6693 2569 }
47d67540 2570
1ecc4d80
RR		 2571 if (x) *x -= org_x;
2572 if (y) *y -= org_y;
362c6693 2573}
c801d85f 2574
f03fc89f 2575bool wxWindow::Show( bool show )
c801d85f 2576{
223d09f6 2577 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
47d67540 2578
739730ca
RR		 2579 if (!wxWindowBase::Show(show))
2580 {
2581 // nothing to do
f03fc89f 2582 return FALSE;
739730ca 2583 }
8bbe427f 2584
f03fc89f
VZ		 2585 if (show)
2586 gtk_widget_show( m_widget );
1ecc4d80 2587 else
f03fc89f 2588 gtk_widget_hide( m_widget );
8bbe427f 2589
f03fc89f 2590 return TRUE;
362c6693 2591}
c801d85f 2592
f03fc89f 2593bool wxWindow::Enable( bool enable )
c801d85f 2594{
223d09f6 2595 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
5e0aa05a 2596
739730ca
RR		 2597 if (!wxWindowBase::Enable(enable))
2598 {
2599 // nothing to do
f03fc89f 2600 return FALSE;
739730ca 2601 }
1ecc4d80 2602
f03fc89f
VZ		 2603 gtk_widget_set_sensitive( m_widget, enable );
2604 if ( m_wxwindow )
2605 gtk_widget_set_sensitive( m_wxwindow, enable );
ff8bfdbb 2606
f03fc89f 2607 return TRUE;
362c6693 2608}
c801d85f 2609
f03fc89f 2610int wxWindow::GetCharHeight() const
2f2aa628 2611{
223d09f6 2612 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
47d67540 2613
223d09f6 2614 wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
2f2aa628 2615
f03fc89f
VZ		 2616 GdkFont *font = m_font.GetInternalFont( 1.0 );
2617
2618 return font->ascent + font->descent;
362c6693 2619}
c801d85f 2620
f03fc89f 2621int wxWindow::GetCharWidth() const
c33c4050 2622{
223d09f6 2623 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
47d67540 2624
223d09f6 2625 wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
47d67540 2626
463c1fa1 2627 GdkFont *font = m_font.GetInternalFont( 1.0 );
ff8bfdbb 2628
463c1fa1 2629 return gdk_string_width( font, "H" );
c33c4050
RR		 2630}
2631
f03fc89f
VZ		 2632void wxWindow::GetTextExtent( const wxString& string,
2633 int *x,
2634 int *y,
2635 int *descent,
2636 int *externalLeading,
2637 const wxFont *theFont ) const
c33c4050 2638{
463c1fa1
RR		 2639 wxFont fontToUse = m_font;
2640 if (theFont) fontToUse = *theFont;
47d67540 2641
223d09f6 2642 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
47d67540 2643
463c1fa1 2644 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
05939a81 2645 if (x) (*x) = gdk_string_width( font, string.mbc_str() );
463c1fa1
RR		 2646 if (y) (*y) = font->ascent + font->descent;
2647 if (descent) (*descent) = font->descent;
2648 if (externalLeading) (*externalLeading) = 0; // ??
c33c4050
RR		 2649}
2650
68dda785 2651void wxWindow::SetFocus()
c801d85f 2652{
223d09f6 2653 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
c0d6c58b 2654
354aa1e3
RR		 2655 if (m_wxwindow)
2656 {
173348db
RR		 2657 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
2658 gtk_widget_grab_focus (m_wxwindow);
354aa1e3
RR		 2659 return;
2660 }
2661
2662 if (m_widget)
c801d85f 2663 {
173348db 2664 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
463c1fa1 2665 {
354aa1e3 2666 gtk_widget_grab_focus (m_widget);
463c1fa1 2667 }
354aa1e3 2668 else if (GTK_IS_CONTAINER(m_widget))
ff8bfdbb 2669 {
354aa1e3 2670 gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD );
ff8bfdbb
VZ		 2671 }
2672 else
2673 {
b02da6b1 2674 // ?
ff8bfdbb 2675 }
362c6693 2676 }
362c6693 2677}
c801d85f 2678
b292e2f5
RR		 2679bool wxWindow::AcceptsFocus() const
2680{
f03fc89f 2681 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
b292e2f5
RR		 2682}
2683
fdb7dadb 2684bool wxWindow::Reparent( wxWindowBase *newParentBase )
463c1fa1 2685{
223d09f6 2686 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
c50f1fb9 2687
fdb7dadb
VZ		 2688 wxWindow *oldParent = m_parent,
2689 *newParent = (wxWindow *)newParentBase;
a2053b27 2690
5fd11f09
RR		 2691 wxASSERT( GTK_IS_WIDGET(m_widget) );
2692
f03fc89f
VZ		 2693 if ( !wxWindowBase::Reparent(newParent) )
2694 return FALSE;
8bbe427f 2695
5fd11f09
RR		 2696 wxASSERT( GTK_IS_WIDGET(m_widget) );
2697
2698 /* prevent GTK from deleting the widget arbitrarily */
2699 gtk_widget_ref( m_widget );
2700
8ce63e9d
RR		 2701 if (oldParent)
2702 {
3017f78d 2703 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
8ce63e9d 2704 }
c50f1fb9 2705
5fd11f09
RR		 2706 wxASSERT( GTK_IS_WIDGET(m_widget) );
2707
8ce63e9d
RR		 2708 if (newParent)
2709 {
2710 /* insert GTK representation */
2711 (*(newParent->m_insertCallback))(newParent, this);
2712 }
c50f1fb9 2713
5fd11f09
RR		 2714 /* reverse: prevent GTK from deleting the widget arbitrarily */
2715 gtk_widget_unref( m_widget );
148cd9b6 2716
f03fc89f 2717 return TRUE;
362c6693 2718}
c801d85f 2719
c50f1fb9 2720void wxWindow::DoAddChild(wxWindow *child)
ddb6bc71 2721{
223d09f6 2722 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
ddb6bc71 2723
223d09f6 2724 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
ddb6bc71 2725
223d09f6 2726 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
c50f1fb9 2727
ddb6bc71
RR		 2728 /* add to list */
2729 AddChild( child );
c50f1fb9 2730
ddb6bc71
RR		 2731 /* insert GTK representation */
2732 (*m_insertCallback)(this, child);
2733}
2734
68dda785 2735void wxWindow::Raise()
362c6693 2736{
223d09f6 2737 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2738
a2053b27
RR		 2739 if (!m_widget->window) return;
2740
f03fc89f 2741 gdk_window_raise( m_widget->window );
362c6693
RR		 2742}
2743
68dda785 2744void wxWindow::Lower()
362c6693 2745{
223d09f6 2746 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 2747
a2053b27
RR		 2748 if (!m_widget->window) return;
2749
f03fc89f 2750 gdk_window_lower( m_widget->window );
362c6693 2751}
c801d85f 2752
f03fc89f 2753bool wxWindow::SetCursor( const wxCursor &cursor )
86b29a61 2754{
223d09f6 2755 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
86b29a61 2756
5e014a0c 2757 return wxWindowBase::SetCursor( cursor );
362c6693 2758}
c801d85f 2759
85eb36c2 2760void wxWindow::WarpPointer( int x, int y )
4f22cf8d 2761{
223d09f6 2762 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
85eb36c2 2763
ed673c6a
RR		 2764 /* we provide this function ourselves as it is
2765 missing in GDK (top of this file) */
148cd9b6 2766
ed673c6a
RR		 2767 GdkWindow *window = (GdkWindow*) NULL;
2768 if (m_wxwindow)
da048e3d 2769 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 2770 else
2771 window = GetConnectWidget()->window;
148cd9b6 2772
ed673c6a
RR		 2773 if (window)
2774 gdk_window_warp_pointer( window, x, y );
4f22cf8d
RR		 2775}
2776
debe6624 2777void wxWindow::Refresh( bool eraseBackground, const wxRect *rect )
c801d85f 2778{
f2593d0d 2779 if (!m_widget) return;
a2053b27
RR		 2780 if (!m_widget->window) return;
2781
139adb6a 2782 if (eraseBackground && m_wxwindow && m_wxwindow->window)
c801d85f 2783 {
139adb6a
RR		 2784 if (rect)
2785 {
da048e3d 2786 gdk_window_clear_area( GTK_PIZZA(m_wxwindow)->bin_window,
139adb6a 2787 rect->x, rect->y,
f234c60c 2788 rect->width, rect->height );
139adb6a
RR		 2789 }
2790 else
2791 {
da048e3d 2792 gdk_window_clear( GTK_PIZZA(m_wxwindow)->bin_window );
139adb6a
RR		 2793 }
2794 }
ff8bfdbb 2795
1b68e0b5 2796 /* there is no GTK equivalent of "draw only, don't clear" so we
da048e3d 2797 invent our own in the GtkPizza widget */
1b68e0b5 2798
139adb6a
RR		 2799 if (!rect)
2800 {
2801 if (m_wxwindow)
b02da6b1
VZ		 2802 {
2803 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2804 gboolean old_clear = pizza->clear_on_draw;
2805 gtk_pizza_set_clear( pizza, FALSE );
148cd9b6 2806
1b68e0b5 2807 gtk_widget_draw( m_wxwindow, (GdkRectangle*) NULL );
148cd9b6 2808
b02da6b1
VZ		 2809 gtk_pizza_set_clear( pizza, old_clear );
2810 }
ff8bfdbb 2811 else
139adb6a 2812 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
362c6693 2813 }
c801d85f 2814 else
139adb6a 2815 {
1b68e0b5
RR		 2816 GdkRectangle gdk_rect;
2817 gdk_rect.x = rect->x;
2818 gdk_rect.y = rect->y;
2819 gdk_rect.width = rect->width;
2820 gdk_rect.height = rect->height;
139adb6a
RR		 2821
2822 if (m_wxwindow)
b02da6b1
VZ		 2823 {
2824 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
2825 gboolean old_clear = pizza->clear_on_draw;
2826 gtk_pizza_set_clear( pizza, FALSE );
148cd9b6 2827
1b68e0b5 2828 gtk_widget_draw( m_wxwindow, &gdk_rect );
148cd9b6 2829
b02da6b1
VZ		 2830 gtk_pizza_set_clear( pizza, old_clear );
2831 }
139adb6a
RR		 2832 else
2833 gtk_widget_draw( m_widget, &gdk_rect );
2834 }
362c6693 2835}
c801d85f 2836
68dda785 2837void wxWindow::Clear()
c801d85f 2838{
223d09f6 2839 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 2840
a2053b27
RR		 2841 if (!m_widget->window) return;
2842
f234c60c
RR		 2843 if (m_wxwindow && m_wxwindow->window)
2844 {
2845 gdk_window_clear( m_wxwindow->window );
2846 }
362c6693 2847}
c801d85f 2848
ff8bfdbb 2849#if wxUSE_TOOLTIPS
f03fc89f 2850void wxWindow::DoSetToolTip( wxToolTip *tip )
b1170810 2851{
f03fc89f 2852 wxWindowBase::DoSetToolTip(tip);
ff8bfdbb 2853
f03fc89f
VZ		 2854 if (m_tooltip)
2855 m_tooltip->Apply( this );
b1170810
RR		 2856}
2857
05939a81 2858void wxWindow::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
b1170810 2859{
dcf924a3 2860 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
301cd871 2861}
ff8bfdbb 2862#endif // wxUSE_TOOLTIPS
b1170810 2863
f03fc89f 2864bool wxWindow::SetBackgroundColour( const wxColour &colour )
c801d85f 2865{
223d09f6 2866 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
8bbe427f 2867
739730ca
RR		 2868 if (!wxWindowBase::SetBackgroundColour(colour))
2869 {
2870 // don't leave if the GTK widget has just
2871 // been realized
2872 if (!m_delayedBackgroundColour) return FALSE;
2873 }
c50f1fb9 2874
ed673c6a
RR		 2875 GdkWindow *window = (GdkWindow*) NULL;
2876 if (m_wxwindow)
da048e3d 2877 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 2878 else
2879 window = GetConnectWidget()->window;
148cd9b6 2880
ed673c6a 2881 if (!window)
739730ca
RR		 2882 {
2883 // indicate that a new style has been set
c50f1fb9
VZ		 2884 // but it couldn't get applied as the
2885 // widget hasn't been realized yet.
2886 m_delayedBackgroundColour = TRUE;
2887
2888 // pretend we have done something
739730ca
RR		 2889 return TRUE;
2890 }
ca298c88 2891
ed673c6a 2892 if (m_wxwindow)
3bc755fc 2893 {
a2053b27
RR		 2894 /* wxMSW doesn't clear the window here. I don't do that either to
2895 provide compatibility. call Clear() to do the job. */
ca298c88 2896
ed673c6a
RR		 2897 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
2898 gdk_window_set_background( window, m_backgroundColour.GetColor() );
3bc755fc 2899 }
8bbe427f 2900
ae0bdb01 2901 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
121a3581 2902 if (sysbg == m_backgroundColour)
ae0bdb01
RR		 2903 {
2904 m_backgroundColour = wxNullColour;
2905 ApplyWidgetStyle();
ff8bfdbb
VZ		 2906 m_backgroundColour = sysbg;
2907 }
ae0bdb01
RR		 2908 else
2909 {
2910 ApplyWidgetStyle();
2911 }
c801d85f 2912
f03fc89f 2913 return TRUE;
6de97a3b
RR		 2914}
2915
f03fc89f 2916bool wxWindow::SetForegroundColour( const wxColour &colour )
6de97a3b 2917{
223d09f6 2918 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
8bbe427f 2919
739730ca
RR		 2920 if (!wxWindowBase::SetForegroundColour(colour))
2921 {
2922 // don't leave if the GTK widget has just
2923 // been realized
2924 if (!m_delayedForegroundColour) return FALSE;
2925 }
c50f1fb9 2926
ed673c6a
RR		 2927 GdkWindow *window = (GdkWindow*) NULL;
2928 if (m_wxwindow)
da048e3d 2929 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 2930 else
2931 window = GetConnectWidget()->window;
148cd9b6 2932
ed673c6a 2933 if (!window)
739730ca
RR		 2934 {
2935 // indicate that a new style has been set
c50f1fb9
VZ		 2936 // but it couldn't get applied as the
2937 // widget hasn't been realized yet.
2938 m_delayedForegroundColour = TRUE;
2939
2940 // pretend we have done something
739730ca
RR		 2941 return TRUE;
2942 }
2b07d713 2943
ae0bdb01 2944 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
2b62ab35 2945 if ( sysbg == m_backgroundColour )
ae0bdb01
RR		 2946 {
2947 m_backgroundColour = wxNullColour;
2948 ApplyWidgetStyle();
ff8bfdbb
VZ		 2949 m_backgroundColour = sysbg;
2950 }
ae0bdb01
RR		 2951 else
2952 {
2953 ApplyWidgetStyle();
2954 }
f03fc89f
VZ		 2955
2956 return TRUE;
58614078
RR		 2957}
2958
2959GtkStyle *wxWindow::GetWidgetStyle()
2960{
1ecc4d80 2961 if (m_widgetStyle) gtk_style_unref( m_widgetStyle );
8bbe427f 2962
f03fc89f 2963 m_widgetStyle = gtk_style_copy( gtk_widget_get_style( m_widget ) );
8bbe427f 2964
1ecc4d80 2965 return m_widgetStyle;
58614078
RR		 2966}
2967
2968void wxWindow::SetWidgetStyle()
2969{
1ecc4d80
RR		 2970 GtkStyle *style = GetWidgetStyle();
2971
2972 gdk_font_unref( style->font );
2973 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
2974
2975 if (m_foregroundColour.Ok())
2976 {
454e2a22 2977 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
1ecc4d80
RR		 2978 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
2979 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
2980 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
2981 }
2982
2983 if (m_backgroundColour.Ok())
2984 {
454e2a22 2985 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
1ecc4d80
RR		 2986 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2987 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
2988 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2989 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
2990 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2991 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
2992 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2993 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
2994 }
a81258be
RR		 2995}
2996
58614078 2997void wxWindow::ApplyWidgetStyle()
a81258be 2998{
6de97a3b
RR		 2999}
3000
2259e007
RR		 3001//-----------------------------------------------------------------------------
3002// Pop-up menu stuff
3003//-----------------------------------------------------------------------------
3004
3005static void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
3006{
3007 *is_waiting = FALSE;
3008}
3009
30dea054
RR		 3010static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
3011{
1ecc4d80 3012 menu->SetInvokingWindow( win );
1987af7e 3013 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
1ecc4d80
RR		 3014 while (node)
3015 {
1987af7e 3016 wxMenuItem *menuitem = node->GetData();
1ecc4d80
RR		 3017 if (menuitem->IsSubMenu())
3018 {
ff8bfdbb
VZ		 3019 SetInvokingWindow( menuitem->GetSubMenu(), win );
3020 }
1987af7e
VZ		 3021
3022 node = node->GetNext();
1ecc4d80 3023 }
362c6693 3024}
30dea054 3025
0c77152e
RR		 3026static gint gs_pop_x = 0;
3027static gint gs_pop_y = 0;
3028
a234a61a
VZ		 3029static void pop_pos_callback( GtkMenu * WXUNUSED(menu),
3030 gint *x, gint *y,
3031 wxWindow *win )
0c77152e
RR		 3032{
3033 win->ClientToScreen( &gs_pop_x, &gs_pop_y );
3034 *x = gs_pop_x;
3035 *y = gs_pop_y;
3036}
3037
a1665b22 3038bool wxWindow::DoPopupMenu( wxMenu *menu, int x, int y )
30dea054 3039{
223d09f6 3040 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
47d67540 3041
223d09f6 3042 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
8bbe427f 3043
1ecc4d80 3044 SetInvokingWindow( menu, this );
ff8bfdbb 3045
631f1bfe
JS		 3046 menu->UpdateUI();
3047
0c77152e
RR		 3048 gs_pop_x = x;
3049 gs_pop_y = y;
ff8bfdbb 3050
2259e007 3051 bool is_waiting = TRUE;
148cd9b6 3052
2259e007
RR		 3053 gtk_signal_connect( GTK_OBJECT(menu->m_menu), "hide",
3054 GTK_SIGNAL_FUNC(gtk_pop_hide_callback), (gpointer)&is_waiting );
3055
1ecc4d80 3056 gtk_menu_popup(
47d67540 3057 GTK_MENU(menu->m_menu),
0c77152e
RR		 3058 (GtkWidget *) NULL, // parent menu shell
3059 (GtkWidget *) NULL, // parent menu item
3060 (GtkMenuPositionFunc) pop_pos_callback,
3061 (gpointer) this, // client data
3062 0, // button used to activate it
54517652 3063 gs_timeLastClick // the time of activation
47d67540 3064 );
148cd9b6 3065
956dbab1
RR		 3066 while (is_waiting)
3067 {
3068 while (gtk_events_pending())
3069 gtk_main_iteration();
3070 }
2259e007 3071
1ecc4d80 3072 return TRUE;
30dea054
RR		 3073}
3074
06cfab17 3075#if wxUSE_DRAG_AND_DROP
ac57418f 3076
c801d85f
KB		 3077void wxWindow::SetDropTarget( wxDropTarget *dropTarget )
3078{
223d09f6 3079 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 3080
1ecc4d80 3081 GtkWidget *dnd_widget = GetConnectWidget();
47d67540 3082
1ecc4d80 3083 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
47d67540 3084
1ecc4d80
RR		 3085 if (m_dropTarget) delete m_dropTarget;
3086 m_dropTarget = dropTarget;
47d67540 3087
1ecc4d80 3088 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
362c6693 3089}
c801d85f 3090
f03fc89f 3091#endif // wxUSE_DRAG_AND_DROP
ac57418f 3092
68dda785 3093GtkWidget* wxWindow::GetConnectWidget()
e3e65dac 3094{
1ecc4d80
RR		 3095 GtkWidget *connect_widget = m_widget;
3096 if (m_wxwindow) connect_widget = m_wxwindow;
47d67540 3097
1ecc4d80 3098 return connect_widget;
e3e65dac 3099}
47d67540 3100
903f689b
RR		 3101bool wxWindow::IsOwnGtkWindow( GdkWindow *window )
3102{
148cd9b6 3103 if (m_wxwindow)
da048e3d 3104 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
148cd9b6 3105
1ecc4d80 3106 return (window == m_widget->window);
903f689b
RR		 3107}
3108
f03fc89f 3109bool wxWindow::SetFont( const wxFont &font )
c801d85f 3110{
223d09f6 3111 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
c801d85f 3112
739730ca
RR		 3113 if (!wxWindowBase::SetFont(font))
3114 {
454e2a22 3115 return FALSE;
739730ca 3116 }
9c288e4d 3117
ae0bdb01 3118 wxColour sysbg = wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE );
f03fc89f 3119 if ( sysbg == m_backgroundColour )
ae0bdb01
RR		 3120 {
3121 m_backgroundColour = wxNullColour;
3122 ApplyWidgetStyle();
ff8bfdbb
VZ		 3123 m_backgroundColour = sysbg;
3124 }
ae0bdb01
RR		 3125 else
3126 {
3127 ApplyWidgetStyle();
3128 }
c801d85f 3129
f03fc89f 3130 return TRUE;
362c6693 3131}
c801d85f 3132
68dda785 3133void wxWindow::CaptureMouse()
c801d85f 3134{
223d09f6 3135 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 3136
223d09f6 3137 wxCHECK_RET( g_captureWindow == NULL, wxT("CaptureMouse called twice") );
47d67540 3138
ed673c6a
RR		 3139 GdkWindow *window = (GdkWindow*) NULL;
3140 if (m_wxwindow)
da048e3d 3141 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 3142 else
3143 window = GetConnectWidget()->window;
148cd9b6 3144
ed673c6a 3145 if (!window) return;
c50f1fb9 3146
ed673c6a 3147 gdk_pointer_grab( window, FALSE,
1ecc4d80
RR		 3148 (GdkEventMask)
3149 (GDK_BUTTON_PRESS_MASK |
3150 GDK_BUTTON_RELEASE_MASK |
148cd9b6 3151 GDK_POINTER_MOTION_HINT_MASK |
1ecc4d80 3152 GDK_POINTER_MOTION_MASK),
ff8bfdbb 3153 (GdkWindow *) NULL,
72195a0f 3154 m_cursor.GetCursor(),
b02da6b1 3155 (guint32)GDK_CURRENT_TIME );
72195a0f 3156 g_captureWindow = this;
362c6693 3157}
c801d85f 3158
68dda785 3159void wxWindow::ReleaseMouse()
c801d85f 3160{
223d09f6 3161 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 3162
223d09f6 3163 wxCHECK_RET( g_captureWindow, wxT("ReleaseMouse called twice") );
47d67540 3164
ed673c6a
RR		 3165 GdkWindow *window = (GdkWindow*) NULL;
3166 if (m_wxwindow)
da048e3d 3167 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 3168 else
3169 window = GetConnectWidget()->window;
148cd9b6 3170
b02da6b1
VZ		 3171 if (!window)
3172 return;
c50f1fb9 3173
b02da6b1 3174 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
72195a0f 3175 g_captureWindow = (wxWindow*) NULL;
362c6693 3176}
c801d85f 3177
f03fc89f 3178bool wxWindow::IsRetained() const
c801d85f 3179{
1ecc4d80 3180 return FALSE;
362c6693 3181}
c801d85f 3182
debe6624 3183void wxWindow::SetScrollbar( int orient, int pos, int thumbVisible,
cb43b372 3184 int range, bool refresh )
c801d85f 3185{
223d09f6 3186 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
8bbe427f 3187
223d09f6 3188 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
c801d85f 3189
1ecc4d80 3190 m_hasScrolling = TRUE;
47d67540 3191
1ecc4d80 3192 if (orient == wxHORIZONTAL)
cb43b372 3193 {
1ecc4d80
RR		 3194 float fpos = (float)pos;
3195 float frange = (float)range;
3196 float fthumb = (float)thumbVisible;
3197 if (fpos > frange-fthumb) fpos = frange-fthumb;
3198 if (fpos < 0.0) fpos = 0.0;
3199
3200 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
3201 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
3202 {
3203 SetScrollPos( orient, pos, refresh );
3204 return;
3205 }
47d67540 3206
1ecc4d80 3207 m_oldHorizontalPos = fpos;
47d67540 3208
1ecc4d80
RR		 3209 m_hAdjust->lower = 0.0;
3210 m_hAdjust->upper = frange;
3211 m_hAdjust->value = fpos;
3212 m_hAdjust->step_increment = 1.0;
3213 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
3214 m_hAdjust->page_size = fthumb;
cb43b372 3215 }
1ecc4d80
RR		 3216 else
3217 {
3218 float fpos = (float)pos;
3219 float frange = (float)range;
3220 float fthumb = (float)thumbVisible;
3221 if (fpos > frange-fthumb) fpos = frange-fthumb;
3222 if (fpos < 0.0) fpos = 0.0;
3223
3224 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
3225 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
3226 {
3227 SetScrollPos( orient, pos, refresh );
3228 return;
3229 }
47d67540 3230
1ecc4d80 3231 m_oldVerticalPos = fpos;
47d67540 3232
1ecc4d80
RR		 3233 m_vAdjust->lower = 0.0;
3234 m_vAdjust->upper = frange;
3235 m_vAdjust->value = fpos;
3236 m_vAdjust->step_increment = 1.0;
3237 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
3238 m_vAdjust->page_size = fthumb;
3239 }
47d67540 3240
eb082a08
RR		 3241 if (orient == wxHORIZONTAL)
3242 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
3243 else
3244 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
362c6693 3245}
c801d85f 3246
debe6624 3247void wxWindow::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
c801d85f 3248{
223d09f6 3249 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
1ecc4d80 3250
223d09f6 3251 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
1ecc4d80
RR		 3252
3253 if (orient == wxHORIZONTAL)
3254 {
3255 float fpos = (float)pos;
3256 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
3257 if (fpos < 0.0) fpos = 0.0;
3258 m_oldHorizontalPos = fpos;
3259
3260 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
3261 m_hAdjust->value = fpos;
3262 }
3263 else
3264 {
3265 float fpos = (float)pos;
3266 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
3267 if (fpos < 0.0) fpos = 0.0;
3268 m_oldVerticalPos = fpos;
ff8bfdbb 3269
1ecc4d80
RR		 3270 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
3271 m_vAdjust->value = fpos;
3272 }
47d67540 3273
5e014a0c
RR		 3274/*
3275 if (!m_isScrolling)
47d67540 3276 {
5e014a0c 3277*/
1ecc4d80
RR		 3278 if (m_wxwindow->window)
3279 {
3280 if (orient == wxHORIZONTAL)
3281 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
3282 else
3283 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
3284 }
5e014a0c 3285/*
cb43b372 3286 }
5e014a0c 3287*/
362c6693 3288}
c801d85f 3289
debe6624 3290int wxWindow::GetScrollThumb( int orient ) const
c801d85f 3291{
223d09f6 3292 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 3293
223d09f6 3294 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
47d67540 3295
1ecc4d80
RR		 3296 if (orient == wxHORIZONTAL)
3297 return (int)(m_hAdjust->page_size+0.5);
3298 else
3299 return (int)(m_vAdjust->page_size+0.5);
362c6693 3300}
c801d85f 3301
debe6624 3302int wxWindow::GetScrollPos( int orient ) const
c801d85f 3303{
223d09f6 3304 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 3305
223d09f6 3306 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
c801d85f 3307
1ecc4d80
RR		 3308 if (orient == wxHORIZONTAL)
3309 return (int)(m_hAdjust->value+0.5);
3310 else
3311 return (int)(m_vAdjust->value+0.5);
362c6693 3312}
c801d85f 3313
debe6624 3314int wxWindow::GetScrollRange( int orient ) const
c801d85f 3315{
223d09f6 3316 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 3317
223d09f6 3318 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
c801d85f 3319
1ecc4d80
RR		 3320 if (orient == wxHORIZONTAL)
3321 return (int)(m_hAdjust->upper+0.5);
3322 else
3323 return (int)(m_vAdjust->upper+0.5);
362c6693 3324}
c801d85f 3325
debe6624 3326void wxWindow::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
c801d85f 3327{
223d09f6 3328 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 3329
223d09f6 3330 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
c801d85f 3331
00e12320
RR		 3332/*
3333 printf( "ScrollWindow: %d %d\n", dx, dy );
3334*/
3335
da048e3d 3336 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
ed673c6a
RR		 3337
3338/*
a2053b27 3339 if (!m_scrollGC)
96d5ab4d 3340 {
a2053b27
RR		 3341 m_scrollGC = gdk_gc_new( m_wxwindow->window );
3342 gdk_gc_set_exposures( m_scrollGC, TRUE );
96d5ab4d 3343 }
c50f1fb9 3344
ea5c6ca7
RR		 3345 wxNode *node = m_children.First();
3346 while (node)
3347 {
3348 wxWindow *child = (wxWindow*) node->Data();
c50f1fb9
VZ		 3349 int sx = 0;
3350 int sy = 0;
3351 child->GetSize( &sx, &sy );
3352 child->SetSize( child->m_x + dx, child->m_y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
3353 node = node->Next();
ea5c6ca7 3354 }
96d5ab4d 3355
c801d85f
KB		 3356 int cw = 0;
3357 int ch = 0;
3358 GetClientSize( &cw, &ch );
c801d85f
KB		 3359 int w = cw - abs(dx);
3360 int h = ch - abs(dy);
c50f1fb9 3361
c801d85f
KB		 3362 if ((h < 0) || (w < 0))
3363 {
1ecc4d80 3364 Refresh();
362c6693 3365 }
a2053b27 3366 else
c801d85f 3367 {
a2053b27
RR		 3368 int s_x = 0;
3369 int s_y = 0;
3370 if (dx < 0) s_x = -dx;
3371 if (dy < 0) s_y = -dy;
3372 int d_x = 0;
3373 int d_y = 0;
3374 if (dx > 0) d_x = dx;
3375 if (dy > 0) d_y = dy;
c801d85f 3376
a2053b27
RR		 3377 gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
3378 m_wxwindow->window, s_x, s_y, w, h );
c801d85f 3379
a2053b27
RR		 3380 wxRect rect;
3381 if (dx < 0) rect.x = cw+dx; else rect.x = 0;
3382 if (dy < 0) rect.y = ch+dy; else rect.y = 0;
3383 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
3384 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
c801d85f 3385
a2053b27
RR		 3386 Refresh( TRUE, &rect );
3387 }
ed673c6a 3388*/
c801d85f
KB		 3389}
3390
f03fc89f 3391void wxWindow::SetScrolling(bool scroll)
c801d85f 3392{
f03fc89f 3393 m_isScrolling = g_blockEventsOnScroll = scroll;
c801d85f 3394}
wxWidgets (Impactor)