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