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