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