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