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