]> git.saurik.com Git - wxWidgets.git/blame - src/gtk/window.cpp
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Warning fix.
[wxWidgets.git] / src / gtk / window.cpp
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
f6bcfd97 2// Name: gtk/window.cpp
c801d85f
KB		 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
d02af7bb
JJ		 15#ifdef __VMS
16#define XWarpPointer XWARPPOINTER
17#endif
18
c801d85f
KB		 19#include "wx/defs.h"
20#include "wx/window.h"
33611ebb 21#include "wx/dcclient.h"
c801d85f
KB		 22#include "wx/frame.h"
23#include "wx/app.h"
24#include "wx/layout.h"
25#include "wx/utils.h"
26#include "wx/dialog.h"
27#include "wx/msgdlg.h"
0fc5dbf5 28#include "wx/module.h"
bfc6fde4 29
06cfab17 30#if wxUSE_DRAG_AND_DROP
bfc6fde4 31 #include "wx/dnd.h"
ac57418f 32#endif
bfc6fde4 33
cad880f5 34#if wxUSE_TOOLTIPS
bfc6fde4 35 #include "wx/tooltip.h"
cad880f5 36#endif
bfc6fde4 37
f6bcfd97
BP		 38#if wxUSE_CARET
39 #include "wx/caret.h"
40#endif // wxUSE_CARET
41
ab93a576 42#if wxUSE_TEXTCTRL
0fc5dbf5 43 #include "wx/textctrl.h"
ab93a576
RD		 44#endif
45
30dea054 46#include "wx/menu.h"
d4c99d6f 47#include "wx/statusbr.h"
b4071e91 48#include "wx/intl.h"
3bc755fc 49#include "wx/settings.h"
3069ac4e 50#include "wx/log.h"
48d011c8 51#include "wx/fontutil.h"
b4071e91 52
3ac8d3bc
RR		 53#ifdef __WXDEBUG__
54 #include "wx/thread.h"
55#endif
56
b4071e91 57#include <math.h>
fab591c5 58#include <ctype.h>
c801d85f 59
9e691f46 60#include "wx/gtk/private.h"
3ac8d3bc
RR		 61#include <gdk/gdkprivate.h>
62#include <gdk/gdkkeysyms.h>
3ac8d3bc 63#include <gdk/gdkx.h>
6bc8a1c8 64
8cb9f0d0
RR		 65#include <gtk/gtk.h>
66#include <gtk/gtkprivate.h>
67
68#include "wx/gtk/win_gtk.h"
69
2b5f62a0
VZ		 70#ifdef __WXGTK20__
71#include <pango/pangox.h>
72#endif
73
9e691f46
VZ		 74#ifdef __WXGTK20__
75 #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d))
76#else
77 #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d))
78#endif
79
4e5a4c69
RR		 80#ifdef __WXGTK20__
81 #ifdef HAVE_XIM
82 #undef HAVE_XIM
83 #endif
84#endif
85
af1d24da
RR		 86#ifdef __WXGTK20__
87extern GtkContainerClass *pizza_parent_class;
88#endif
89
868a2826
RR		 90//-----------------------------------------------------------------------------
91// documentation on internals
92//-----------------------------------------------------------------------------
93
94/*
95 I have been asked several times about writing some documentation about
96 the GTK port of wxWindows, especially its internal structures. Obviously,
97 you cannot understand wxGTK without knowing a little about the GTK, but
47d67540 98 some more information about what the wxWindow, which is the base class
868a2826 99 for all other window classes, does seems required as well.
47d67540 100
30760ce7
RR		 101 I)
102
868a2826 103 What does wxWindow do? It contains the common interface for the following
e380f72b 104 jobs of its descendants:
47d67540 105
868a2826 106 1) Define the rudimentary behaviour common to all window classes, such as
e380f72b
RR		 107 resizing, intercepting user input (so as to make it possible to use these
108 events for special purposes in a derived class), window names etc.
868a2826
RR		 109
110 2) Provide the possibility to contain and manage children, if the derived
111 class is allowed to contain children, which holds true for those window
e380f72b 112 classes which do not display a native GTK widget. To name them, these
868a2826 113 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
47d67540 114 work classes are a special case and are handled a bit differently from
e380f72b 115 the rest. The same holds true for the wxNotebook class.
47d67540 116
868a2826
RR		 117 3) Provide the possibility to draw into a client area of a window. This,
118 too, only holds true for classes that do not display a native GTK widget
119 as above.
47d67540 120
e380f72b
RR		 121 4) Provide the entire mechanism for scrolling widgets. This actual inter-
122 face for this is usually in wxScrolledWindow, but the GTK implementation
868a2826 123 is in this class.
47d67540 124
868a2826
RR		 125 5) A multitude of helper or extra methods for special purposes, such as
126 Drag'n'Drop, managing validators etc.
47d67540 127
30760ce7
RR		 128 6) Display a border (sunken, raised, simple or none).
129
e380f72b
RR		 130 Normally one might expect, that one wxWindows window would always correspond
131 to one GTK widget. Under GTK, there is no such allround widget that has all
868a2826
RR		 132 the functionality. Moreover, the GTK defines a client area as a different
133 widget from the actual widget you are handling. Last but not least some
134 special classes (e.g. wxFrame) handle different categories of widgets and
135 still have the possibility to draw something in the client area.
136 It was therefore required to write a special purpose GTK widget, that would
137 represent a client area in the sense of wxWindows capable to do the jobs
138 2), 3) and 4). I have written this class and it resides in win_gtk.c of
139 this directory.
47d67540 140
868a2826 141 All windows must have a widget, with which they interact with other under-
e380f72b 142 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
868a2826 143 thw wxWindow class has a member variable called m_widget which holds a
e380f72b
RR		 144 pointer to this widget. When the window class represents a GTK native widget,
145 this is (in most cases) the only GTK widget the class manages. E.g. the
146 wxStatitText class handles only a GtkLabel widget a pointer to which you
147 can find in m_widget (defined in wxWindow)
8bbe427f 148
e380f72b 149 When the class has a client area for drawing into and for containing children
da048e3d 150 it has to handle the client area widget (of the type GtkPizza, defined in
8bbe427f
VZ		 151 win_gtk.c), but there could be any number of widgets, handled by a class
152 The common rule for all windows is only, that the widget that interacts with
153 the rest of GTK must be referenced in m_widget and all other widgets must be
154 children of this widget on the GTK level. The top-most widget, which also
155 represents the client area, must be in the m_wxwindow field and must be of
da048e3d 156 the type GtkPizza.
47d67540 157
868a2826
RR		 158 As I said, the window classes that display a GTK native widget only have
159 one widget, so in the case of e.g. the wxButton class m_widget holds a
160 pointer to a GtkButton widget. But windows with client areas (for drawing
161 and children) have a m_widget field that is a pointer to a GtkScrolled-
da048e3d 162 Window and a m_wxwindow field that is pointer to a GtkPizza and this
868a2826 163 one is (in the GTK sense) a child of the GtkScrolledWindow.
47d67540 164
868a2826
RR		 165 If the m_wxwindow field is set, then all input to this widget is inter-
166 cepted and sent to the wxWindows class. If not, all input to the widget
167 that gets pointed to by m_widget gets intercepted and sent to the class.
148cd9b6 168
30760ce7 169 II)
148cd9b6 170
30760ce7
RR		 171 The design of scrolling in wxWindows is markedly different from that offered
172 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
173 clicking on a scrollbar belonging to scrolled window will inevitably move
174 the window. In wxWindows, the scrollbar will only emit an event, send this
175 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
da048e3d 176 which actually moves the window and its subchildren. Note that GtkPizza
30760ce7
RR		 177 memorizes how much it has been scrolled but that wxWindows forgets this
178 so that the two coordinates systems have to be kept in synch. This is done
da048e3d 179 in various places using the pizza->xoffset and pizza->yoffset values.
148cd9b6
VZ		 180
181 III)
182
30760ce7
RR		 183 Singularily the most broken code in GTK is the code that is supposes to
184 inform subwindows (child windows) about new positions. Very often, duplicate
185 events are sent without changes in size or position, equally often no
186 events are sent at all (All this is due to a bug in the GtkContainer code
187 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
188 GTK's own system and it simply waits for size events for toplevel windows
189 and then iterates down the respective size events to all window. This has
190 the disadvantage, that windows might get size events before the GTK widget
191 actually has the reported size. This doesn't normally pose any problem, but
3017f78d 192 the OpenGl drawing routines rely on correct behaviour. Therefore, I have
30760ce7
RR		 193 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
194 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
195 window that is used for OpenGl output really has that size (as reported by
196 GTK).
197
198 IV)
148cd9b6 199
30760ce7
RR		 200 If someone at some point of time feels the immense desire to have a look at,
201 change or attempt to optimse the Refresh() logic, this person will need an
202 intimate understanding of what a "draw" and what an "expose" events are and
203 what there are used for, in particular when used in connection with GTK's
204 own windowless widgets. Beware.
148cd9b6 205
30760ce7 206 V)
148cd9b6 207
30760ce7
RR		 208 Cursors, too, have been a constant source of pleasure. The main difficulty
209 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
210 for the parent. To prevent this from doing too much harm, I use idle time
211 to set the cursor over and over again, starting from the toplevel windows
212 and ending with the youngest generation (speaking of parent and child windows).
213 Also don't forget that cursors (like much else) are connected to GdkWindows,
214 not GtkWidgets and that the "window" field of a GtkWidget might very well
148cd9b6 215 point to the GdkWindow of the parent widget (-> "window less widget") and
30760ce7 216 that the two obviously have very different meanings.
868a2826
RR		 217
218*/
219
f03fc89f
VZ		 220//-----------------------------------------------------------------------------
221// data
222//-----------------------------------------------------------------------------
223
224extern wxList wxPendingDelete;
225extern bool g_blockEventsOnDrag;
226extern bool g_blockEventsOnScroll;
238d735d 227extern wxCursor g_globalCursor;
f68586e5 228
4e5a4c69
RR		 229static GdkGC *g_eraseGC = NULL;
230
1e6feb95
VZ		 231// mouse capture state: the window which has it and if the mouse is currently
232// inside it
233static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL;
234static bool g_captureWindowHasMouse = FALSE;
235
236/* extern */ wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL;
237
238// the last window which had the focus - this is normally never NULL (except
239// if we never had focus at all) as even when g_focusWindow is NULL it still
240// keeps its previous value
d7fa7eaa 241static wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL;
148cd9b6 242
e8c12a53
VS		 243// the frame that is currently active (i.e. its child has focus). It is
244// used to generate wxActivateEvents
d7fa7eaa 245static wxWindowGTK *g_activeFrame = (wxWindowGTK*) NULL;
e8c12a53
VS		 246static bool g_activeFrameLostFocus = FALSE;
247
d7fa7eaa
RR		 248// If a window get the focus set but has not been realized
249// yet, defer setting the focus to idle time.
250wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL;
251
148cd9b6
VZ		 252// if we detect that the app has got/lost the focus, we set this variable to
253// either TRUE or FALSE and an activate event will be sent during the next
254// OnIdle() call and it is reset to -1: this value means that we shouldn't
255// send any activate events at all
256static int g_sendActivateEvent = -1;
f03fc89f
VZ		 257
258/* hack: we need something to pass to gtk_menu_popup, so we store the time of
259 the last click here */
260static guint32 gs_timeLastClick = 0;
261
3ac8d3bc
RR		 262extern bool g_mainThreadLocked;
263
2e563988
RR		 264//-----------------------------------------------------------------------------
265// debug
266//-----------------------------------------------------------------------------
267
d52e91c9 268#ifndef __WXGTK20__
2b5f62a0 269#define DISABLE_STYLE_IF_BROKEN_THEME 0
d52e91c9 270#endif
a56fcaaf 271
2e563988
RR		 272#ifdef __WXDEBUG__
273
c6e62f74
KB		 274#if wxUSE_THREADS
275# define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
276#else
277# define DEBUG_MAIN_THREAD
278#endif
559d79aa
BJ		 279#else
280#define DEBUG_MAIN_THREAD
f03fc89f 281#endif // Debug
ff8bfdbb 282
6cad4f1b
VZ		 283// the trace mask used for the focus debugging messages
284#define TRACE_FOCUS _T("focus")
285
85eb36c2
RR		 286//-----------------------------------------------------------------------------
287// missing gdk functions
288//-----------------------------------------------------------------------------
289
290void
291gdk_window_warp_pointer (GdkWindow *window,
c50f1fb9
VZ		 292 gint x,
293 gint y)
85eb36c2 294{
dd00f3f6 295#ifndef __WXGTK20__
85eb36c2 296 GdkWindowPrivate *priv;
dd00f3f6 297#endif
c50f1fb9 298
85eb36c2 299 if (!window)
27df579a 300 window = GDK_ROOT_PARENT();
c50f1fb9 301
dd00f3f6
OK		 302#ifdef __WXGTK20__
303 if (!GDK_WINDOW_DESTROYED(window))
304 {
305 XWarpPointer (GDK_WINDOW_XDISPLAY(window),
306 None, /* not source window -> move from anywhere */
307 GDK_WINDOW_XID(window), /* dest window */
308 0, 0, 0, 0, /* not source window -> move from anywhere */
309 x, y );
310 }
311#else
85eb36c2 312 priv = (GdkWindowPrivate*) window;
c50f1fb9 313
85eb36c2
RR		 314 if (!priv->destroyed)
315 {
c50f1fb9 316 XWarpPointer (priv->xdisplay,
85eb36c2 317 None, /* not source window -> move from anywhere */
c50f1fb9 318 priv->xwindow, /* dest window */
85eb36c2 319 0, 0, 0, 0, /* not source window -> move from anywhere */
c50f1fb9 320 x, y );
85eb36c2 321 }
dd00f3f6 322#endif
85eb36c2
RR		 323}
324
acfd422a 325//-----------------------------------------------------------------------------
a2053b27 326// idle system
acfd422a
RR		 327//-----------------------------------------------------------------------------
328
a2053b27
RR		 329extern void wxapp_install_idle_handler();
330extern bool g_isIdle;
331
ed673c6a
RR		 332//-----------------------------------------------------------------------------
333// local code (see below)
334//-----------------------------------------------------------------------------
335
f6bcfd97 336// returns the child of win which currently has focus or NULL if not found
1e6feb95 337//
fc71ef6e 338// Note: can't be static, needed by textctrl.cpp.
3379ed37 339wxWindow *wxFindFocusedChild(wxWindowGTK *win)
f6bcfd97 340{
3379ed37 341 wxWindow *winFocus = wxWindowGTK::FindFocus();
f6bcfd97 342 if ( !winFocus )
3379ed37 343 return (wxWindow *)NULL;
f6bcfd97
BP		 344
345 if ( winFocus == win )
3379ed37 346 return (wxWindow *)win;
f6bcfd97
BP		 347
348 for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
349 node;
350 node = node->GetNext() )
351 {
3379ed37 352 wxWindow *child = wxFindFocusedChild(node->GetData());
f6bcfd97
BP		 353 if ( child )
354 return child;
355 }
356
3379ed37 357 return (wxWindow *)NULL;
f6bcfd97
BP		 358}
359
1e6feb95 360static void draw_frame( GtkWidget *widget, wxWindowGTK *win )
ed673c6a 361{
1e6feb95
VZ		 362 // wxUniversal widgets draw the borders and scrollbars themselves
363#ifndef __WXUNIVERSAL__
ed673c6a
RR		 364 if (!win->m_hasVMT)
365 return;
366
367 int dw = 0;
368 int dh = 0;
369
5b8a521e 370 if (win->m_hasScrolling)
ed673c6a 371 {
beab25bd 372 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(widget);
2daa0ce9 373
beab25bd
RR		 374 GtkRequisition vscroll_req;
375 vscroll_req.width = 2;
376 vscroll_req.height = 2;
377 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
378 (scroll_window->vscrollbar, &vscroll_req );
2daa0ce9 379
beab25bd
RR		 380 GtkRequisition hscroll_req;
381 hscroll_req.width = 2;
382 hscroll_req.height = 2;
383 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
384 (scroll_window->hscrollbar, &hscroll_req );
9000c624 385
beab25bd 386 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(widget) );
ed673c6a 387
beab25bd
RR		 388 if (scroll_window->vscrollbar_visible)
389 {
390 dw += vscroll_req.width;
391 dw += scroll_class->scrollbar_spacing;
392 }
ed673c6a 393
beab25bd
RR		 394 if (scroll_window->hscrollbar_visible)
395 {
396 dh += hscroll_req.height;
397 dh += scroll_class->scrollbar_spacing;
398 }
399}
ed673c6a
RR		 400
401 int dx = 0;
402 int dy = 0;
403 if (GTK_WIDGET_NO_WINDOW (widget))
404 {
405 dx += widget->allocation.x;
406 dy += widget->allocation.y;
407 }
408
409 if (win->HasFlag(wxRAISED_BORDER))
410 {
411 gtk_draw_shadow( widget->style,
412 widget->window,
413 GTK_STATE_NORMAL,
414 GTK_SHADOW_OUT,
415 dx, dy,
07f5b19a 416 widget->allocation.width-dw, widget->allocation.height-dh );
ed673c6a
RR		 417 return;
418 }
419
420 if (win->HasFlag(wxSUNKEN_BORDER))
421 {
422 gtk_draw_shadow( widget->style,
423 widget->window,
424 GTK_STATE_NORMAL,
425 GTK_SHADOW_IN,
426 dx, dy,
07f5b19a 427 widget->allocation.width-dw, widget->allocation.height-dh );
ed673c6a
RR		 428 return;
429 }
148cd9b6 430
ed673c6a
RR		 431 if (win->HasFlag(wxSIMPLE_BORDER))
432 {
433 GdkGC *gc;
b02da6b1 434 gc = gdk_gc_new( widget->window );
ed673c6a 435 gdk_gc_set_foreground( gc, &widget->style->black );
148cd9b6 436 gdk_draw_rectangle( widget->window, gc, FALSE,
ed673c6a 437 dx, dy,
07f5b19a 438 widget->allocation.width-dw-1, widget->allocation.height-dh-1 );
ed673c6a
RR		 439 gdk_gc_unref( gc );
440 return;
441 }
1e6feb95 442#endif // __WXUNIVERSAL__
ed673c6a
RR		 443}
444
445//-----------------------------------------------------------------------------
446// "expose_event" of m_widget
447//-----------------------------------------------------------------------------
448
1e6feb95 449gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win )
ed673c6a 450{
b6fa52db 451 if (gdk_event->count > 0) return FALSE;
1e6feb95 452
ed673c6a 453 draw_frame( widget, win );
1e6feb95 454
af1d24da
RR		 455#ifdef __WXGTK20__
456
457 (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
0fc5dbf5
VZ		 458
459#endif
b6fa52db 460 return TRUE;
ed673c6a
RR		 461}
462
463//-----------------------------------------------------------------------------
147bc491 464// "draw" of m_widget
ed673c6a
RR		 465//-----------------------------------------------------------------------------
466
67d78217
RR		 467#ifndef __WXGTK20__
468
1e6feb95 469static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win )
ed673c6a
RR		 470{
471 draw_frame( widget, win );
472}
473
1c6896d7 474#endif // GTK+ < 2.0
c5b42c87 475
47c93b63
RR		 476//-----------------------------------------------------------------------------
477// "size_request" of m_widget
478//-----------------------------------------------------------------------------
479
480static void gtk_window_size_request_callback( GtkWidget *widget, GtkRequisition *requisition, wxWindow *win )
481{
482 int w,h;
483 win->GetSize( &w, &h );
484 if (w < 2) w = 2;
485 if (h < 2) h = 2;
1e6feb95 486
47c93b63
RR		 487 requisition->height = h;
488 requisition->width = w;
489}
490
c801d85f 491//-----------------------------------------------------------------------------
034be888 492// "expose_event" of m_wxwindow
c801d85f
KB		 493//-----------------------------------------------------------------------------
494
1e6feb95
VZ		 495static int gtk_window_expose_callback( GtkWidget *widget,
496 GdkEventExpose *gdk_event,
497 wxWindow *win )
47d67540 498{
3ac8d3bc
RR		 499 DEBUG_MAIN_THREAD
500
b6fa52db
RR		 501 if (g_isIdle)
502 wxapp_install_idle_handler();
1e6feb95 503
3fc6e5fa
RR		 504#ifdef __WXGTK20__
505 // This callback gets called in drawing-idle time under
506 // GTK 2.0, so we don't need to defer anything to idle
507 // time anymore.
2b5f62a0 508
3fc6e5fa
RR		 509 GtkPizza *pizza = GTK_PIZZA( widget );
510 if (gdk_event->window != pizza->bin_window) return FALSE;
2b5f62a0 511
d7fa7eaa
RR		 512#if 0
513 if (win->GetName())
3d2d8da1
RR		 514 {
515 wxPrintf( wxT("OnExpose from ") );
516 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
517 wxPrintf( win->GetClassInfo()->GetClassName() );
518 wxPrintf( wxT(" %d %d %d %d\n"), (int)gdk_event->area.x,
519 (int)gdk_event->area.y,
520 (int)gdk_event->area.width,
521 (int)gdk_event->area.height );
522 }
d7fa7eaa 523#endif
1e6feb95 524
b15ed747
RR		 525 win->GetUpdateRegion() = wxRegion( gdk_event->region );
526
527 win->GtkSendPaintEvents();
528
2b5f62a0 529
3fc6e5fa 530 // Let parent window draw window less widgets
b15ed747
RR		 531 (* GTK_WIDGET_CLASS (pizza_parent_class)->expose_event) (widget, gdk_event);
532#else
533 // This gets called immediately after an expose event
534 // under GTK 1.2 so we collect the calls and wait for
535 // the idle handler to pick things up.
2b5f62a0 536
2bc6945a
RR		 537 win->GetUpdateRegion().Union( gdk_event->area.x,
538 gdk_event->area.y,
539 gdk_event->area.width,
540 gdk_event->area.height );
d665f50b
JS		 541 win->m_clearRegion.Union( gdk_event->area.x,
542 gdk_event->area.y,
543 gdk_event->area.width,
544 gdk_event->area.height );
0e09f76e 545
8f3e7ecc 546 // Actual redrawing takes place in idle time.
62cb3cd8 547 // win->GtkUpdate();
0fc5dbf5 548#endif
f7a11f8c 549
3fc6e5fa 550 return FALSE;
b6fa52db
RR		 551}
552
553//-----------------------------------------------------------------------------
554// "event" of m_wxwindow
555//-----------------------------------------------------------------------------
556
beab25bd
RR		 557// GTK thinks it is clever and filters out a certain amount of "unneeded"
558// expose events. We need them, of course, so we override the main event
559// procedure in GtkWidget by giving our own handler for all system events.
560// There, we look for expose events ourselves whereas all other events are
561// handled normally.
b6fa52db 562
1e6feb95
VZ		 563gint gtk_window_event_event_callback( GtkWidget *widget,
564 GdkEventExpose *event,
565 wxWindow *win )
b6fa52db
RR		 566{
567 if (event->type == GDK_EXPOSE)
568 {
569 gint ret = gtk_window_expose_callback( widget, event, win );
570 return ret;
571 }
572
b6fa52db 573 return FALSE;
362c6693 574}
c801d85f
KB		 575
576//-----------------------------------------------------------------------------
034be888 577// "draw" of m_wxwindow
2f2aa628 578//-----------------------------------------------------------------------------
c801d85f 579
67d78217
RR		 580#ifndef __WXGTK20__
581
beab25bd 582// This callback is a complete replacement of the gtk_pizza_draw() function,
67d78217 583// which is disabled.
b6fa52db 584
1e6feb95
VZ		 585static void gtk_window_draw_callback( GtkWidget *widget,
586 GdkRectangle *rect,
587 wxWindow *win )
47d67540 588{
3ac8d3bc
RR		 589 DEBUG_MAIN_THREAD
590
c50f1fb9 591 if (g_isIdle)
a2053b27 592 wxapp_install_idle_handler();
2d19ad25 593
beab25bd
RR		 594 // The wxNO_FULL_REPAINT_ON_RESIZE flag only works if
595 // there are no child windows.
e22454be
RR		 596 if ((win->HasFlag(wxNO_FULL_REPAINT_ON_RESIZE)) &&
597 (win->GetChildren().GetCount() == 0))
598 {
599 return;
600 }
2d19ad25 601
d7fa7eaa
RR		 602#if 0
603 if (win->GetName())
3d2d8da1
RR		 604 {
605 wxPrintf( wxT("OnDraw from ") );
606 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
607 wxPrintf( win->GetClassInfo()->GetClassName() );
608 wxPrintf( wxT(" %d %d %d %d\n"), (int)rect->x,
609 (int)rect->y,
610 (int)rect->width,
611 (int)rect->height );
612 }
d7fa7eaa 613#endif
1e6feb95 614
2e09dc2d 615#ifndef __WXUNIVERSAL__
b420fb6a 616 GtkPizza *pizza = GTK_PIZZA (widget);
2bc6945a 617
9cc7121f 618 if (win->GetThemeEnabled())
789dbcd4 619 {
9cc7121f
RR		 620 wxWindow *parent = win->GetParent();
621 while (parent && !parent->IsTopLevel())
789dbcd4 622 parent = parent->GetParent();
9cc7121f
RR		 623 if (!parent)
624 parent = win;
625
90350682
VZ		 626 gtk_paint_flat_box (parent->m_widget->style,
627 pizza->bin_window,
628 GTK_STATE_NORMAL,
629 GTK_SHADOW_NONE,
630 rect,
631 parent->m_widget,
632 (char *)"base",
633 0, 0, -1, -1);
789dbcd4 634 }
2e09dc2d 635#endif
1e6feb95 636
62cb3cd8 637 win->m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
9cc7121f 638 win->GetUpdateRegion().Union( rect->x, rect->y, rect->width, rect->height );
148cd9b6 639
62cb3cd8 640 // Update immediately, not in idle time.
010afced 641 win->GtkUpdate();
1e6feb95 642
8f3e7ecc 643#ifndef __WXUNIVERSAL__
beab25bd 644 // Redraw child widgets
e22454be
RR		 645 GList *children = pizza->children;
646 while (children)
647 {
beab25bd
RR		 648 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
649 children = children->next;
b420fb6a 650
beab25bd
RR		 651 GdkRectangle child_area;
652 if (gtk_widget_intersect (child->widget, rect, &child_area))
653 {
654 gtk_widget_draw (child->widget, &child_area /* (GdkRectangle*) NULL*/ );
655 }
e22454be 656 }
8f3e7ecc 657#endif
362c6693 658}
c801d85f 659
67d78217
RR		 660#endif
661
c801d85f 662//-----------------------------------------------------------------------------
b292e2f5 663// "key_press_event" from any window
c801d85f 664//-----------------------------------------------------------------------------
c801d85f 665
74710601
VZ		 666// set WXTRACE to this to see the key event codes on the console
667#define TRACE_KEYS _T("keyevent")
f17393f1 668
1c6896d7
VZ		 669// translates an X key symbol to WXK_XXX value
670//
671// if isChar is true it means that the value returned will be used for EVT_CHAR
672// event and then we choose the logical WXK_XXX, i.e. '/' for GDK_KP_Divide,
673// for example, while if it is false it means that the value is going to be
674// used for KEY_DOWN/UP events and then we translate GDK_KP_Divide to
675// WXK_NUMPAD_DIVIDE
676static long wxTranslateKeySymToWXKey(KeySym keysym, bool isChar)
677{
678 long key_code;
679
680 switch ( keysym )
681 {
682 // Shift, Control and Alt don't generate the CHAR events at all
683 case GDK_Shift_L:
684 case GDK_Shift_R:
685 key_code = isChar ? 0 : WXK_SHIFT;
686 break;
687 case GDK_Control_L:
688 case GDK_Control_R:
689 key_code = isChar ? 0 : WXK_CONTROL;
690 break;
691 case GDK_Meta_L:
692 case GDK_Meta_R:
693 case GDK_Alt_L:
694 case GDK_Alt_R:
695 case GDK_Super_L:
696 case GDK_Super_R:
697 key_code = isChar ? 0 : WXK_ALT;
698 break;
699
700 // neither do the toggle modifies
701 case GDK_Scroll_Lock:
702 key_code = isChar ? 0 : WXK_SCROLL;
703 break;
704
705 case GDK_Caps_Lock:
706 key_code = isChar ? 0 : WXK_CAPITAL;
707 break;
708
709 case GDK_Num_Lock:
710 key_code = isChar ? 0 : WXK_NUMLOCK;
711 break;
712
713
714 // various other special keys
715 case GDK_Menu:
716 key_code = WXK_MENU;
717 break;
718
719 case GDK_Help:
720 key_code = WXK_HELP;
721 break;
722
723 case GDK_BackSpace:
724 key_code = WXK_BACK;
725 break;
726
727 case GDK_ISO_Left_Tab:
728 case GDK_Tab:
729 key_code = WXK_TAB;
730 break;
731
732 case GDK_Linefeed:
733 case GDK_Return:
734 key_code = WXK_RETURN;
735 break;
736
737 case GDK_Clear:
738 key_code = WXK_CLEAR;
739 break;
740
741 case GDK_Pause:
742 key_code = WXK_PAUSE;
743 break;
744
745 case GDK_Select:
746 key_code = WXK_SELECT;
747 break;
748
749 case GDK_Print:
750 key_code = WXK_PRINT;
751 break;
752
753 case GDK_Execute:
754 key_code = WXK_EXECUTE;
755 break;
756
757 case GDK_Escape:
758 key_code = WXK_ESCAPE;
759 break;
760
761 // cursor and other extended keyboard keys
762 case GDK_Delete:
763 key_code = WXK_DELETE;
764 break;
765
766 case GDK_Home:
767 key_code = WXK_HOME;
768 break;
769
770 case GDK_Left:
771 key_code = WXK_LEFT;
772 break;
773
774 case GDK_Up:
775 key_code = WXK_UP;
776 break;
777
778 case GDK_Right:
779 key_code = WXK_RIGHT;
780 break;
781
782 case GDK_Down:
783 key_code = WXK_DOWN;
784 break;
785
786 case GDK_Prior: // == GDK_Page_Up
787 key_code = WXK_PRIOR;
788 break;
789
790 case GDK_Next: // == GDK_Page_Down
791 key_code = WXK_NEXT;
792 break;
793
794 case GDK_End:
795 key_code = WXK_END;
796 break;
797
798 case GDK_Begin:
799 key_code = WXK_HOME;
800 break;
801
802 case GDK_Insert:
803 key_code = WXK_INSERT;
804 break;
805
806
807 // numpad keys
808 case GDK_KP_0:
809 case GDK_KP_1:
810 case GDK_KP_2:
811 case GDK_KP_3:
812 case GDK_KP_4:
813 case GDK_KP_5:
814 case GDK_KP_6:
815 case GDK_KP_7:
816 case GDK_KP_8:
817 case GDK_KP_9:
818 key_code = (isChar ? '0' : WXK_NUMPAD0) + keysym - GDK_KP_0;
819 break;
820
821 case GDK_KP_Space:
822 key_code = isChar ? ' ' : WXK_NUMPAD_SPACE;
823 break;
824
825 case GDK_KP_Tab:
826 key_code = isChar ? WXK_TAB : WXK_NUMPAD_TAB;
827 break;
828
829 case GDK_KP_Enter:
830 key_code = isChar ? WXK_RETURN : WXK_NUMPAD_ENTER;
831 break;
832
833 case GDK_KP_F1:
834 key_code = isChar ? WXK_F1 : WXK_NUMPAD_F1;
835 break;
836
837 case GDK_KP_F2:
838 key_code = isChar ? WXK_F2 : WXK_NUMPAD_F2;
839 break;
840
841 case GDK_KP_F3:
842 key_code = isChar ? WXK_F3 : WXK_NUMPAD_F3;
843 break;
844
845 case GDK_KP_F4:
846 key_code = isChar ? WXK_F4 : WXK_NUMPAD_F4;
847 break;
848
849 case GDK_KP_Home:
850 key_code = isChar ? WXK_HOME : WXK_NUMPAD_HOME;
851 break;
852
853 case GDK_KP_Left:
854 key_code = isChar ? WXK_LEFT : WXK_NUMPAD_LEFT;
855 break;
856
857 case GDK_KP_Up:
858 key_code = isChar ? WXK_UP : WXK_NUMPAD_UP;
859 break;
860
861 case GDK_KP_Right:
862 key_code = isChar ? WXK_RIGHT : WXK_NUMPAD_RIGHT;
863 break;
864
865 case GDK_KP_Down:
866 key_code = isChar ? WXK_DOWN : WXK_NUMPAD_DOWN;
867 break;
868
869 case GDK_KP_Prior: // == GDK_KP_Page_Up
870 key_code = isChar ? WXK_PRIOR : WXK_NUMPAD_PRIOR;
871 break;
872
873 case GDK_KP_Next: // == GDK_KP_Page_Down
874 key_code = isChar ? WXK_NEXT : WXK_NUMPAD_NEXT;
875 break;
876
877 case GDK_KP_End:
878 key_code = isChar ? WXK_END : WXK_NUMPAD_END;
879 break;
880
881 case GDK_KP_Begin:
882 key_code = isChar ? WXK_HOME : WXK_NUMPAD_BEGIN;
883 break;
884
885 case GDK_KP_Insert:
886 key_code = isChar ? WXK_INSERT : WXK_NUMPAD_INSERT;
887 break;
888
889 case GDK_KP_Delete:
890 key_code = isChar ? WXK_DELETE : WXK_NUMPAD_DELETE;
891 break;
892
893 case GDK_KP_Equal:
894 key_code = isChar ? '=' : WXK_NUMPAD_EQUAL;
895 break;
896
897 case GDK_KP_Multiply:
898 key_code = isChar ? '*' : WXK_NUMPAD_MULTIPLY;
899 break;
900
901 case GDK_KP_Add:
902 key_code = isChar ? '+' : WXK_NUMPAD_ADD;
903 break;
904
905 case GDK_KP_Separator:
906 // FIXME: what is this?
907 key_code = isChar ? '.' : WXK_NUMPAD_SEPARATOR;
908 break;
909
910 case GDK_KP_Subtract:
911 key_code = isChar ? '-' : WXK_NUMPAD_SUBTRACT;
912 break;
913
914 case GDK_KP_Decimal:
915 key_code = isChar ? '.' : WXK_NUMPAD_DECIMAL;
916 break;
917
918 case GDK_KP_Divide:
919 key_code = isChar ? '/' : WXK_NUMPAD_DIVIDE;
920 break;
921
922
923 // function keys
924 case GDK_F1:
925 case GDK_F2:
926 case GDK_F3:
927 case GDK_F4:
928 case GDK_F5:
929 case GDK_F6:
930 case GDK_F7:
931 case GDK_F8:
932 case GDK_F9:
933 case GDK_F10:
934 case GDK_F11:
935 case GDK_F12:
936 key_code = WXK_F1 + keysym - GDK_F1;
937 break;
938
939 default:
940 key_code = 0;
941 }
942
943 return key_code;
944}
945
946static inline bool wxIsAsciiKeysym(KeySym ks)
947{
948 return ks < 256;
949}
950
74710601
VZ		 951static bool
952wxTranslateGTKKeyEventToWx(wxKeyEvent& event,
953 wxWindowGTK *win,
954 GdkEventKey *gdk_event)
47d67540 955{
1c6896d7
VZ		 956 // VZ: it seems that GDK_KEY_RELEASE event doesn't set event->string
957 // but only event->keyval which is quite useless to us, so remember
958 // the last character from GDK_KEY_PRESS and reuse it as last resort
959 //
960 // NB: should be MT-safe as we're always called from the main thread only
961 static struct
962 {
963 KeySym keysym;
964 long keycode;
965 } s_lastKeyPress = { 0, 0 };
966
967 KeySym keysym = gdk_event->keyval;
0a62b197 968
ada7d2c0 969 wxLogTrace(TRACE_KEYS, _T("Key %s event: keysym = %ld"),
0a62b197
VZ		 970 event.GetEventType() == wxEVT_KEY_UP ? _T("release")
971 : _T("press"),
972 keysym);
973
1c6896d7
VZ		 974 long key_code = wxTranslateKeySymToWXKey(keysym, FALSE /* !isChar */);
975
976 if ( !key_code )
977 {
978 // do we have the translation or is it a plain ASCII character?
979 if ( (gdk_event->length == 1) || wxIsAsciiKeysym(keysym) )
980 {
981 // we should use keysym if it is ASCII as X does some translations
982 // like "I pressed while Control is down" => "Ctrl-I" == "TAB"
983 // which we don't want here (but which we do use for OnChar())
984 if ( !wxIsAsciiKeysym(keysym) )
985 {
986 keysym = (KeySym)gdk_event->string[0];
987 }
a2053b27 988
1c6896d7
VZ		 989 // we want to always get the same key code when the same key is
990 // pressed regardless of the state of the modifies, i.e. on a
991 // standard US keyboard pressing '5' or '%' ('5' key with
992 // Shift) should result in the same key code in OnKeyDown():
993 // '5' (although OnChar() will get either '5' or '%').
994 //
995 // to do it we first translate keysym to keycode (== scan code)
996 // and then back but always using the lower register
997 Display *dpy = (Display *)wxGetDisplay();
998 KeyCode keycode = XKeysymToKeycode(dpy, keysym);
0a62b197
VZ		 999
1000 wxLogTrace(TRACE_KEYS, _T("\t-> keycode %d"), keycode);
1001
1c6896d7
VZ		 1002 KeySym keysymNormalized = XKeycodeToKeysym(dpy, keycode, 0);
1003
1004 // use the normalized, i.e. lower register, keysym if we've
1005 // got one
1006 key_code = keysymNormalized ? keysymNormalized : keysym;
1007
1008 // as explained above, we want to have lower register key codes
1009 // normally but for the letter keys we want to have the upper ones
1010 //
1011 // NB: don't use XConvertCase() here, we want to do it for letters
1012 // only
1013 key_code = toupper(key_code);
1014 }
1015 else // non ASCII key, what to do?
1016 {
1017 // by default, ignore it
1018 key_code = 0;
1019
1020 // but if we have cached information from the last KEY_PRESS
1021 if ( gdk_event->type == GDK_KEY_RELEASE )
1022 {
1023 // then reuse it
1024 if ( keysym == s_lastKeyPress.keysym )
1025 {
1026 key_code = s_lastKeyPress.keycode;
1027 }
1028 }
1029 }
1030
1031 if ( gdk_event->type == GDK_KEY_PRESS )
1032 {
1033 // remember it to be reused for KEY_UP event later
1034 s_lastKeyPress.keysym = keysym;
1035 s_lastKeyPress.keycode = key_code;
1036 }
1037 }
1038
ada7d2c0 1039 wxLogTrace(TRACE_KEYS, _T("\t-> wxKeyCode %ld"), key_code);
c801d85f 1040
74710601 1041 // sending unknown key events doesn't really make sense
1c6896d7 1042 if ( !key_code )
74710601 1043 return FALSE;
3d6f7261 1044
1c6896d7 1045 // now fill all the other fields
b0e813a0
RR		 1046 int x = 0;
1047 int y = 0;
1048 GdkModifierType state;
f17393f1
VZ		 1049 if (gdk_event->window)
1050 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
47d67540 1051
d1367c3d 1052 event.SetTimestamp( gdk_event->time );
74710601
VZ		 1053 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
1054 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
1055 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
1056 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
f5e27805 1057 event.m_keyCode = key_code;
b0e813a0 1058 event.m_scanCode = gdk_event->keyval;
9c7df356
VZ		 1059 event.m_rawCode = (wxUint32) gdk_event->keyval;
1060 event.m_rawFlags = 0;
b0e813a0
RR		 1061 event.m_x = x;
1062 event.m_y = y;
f5e27805 1063 event.SetEventObject( win );
74710601
VZ		 1064
1065 return TRUE;
1066}
1067
2b5f62a0 1068#ifndef __WXGTK20__
74710601
VZ		 1069static gint gtk_window_key_press_callback( GtkWidget *widget,
1070 GdkEventKey *gdk_event,
1071 wxWindow *win )
1072{
1073 DEBUG_MAIN_THREAD
1074
1075 if (g_isIdle)
1076 wxapp_install_idle_handler();
1077
1c6896d7
VZ		 1078 if (!win->m_hasVMT)
1079 return FALSE;
1080 if (g_blockEventsOnDrag)
1081 return FALSE;
74710601 1082
1ec3a984
RR		 1083
1084 wxKeyEvent event( wxEVT_KEY_DOWN );
74710601
VZ		 1085 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
1086 {
1c6896d7 1087 // unknown key pressed, ignore (the event would be useless anyhow)
74710601
VZ		 1088 return FALSE;
1089 }
1090
1ec3a984
RR		 1091 // Emit KEY_DOWN event
1092 bool ret = win->GetEventHandler()->ProcessEvent( event );
c50f1fb9 1093
88ac883a 1094#if wxUSE_ACCEL
f5e27805 1095 if (!ret)
47d67540 1096 {
1e6feb95 1097 wxWindowGTK *ancestor = win;
f5e27805
RR		 1098 while (ancestor)
1099 {
1100 int command = ancestor->GetAcceleratorTable()->GetCommand( event );
1101 if (command != -1)
1102 {
1103 wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
1104 ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
1105 break;
1106 }
f6bcfd97 1107 if (ancestor->IsTopLevel())
b02da6b1 1108 break;
f5e27805
RR		 1109 ancestor = ancestor->GetParent();
1110 }
bcf1fa6b 1111 }
88ac883a 1112#endif // wxUSE_ACCEL
3017f78d 1113
1ec3a984
RR		 1114 // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
1115 // will only be sent if it is not in an accelerator table.
2dde25b9 1116 if (!ret)
d728dd40 1117 {
1ec3a984 1118 // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
1c6896d7
VZ		 1119 KeySym keysym = gdk_event->keyval;
1120 long key_code = wxTranslateKeySymToWXKey(keysym, TRUE /* isChar */);
1121 if ( !key_code )
1122 {
1123 if ( gdk_event->length == 1 )
1124 {
486ac244 1125 key_code = (unsigned char)gdk_event->string[0];
1c6896d7 1126 }
486ac244 1127 else if ( wxIsAsciiKeysym(keysym) )
1c6896d7
VZ		 1128 {
1129 // ASCII key
486ac244 1130 key_code = (unsigned char)keysym;
1c6896d7
VZ		 1131 }
1132 }
f17393f1
VZ		 1133
1134 if ( key_code )
1135 {
74710601 1136 wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);
f17393f1 1137
f17393f1 1138 event.m_keyCode = key_code;
2b5f62a0 1139
1ec3a984
RR		 1140 // Implement OnCharHook by checking ancesteror top level windows
1141 wxWindow *parent = win;
1142 while (parent && !parent->IsTopLevel())
1143 parent = parent->GetParent();
1144 if (parent)
1145 {
1146 event.SetEventType( wxEVT_CHAR_HOOK );
1147 ret = parent->GetEventHandler()->ProcessEvent( event );
1148 }
f17393f1 1149
1ec3a984
RR		 1150 if (!ret)
1151 {
1152 event.SetEventType(wxEVT_CHAR);
1153 ret = win->GetEventHandler()->ProcessEvent( event );
1154 }
f17393f1 1155 }
d728dd40
KB		 1156 }
1157
1ec3a984 1158 // win is a control: tab can be propagated up
f17393f1 1159 if ( !ret &&
5664fc32 1160 ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
f6bcfd97
BP		 1161// VZ: testing for wxTE_PROCESS_TAB shouldn't be done here the control may
1162// have this style, yet choose not to process this particular TAB in which
1163// case TAB must still work as a navigational character
1164#if 0
f17393f1 1165 !win->HasFlag(wxTE_PROCESS_TAB) &&
f6bcfd97 1166#endif // 0
f17393f1 1167 win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
b292e2f5
RR		 1168 {
1169 wxNavigationKeyEvent new_event;
8253c7fd 1170 new_event.SetEventObject( win->GetParent() );
1ec3a984 1171 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
5664fc32 1172 new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
1ec3a984 1173 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
b98d804b 1174 new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
b292e2f5 1175 new_event.SetCurrentFocus( win );
8253c7fd 1176 ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
b292e2f5 1177 }
ff8bfdbb 1178
1ec3a984 1179 // generate wxID_CANCEL if <esc> has been pressed (typically in dialogs)
f17393f1 1180 if ( !ret &&
b98d804b
RR		 1181 (gdk_event->keyval == GDK_Escape) )
1182 {
6ce16bdb
VZ		 1183 // however only do it if we have a Cancel button in the dialog,
1184 // otherwise the user code may get confused by the events from a
1185 // non-existing button and, worse, a wxButton might get button event
1186 // from another button which is not really expected
1187 wxWindow *winForCancel = win,
1188 *btnCancel = NULL;
1189 while ( winForCancel )
1190 {
1191 btnCancel = winForCancel->FindWindow(wxID_CANCEL);
1192 if ( btnCancel )
1193 {
1194 // found a cancel button
1195 break;
1196 }
1197
1198 if ( winForCancel->IsTopLevel() )
1199 {
1200 // no need to look further
1201 break;
1202 }
1203
1204 // maybe our parent has a cancel button?
1205 winForCancel = winForCancel->GetParent();
1206 }
1207
1208 if ( btnCancel )
1209 {
1210 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
1211 event.SetEventObject(btnCancel);
1212 ret = btnCancel->GetEventHandler()->ProcessEvent(event);
1213 }
b98d804b 1214 }
c50f1fb9 1215
2b5f62a0 1216 if (ret)
801aa178 1217 {
2b5f62a0
VZ		 1218 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
1219 return TRUE;
1220 }
1221
1222 return FALSE;
1223}
1224#endif
1225
1226#ifdef __WXGTK20__
1227static gint gtk_window_key_press_callback( GtkWidget *widget,
1228 GdkEventKey *gdk_event,
1229 wxWindow *win )
1230{
1231 if (g_isIdle)
1232 wxapp_install_idle_handler();
1233
1234 if (!win->m_hasVMT)
1235 return FALSE;
1236 if (g_blockEventsOnDrag)
1237 return FALSE;
1238
1239 bool ret = FALSE;
1240 bool dont_use_IM = FALSE;
1241
1242 wxKeyEvent event( wxEVT_KEY_DOWN );
1243 long keycode = wxTranslateKeySymToWXKey( gdk_event->keyval, FALSE );
1244 if (keycode)
1245 {
1246 // We were able to decode the key press without
1247 // any input method, so don't use it.
1248 dont_use_IM = TRUE;
1249
1250 // now fill all the other fields
1251 int x = 0;
1252 int y = 0;
1253 GdkModifierType state;
1254 if (gdk_event->window)
1255 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1256
1257 event.SetTimestamp( gdk_event->time );
1258 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0;
1259 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0;
1260 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0;
1261 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK) != 0;
1262 event.m_keyCode = keycode;
1263 event.m_scanCode = gdk_event->keyval;
1264 event.m_rawCode = (wxUint32) gdk_event->keyval;
1265 event.m_rawFlags = 0;
1266 event.m_x = x;
1267 event.m_y = y;
1268 event.SetEventObject( win );
1269
1270 // send key down event
1271 ret = win->GetEventHandler()->ProcessEvent( event );
1272
1273 if (!ret)
801aa178 1274 {
2b5f62a0
VZ		 1275 // Implement OnCharHook by checking ancesteror top level windows
1276 wxWindow *parent = win;
1277 while (parent && !parent->IsTopLevel())
1278 parent = parent->GetParent();
1279 if (parent)
c50f1fb9 1280 {
2b5f62a0
VZ		 1281 event.SetEventType( wxEVT_CHAR_HOOK );
1282 ret = parent->GetEventHandler()->ProcessEvent( event );
1283 }
1284
1285 if (!ret)
1286 {
1287 event.SetEventType(wxEVT_CHAR);
1288 ret = win->GetEventHandler()->ProcessEvent( event );
1289 }
1290 }
1291
1292 // win is a control: tab can be propagated up
1293 if ( !ret &&
1294 ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) &&
1295 win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
1296 {
1297 wxNavigationKeyEvent new_event;
1298 new_event.SetEventObject( win->GetParent() );
1299 // GDK reports GDK_ISO_Left_Tab for SHIFT-TAB
1300 new_event.SetDirection( (gdk_event->keyval == GDK_Tab) );
1301 // CTRL-TAB changes the (parent) window, i.e. switch notebook page
1302 new_event.SetWindowChange( (gdk_event->state & GDK_CONTROL_MASK) );
1303 new_event.SetCurrentFocus( win );
1304 ret = win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
1305 }
1306
1307 if ( !ret &&
1308 (gdk_event->keyval == GDK_Escape) )
1309 {
1310 wxWindow *winForCancel = win, *btnCancel = NULL;
1311 while ( winForCancel )
1312 {
1313 btnCancel = winForCancel->FindWindow(wxID_CANCEL);
1314 if ( btnCancel ) break;
1315
1316 if ( winForCancel->IsTopLevel() ) break;
1317
1318 winForCancel = winForCancel->GetParent();
1319 }
1320
1321 if ( btnCancel )
1322 {
1323 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
1324 event.SetEventObject(btnCancel);
1325 ret = btnCancel->GetEventHandler()->ProcessEvent(event);
c50f1fb9 1326 }
801aa178
RR		 1327 }
1328 }
ca298c88 1329
f5e27805
RR		 1330 if (ret)
1331 {
b292e2f5 1332 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
f03fc89f 1333 return TRUE;
f5e27805 1334 }
2b5f62a0
VZ		 1335
1336 if (!dont_use_IM && win->m_imContext)
1337 {
1338 // In GTK 2.0, we need to hand over the key
1339 // event to an input method and the IM will
1340 // emit a "commit" event containing the
1341 // actual utf8 character.
1342 gtk_im_context_filter_keypress ( (GtkIMContext*) win->m_imContext, gdk_event );
1343
1344 return TRUE;
1345 }
1346
034be888 1347 return FALSE;
362c6693 1348}
c801d85f 1349
2b5f62a0
VZ		 1350static void gtk_wxwindow_commit_cb (GtkIMContext *context,
1351 const gchar *str,
1352 wxWindow *window)
1353{
1354 bool ret = FALSE;
1355
1356 wxKeyEvent event( wxEVT_KEY_DOWN );
1357
1358#if wxUSE_UNICODE
1359 event.m_uniChar = g_utf8_get_char( str );
1360
1361 // Backward compatible for ISO-8859
1362 if (event.m_uniChar < 256)
1363 event.m_keyCode = event.m_uniChar;
1364#else
1365 gunichar uniChar = g_utf8_get_char( str );
1366 // We cannot handle Unicode in non-Unicode mode
1367 if (uniChar > 255) return;
1368
1369 event.m_keyCode = uniChar;
1370#endif
1371
1372 if (!ret)
1373 {
1374 // Implement OnCharHook by checking ancesteror top level windows
1375 wxWindow *parent = window;
1376 while (parent && !parent->IsTopLevel())
1377 parent = parent->GetParent();
1378 if (parent)
1379 {
1380 event.SetEventType( wxEVT_CHAR_HOOK );
1381 ret = parent->GetEventHandler()->ProcessEvent( event );
1382 }
1383
1384 if (!ret)
1385 {
1386 event.SetEventType(wxEVT_CHAR);
1387 ret = window->GetEventHandler()->ProcessEvent( event );
1388 }
1389 }
1390}
1391#endif
1392
1393
b666df2c
RR		 1394//-----------------------------------------------------------------------------
1395// "key_release_event" from any window
1396//-----------------------------------------------------------------------------
1397
74710601
VZ		 1398static gint gtk_window_key_release_callback( GtkWidget *widget,
1399 GdkEventKey *gdk_event,
1400 wxWindowGTK *win )
b666df2c 1401{
3ac8d3bc
RR		 1402 DEBUG_MAIN_THREAD
1403
c50f1fb9 1404 if (g_isIdle)
a2053b27
RR		 1405 wxapp_install_idle_handler();
1406
74710601
VZ		 1407 if (!win->m_hasVMT)
1408 return FALSE;
b666df2c 1409
74710601
VZ		 1410 if (g_blockEventsOnDrag)
1411 return FALSE;
b666df2c
RR		 1412
1413 wxKeyEvent event( wxEVT_KEY_UP );
74710601 1414 if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
b666df2c 1415 {
74710601
VZ		 1416 // unknown key pressed, ignore (the event would be useless anyhow
1417 return FALSE;
b666df2c
RR		 1418 }
1419
74710601
VZ		 1420 if ( !win->GetEventHandler()->ProcessEvent( event ) )
1421 return FALSE;
1422
1423 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" );
1424 return TRUE;
b666df2c
RR		 1425}
1426
c5f9d156
VS		 1427// ============================================================================
1428// the mouse events
1429// ============================================================================
1430
d1f2ac45
VZ		 1431// ----------------------------------------------------------------------------
1432// mouse event processing helpers
1433// ----------------------------------------------------------------------------
1434
c5f9d156 1435// init wxMouseEvent with the info from gdk_event
edc1d330
VZ		 1436//
1437// NB: this has to be a macro as gdk_event type is different for different
1438// events we're used with
1439#define InitMouseEvent(/* wxWindowGTK * */ win, \
1440 /* wxMouseEvent& */ event, \
1441 /* GdkEventXXX * */ gdk_event) \
1442{ \
1443 event.SetTimestamp( gdk_event->time ); \
1444 event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK); \
1445 event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK); \
1446 event.m_altDown = (gdk_event->state & GDK_MOD1_MASK); \
1447 event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK); \
1448 event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK); \
1449 event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK); \
1450 event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK); \
2b5f62a0
VZ		 1451 if (event.GetEventType()==wxEVT_MOUSEWHEEL) \
1452 { \
1453 if (((GdkEventButton*)gdk_event)->button == 4) \
1454 event.m_wheelRotation = 120; \
1455 else if (((GdkEventButton*)gdk_event)->button == 5) \
1456 event.m_wheelRotation = -120; \
1457 } \
edc1d330
VZ		 1458 \
1459 wxPoint pt = win->GetClientAreaOrigin(); \
1460 event.m_x = (wxCoord)gdk_event->x - pt.x; \
1461 event.m_y = (wxCoord)gdk_event->y - pt.y; \
1462 \
1463 event.SetEventObject( win ); \
1464 event.SetId( win->GetId() ); \
1465 event.SetTimestamp( gdk_event->time ); \
1466} \
c5f9d156 1467
2daa0ce9
VZ		 1468static void AdjustEventButtonState(wxMouseEvent& event)
1469{
1470 // GDK reports the old state of the button for a button press event, but
1471 // for compatibility with MSW and common sense we want m_leftDown be TRUE
1472 // for a LEFT_DOWN event, not FALSE, so we will invert
1473 // left/right/middleDown for the corresponding click events
1e6feb95 1474
1a8caf94
RR		 1475 if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
1476 (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
1477 (event.GetEventType() == wxEVT_LEFT_UP))
1478 {
1479 event.m_leftDown = !event.m_leftDown;
1480 return;
1481 }
1482
1483 if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
1484 (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
1485 (event.GetEventType() == wxEVT_MIDDLE_UP))
2daa0ce9 1486 {
1a8caf94
RR		 1487 event.m_middleDown = !event.m_middleDown;
1488 return;
1489 }
1490
1491 if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
1492 (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
1493 (event.GetEventType() == wxEVT_RIGHT_UP))
1494 {
1495 event.m_rightDown = !event.m_rightDown;
1496 return;
2daa0ce9
VZ		 1497 }
1498}
1499
d1f2ac45
VZ		 1500// find the window to send the mouse event too
1501static
1502wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
1503{
7d4909b2
RR		 1504 wxCoord xx = x;
1505 wxCoord yy = y;
1506
d1f2ac45
VZ		 1507 if (win->m_wxwindow)
1508 {
1509 GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
7d4909b2
RR		 1510 xx += pizza->xoffset;
1511 yy += pizza->yoffset;
d1f2ac45
VZ		 1512 }
1513
b1d4dd7a 1514 wxWindowList::Node *node = win->GetChildren().GetFirst();
d1f2ac45
VZ		 1515 while (node)
1516 {
b1d4dd7a 1517 wxWindowGTK *child = node->GetData();
d1f2ac45 1518
b1d4dd7a 1519 node = node->GetNext();
d1f2ac45
VZ		 1520 if (!child->IsShown())
1521 continue;
1522
1523 if (child->IsTransparentForMouse())
1524 {
1525 // wxStaticBox is transparent in the box itself
1526 int xx1 = child->m_x;
1527 int yy1 = child->m_y;
1528 int xx2 = child->m_x + child->m_width;
1529 int yy2 = child->m_x + child->m_height;
1530
1531 // left
7d4909b2 1532 if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
d1f2ac45 1533 // right
7d4909b2 1534 ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
d1f2ac45 1535 // top
7d4909b2 1536 ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
d1f2ac45 1537 // bottom
7d4909b2 1538 ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
d1f2ac45
VZ		 1539 {
1540 win = child;
1541 x -= child->m_x;
1542 y -= child->m_y;
1543 break;
1544 }
1545
1546 }
1547 else
1548 {
1549 if ((child->m_wxwindow == (GtkWidget*) NULL) &&
7d4909b2
RR		 1550 (child->m_x <= xx) &&
1551 (child->m_y <= yy) &&
af3653dd
RR		 1552 (child->m_x+child->m_width >= xx) &&
1553 (child->m_y+child->m_height >= yy))
d1f2ac45
VZ		 1554 {
1555 win = child;
1556 x -= child->m_x;
1557 y -= child->m_y;
1558 break;
1559 }
1560 }
1561 }
1562
1563 return win;
1564}
1565
c801d85f 1566//-----------------------------------------------------------------------------
2f2aa628
RR		 1567// "button_press_event"
1568//-----------------------------------------------------------------------------
c801d85f 1569
d1f2ac45
VZ		 1570static gint gtk_window_button_press_callback( GtkWidget *widget,
1571 GdkEventButton *gdk_event,
1572 wxWindowGTK *win )
903f689b 1573{
3ac8d3bc
RR		 1574 DEBUG_MAIN_THREAD
1575
c50f1fb9 1576 if (g_isIdle)
a2053b27
RR		 1577 wxapp_install_idle_handler();
1578
1579/*
223d09f6 1580 wxPrintf( wxT("1) OnButtonPress from ") );
a2053b27
RR		 1581 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1582 wxPrintf( win->GetClassInfo()->GetClassName() );
223d09f6 1583 wxPrintf( wxT(".\n") );
a2053b27 1584*/
a2053b27 1585 if (!win->m_hasVMT) return FALSE;
f5e27805 1586 if (g_blockEventsOnDrag) return TRUE;
76ed8f8d 1587 if (g_blockEventsOnScroll) return TRUE;
c801d85f 1588
034be888
RR		 1589 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1590
afbe906a 1591 if (win->m_wxwindow && (g_focusWindow != win) && win->AcceptsFocus())
c801d85f 1592 {
afbe906a 1593 gtk_widget_grab_focus( win->m_wxwindow );
c801d85f 1594/*
afbe906a
RR		 1595 wxPrintf( wxT("GrabFocus from ") );
1596 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1597 wxPrintf( win->GetClassInfo()->GetClassName() );
1598 wxPrintf( wxT(".\n") );
c801d85f 1599*/
362c6693 1600 }
47d67540 1601
2b5f62a0
VZ		 1602 // GDK sends surplus button down event
1603 // before a double click event. We
1604 // need to filter these out.
1605 if (gdk_event->type == GDK_BUTTON_PRESS)
1606 {
1607 GdkEvent *peek_event = gdk_event_peek();
1608 if (peek_event)
1609 {
1610 if (peek_event->type == GDK_2BUTTON_PRESS)
1611 {
1612 gdk_event_free( peek_event );
1613 return TRUE;
1614 }
1615 else
1616 {
1617 gdk_event_free( peek_event );
1618 }
1619 }
1620 }
1621
2daa0ce9 1622 wxEventType event_type = wxEVT_NULL;
47d67540 1623
f5e27805 1624 if (gdk_event->button == 1)
c801d85f 1625 {
f5e27805
RR		 1626 switch (gdk_event->type)
1627 {
1628 case GDK_BUTTON_PRESS: event_type = wxEVT_LEFT_DOWN; break;
1629 case GDK_2BUTTON_PRESS: event_type = wxEVT_LEFT_DCLICK; break;
1630 default: break;
1631 }
362c6693 1632 }
f5e27805 1633 else if (gdk_event->button == 2)
c801d85f 1634 {
f5e27805
RR		 1635 switch (gdk_event->type)
1636 {
1637 case GDK_BUTTON_PRESS: event_type = wxEVT_MIDDLE_DOWN; break;
1638 case GDK_2BUTTON_PRESS: event_type = wxEVT_MIDDLE_DCLICK; break;
1639 default: break;
1640 }
362c6693 1641 }
f5e27805 1642 else if (gdk_event->button == 3)
c801d85f 1643 {
f5e27805
RR		 1644 switch (gdk_event->type)
1645 {
1646 case GDK_BUTTON_PRESS: event_type = wxEVT_RIGHT_DOWN; break;
1647 case GDK_2BUTTON_PRESS: event_type = wxEVT_RIGHT_DCLICK; break;
1648 default: break;
1649 }
362c6693 1650 }
2b5f62a0
VZ		 1651 else if (gdk_event->button == 4)
1652 {
1653 switch (gdk_event->type)
1654 {
1655 case GDK_BUTTON_PRESS: event_type = wxEVT_MOUSEWHEEL; break;
1656 default: break;
1657 }
1658 }
1659 else if (gdk_event->button == 5)
1660 {
1661 switch (gdk_event->type)
1662 {
1663 case GDK_BUTTON_PRESS: event_type = wxEVT_MOUSEWHEEL; break;
1664 default: break;
1665 }
1666 }
47d67540 1667
2daa0ce9
VZ		 1668 if ( event_type == wxEVT_NULL )
1669 {
1670 // unknown mouse button or click type
1671 return FALSE;
1672 }
1673
f5e27805 1674 wxMouseEvent event( event_type );
c5f9d156 1675 InitMouseEvent( win, event, gdk_event );
47d67540 1676
2daa0ce9 1677 AdjustEventButtonState(event);
94633ad9 1678
3ae4c570
VZ		 1679 // wxListBox actually get mouse events from the item, so we need to give it
1680 // a chance to correct this
1681 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
2daa0ce9 1682
d1f2ac45
VZ		 1683 // find the correct window to send the event too: it may be a different one
1684 // from the one which got it at GTK+ level because some control don't have
1685 // their own X window and thus cannot get any events.
1686 if ( !g_captureWindow )
1687 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
ff8bfdbb 1688
f5e27805 1689 gs_timeLastClick = gdk_event->time;
47d67540 1690
2f073eb2
RR		 1691/*
1692 wxPrintf( wxT("2) OnButtonPress from ") );
1693 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1694 wxPrintf( win->GetClassInfo()->GetClassName() );
1695 wxPrintf( wxT(".\n") );
1696*/
1697
df135f2b
RR		 1698#ifndef __WXGTK20__
1699 if (event_type == wxEVT_LEFT_DCLICK)
1700 {
1701 // GTK 1.2 crashes when intercepting double
1702 // click events from both wxSpinButton and
1703 // wxSpinCtrl
1704 if (GTK_IS_SPIN_BUTTON(win->m_widget))
1705 {
1706 // Just disable this event for now.
1707 return FALSE;
1708 }
1709 }
1710#endif
1711
f5e27805 1712 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 1713 {
f5e27805 1714 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_press_event" );
f03fc89f 1715 return TRUE;
034be888 1716 }
47d67540 1717
034be888 1718 return FALSE;
362c6693 1719}
c801d85f
KB		 1720
1721//-----------------------------------------------------------------------------
97b3455a 1722// "button_release_event"
2f2aa628 1723//-----------------------------------------------------------------------------
c801d85f 1724
2b5f62a0
VZ		 1725static gint gtk_window_button_release_callback( GtkWidget *widget,
1726 GdkEventButton *gdk_event,
1727 wxWindowGTK *win )
47d67540 1728{
3ac8d3bc
RR		 1729 DEBUG_MAIN_THREAD
1730
c50f1fb9 1731 if (g_isIdle)
a2053b27
RR		 1732 wxapp_install_idle_handler();
1733
1734 if (!win->m_hasVMT) return FALSE;
034be888
RR		 1735 if (g_blockEventsOnDrag) return FALSE;
1736 if (g_blockEventsOnScroll) return FALSE;
c801d85f 1737
034be888 1738 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
47d67540 1739
f5e27805 1740 wxEventType event_type = wxEVT_NULL;
47d67540 1741
f5e27805
RR		 1742 switch (gdk_event->button)
1743 {
2b5f62a0
VZ		 1744 case 1:
1745 event_type = wxEVT_LEFT_UP;
1746 break;
1747
1748 case 2:
1749 event_type = wxEVT_MIDDLE_UP;
1750 break;
1751
1752 case 3:
1753 event_type = wxEVT_RIGHT_UP;
1754 break;
1755
1756 default:
1757 // unknwon button, don't process
1758 return FALSE;
f5e27805 1759 }
47d67540 1760
f5e27805 1761 wxMouseEvent event( event_type );
c5f9d156 1762 InitMouseEvent( win, event, gdk_event );
f5e27805 1763
2daa0ce9
VZ		 1764 AdjustEventButtonState(event);
1765
3ae4c570
VZ		 1766 // same wxListBox hack as above
1767 win->FixUpMouseEvent(widget, event.m_x, event.m_y);
e2762ff0 1768
2b5f62a0
VZ		 1769 if ( event_type == wxEVT_RIGHT_UP )
1770 {
1771 // generate a "context menu" event: this is similar to wxEVT_RIGHT_UP
1772 // except that:
1773 //
1774 // (a) it's a command event and so is propagated to the parent
1775 // (b) under MSW it can be generated from kbd too
1776 // (c) it uses screen coords (because of (a))
1777 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU,
1778 win->GetId(),
1779 win->ClientToScreen(event.GetPosition()));
1780 (void)win->GetEventHandler()->ProcessEvent(evtCtx);
1781 }
1782
d1f2ac45
VZ		 1783 if ( !g_captureWindow )
1784 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
47d67540 1785
f5e27805 1786 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 1787 {
f5e27805 1788 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "button_release_event" );
f03fc89f 1789 return TRUE;
034be888 1790 }
47d67540 1791
034be888 1792 return FALSE;
362c6693 1793}
c801d85f
KB		 1794
1795//-----------------------------------------------------------------------------
2f2aa628
RR		 1796// "motion_notify_event"
1797//-----------------------------------------------------------------------------
c801d85f 1798
1e6feb95
VZ		 1799static gint gtk_window_motion_notify_callback( GtkWidget *widget,
1800 GdkEventMotion *gdk_event,
1801 wxWindowGTK *win )
47d67540 1802{
3ac8d3bc
RR		 1803 DEBUG_MAIN_THREAD
1804
c50f1fb9 1805 if (g_isIdle)
a2053b27
RR		 1806 wxapp_install_idle_handler();
1807
1808 if (!win->m_hasVMT) return FALSE;
034be888
RR		 1809 if (g_blockEventsOnDrag) return FALSE;
1810 if (g_blockEventsOnScroll) return FALSE;
148cd9b6 1811
034be888
RR		 1812 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
1813
ff8bfdbb 1814 if (gdk_event->is_hint)
aae24d21 1815 {
f7a11f8c
RR		 1816 int x = 0;
1817 int y = 0;
1818 GdkModifierType state;
1819 gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
1820 gdk_event->x = x;
1821 gdk_event->y = y;
aae24d21 1822 }
ff8bfdbb 1823
c801d85f 1824/*
e380f72b
RR		 1825 printf( "OnMotion from " );
1826 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1827 printf( win->GetClassInfo()->GetClassName() );
1828 printf( ".\n" );
aae24d21 1829*/
47d67540 1830
e380f72b 1831 wxMouseEvent event( wxEVT_MOTION );
c5f9d156 1832 InitMouseEvent(win, event, gdk_event);
e380f72b 1833
50382578 1834 if ( g_captureWindow )
2f2aa628 1835 {
1e6feb95
VZ		 1836 // synthetize a mouse enter or leave event if needed
1837 GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
50382578
RR		 1838 // This seems to be necessary and actually been added to
1839 // GDK itself in version 2.0.X
1840 gdk_flush();
1841
1e6feb95
VZ		 1842 bool hasMouse = winUnderMouse == gdk_event->window;
1843 if ( hasMouse != g_captureWindowHasMouse )
1844 {
1845 // the mouse changed window
1846 g_captureWindowHasMouse = hasMouse;
1847
1848 wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
1849 : wxEVT_LEAVE_WINDOW);
c5f9d156 1850 InitMouseEvent(win, event, gdk_event);
1e6feb95
VZ		 1851 event.SetEventObject(win);
1852 win->GetEventHandler()->ProcessEvent(event);
1853 }
1854 }
1855 else // no capture
1856 {
d1f2ac45 1857 win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
2f2aa628 1858 }
47d67540 1859
e380f72b 1860 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 1861 {
e380f72b 1862 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "motion_notify_event" );
f03fc89f 1863 return TRUE;
034be888 1864 }
47d67540 1865
034be888 1866 return FALSE;
362c6693 1867}
c801d85f
KB		 1868
1869//-----------------------------------------------------------------------------
2f2aa628
RR		 1870// "focus_in_event"
1871//-----------------------------------------------------------------------------
c801d85f 1872
6aeb6f2a
VZ		 1873// send the wxChildFocusEvent and wxFocusEvent, common code of
1874// gtk_window_focus_in_callback() and SetFocus()
1875static bool DoSendFocusEvents(wxWindow *win)
1876{
1877 // Notify the parent keeping track of focus for the kbd navigation
1878 // purposes that we got it.
1879 wxChildFocusEvent eventChildFocus(win);
1880 (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
1881
1882 wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
1883 eventFocus.SetEventObject(win);
1884
1885 return win->GetEventHandler()->ProcessEvent(eventFocus);
1886}
1887
1e6feb95
VZ		 1888static gint gtk_window_focus_in_callback( GtkWidget *widget,
1889 GdkEvent *WXUNUSED(event),
1890 wxWindow *win )
c801d85f 1891{
3ac8d3bc
RR		 1892 DEBUG_MAIN_THREAD
1893
c50f1fb9 1894 if (g_isIdle)
a2053b27
RR		 1895 wxapp_install_idle_handler();
1896
1897 if (!win->m_hasVMT) return FALSE;
034be888 1898 if (g_blockEventsOnDrag) return FALSE;
ff8bfdbb 1899
148cd9b6
VZ		 1900 switch ( g_sendActivateEvent )
1901 {
1902 case -1:
76fcf0f2 1903 // we've got focus from outside, synthetize wxActivateEvent
148cd9b6
VZ		 1904 g_sendActivateEvent = 1;
1905 break;
1906
1907 case 0:
1908 // another our window just lost focus, it was already ours before
1909 // - don't send any wxActivateEvent
1910 g_sendActivateEvent = -1;
1911 break;
1912 }
1913
1e6feb95 1914 g_focusWindowLast =
b292e2f5 1915 g_focusWindow = win;
ff8bfdbb 1916
6cad4f1b
VZ		 1917 wxLogTrace(TRACE_FOCUS,
1918 _T("%s: focus in"), win->GetName().c_str());
7de59551 1919
b79395c5
RR		 1920#ifdef HAVE_XIM
1921 if (win->m_ic)
1922 gdk_im_begin(win->m_ic, win->m_wxwindow->window);
1923#endif
1924
1e6feb95 1925#if wxUSE_CARET
f6bcfd97
BP		 1926 // caret needs to be informed about focus change
1927 wxCaret *caret = win->GetCaret();
1928 if ( caret )
1929 {
1930 caret->OnSetFocus();
1931 }
1932#endif // wxUSE_CARET
1933
d7fa7eaa 1934 g_activeFrameLostFocus = FALSE;
2b5f62a0 1935
e8c12a53
VS		 1936 wxWindowGTK *active = wxGetTopLevelParent(win);
1937 if ( active != g_activeFrame )
942bef71 1938 {
e8c12a53
VS		 1939 if ( g_activeFrame )
1940 {
45eb5249 1941 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame);
e8c12a53
VS		 1942 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
1943 event.SetEventObject(g_activeFrame);
1944 g_activeFrame->GetEventHandler()->ProcessEvent(event);
1945 }
47d67540 1946
45eb5249 1947 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active);
e8c12a53
VS		 1948 g_activeFrame = active;
1949 wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
1950 event.SetEventObject(g_activeFrame);
1951 g_activeFrame->GetEventHandler()->ProcessEvent(event);
2b5f62a0 1952
d7fa7eaa
RR		 1953 // Don't send focus events in addition to activate
1954 // if (win == g_activeFrame)
1955 // return TRUE;
942bef71 1956 }
e8c12a53 1957
6cad4f1b
VZ		 1958 // does the window itself think that it has the focus?
1959 if ( !win->m_hasFocus )
5cd09f0b 1960 {
6cad4f1b
VZ		 1961 // not yet, notify it
1962 win->m_hasFocus = TRUE;
1963
1964 if ( DoSendFocusEvents(win) )
1965 {
1966 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_in_event" );
1967 return TRUE;
1968 }
034be888 1969 }
ca298c88 1970
034be888 1971 return FALSE;
362c6693 1972}
c801d85f
KB		 1973
1974//-----------------------------------------------------------------------------
2f2aa628
RR		 1975// "focus_out_event"
1976//-----------------------------------------------------------------------------
c801d85f 1977
afbe906a 1978static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win )
c801d85f 1979{
3ac8d3bc
RR		 1980 DEBUG_MAIN_THREAD
1981
c50f1fb9 1982 if (g_isIdle)
a2053b27
RR		 1983 wxapp_install_idle_handler();
1984
1985 if (!win->m_hasVMT) return FALSE;
034be888 1986 if (g_blockEventsOnDrag) return FALSE;
ca298c88 1987
6cad4f1b
VZ		 1988 wxLogTrace( TRACE_FOCUS,
1989 _T("%s: focus out"), win->GetName().c_str() );
b231914f 1990
45eb5249
VS		 1991 if ( !g_activeFrameLostFocus && g_activeFrame )
1992 {
c0ad3d42
VZ		 1993 // VZ: commenting this out because it does happen (although not easy
1994 // to reproduce, I only see it when using wxMiniFrame and not
1995 // always) and makes using Mahogany quite annoying
1996#if 0
1997 wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame,
63fd5f0b 1998 wxT("unfocusing window that hasn't gained focus properly") );
c0ad3d42
VZ		 1999#endif // 0
2000
45eb5249
VS		 2001 g_activeFrameLostFocus = TRUE;
2002 }
2003
148cd9b6
VZ		 2004 // if the focus goes out of our app alltogether, OnIdle() will send
2005 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
2006 // g_sendActivateEvent to -1
2007 g_sendActivateEvent = 0;
2008
3379ed37 2009 wxWindowGTK *winFocus = wxFindFocusedChild(win);
f6bcfd97
BP		 2010 if ( winFocus )
2011 win = winFocus;
2012
1e6feb95 2013 g_focusWindow = (wxWindowGTK *)NULL;
148cd9b6 2014
b79395c5
RR		 2015#ifdef HAVE_XIM
2016 if (win->m_ic)
2017 gdk_im_end();
2018#endif
2019
1e6feb95 2020#if wxUSE_CARET
f6bcfd97
BP		 2021 // caret needs to be informed about focus change
2022 wxCaret *caret = win->GetCaret();
2023 if ( caret )
2024 {
2025 caret->OnKillFocus();
2026 }
2027#endif // wxUSE_CARET
2028
6cad4f1b
VZ		 2029 // don't send the window a kill focus event if it thinks that it doesn't
2030 // have focus already
2031 if ( win->m_hasFocus )
5cd09f0b 2032 {
6cad4f1b
VZ		 2033 win->m_hasFocus = FALSE;
2034
2035 wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
2036 event.SetEventObject( win );
2037
2038 if (win->GetEventHandler()->ProcessEvent( event ))
2039 {
2040 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" );
2041 return TRUE;
2042 }
034be888 2043 }
ca298c88 2044
034be888 2045 return FALSE;
362c6693 2046}
c801d85f 2047
b4071e91
RR		 2048//-----------------------------------------------------------------------------
2049// "enter_notify_event"
2050//-----------------------------------------------------------------------------
2051
edc1d330
VZ		 2052static
2053gint gtk_window_enter_callback( GtkWidget *widget,
2054 GdkEventCrossing *gdk_event,
2055 wxWindowGTK *win )
b4071e91 2056{
3ac8d3bc
RR		 2057 DEBUG_MAIN_THREAD
2058
c50f1fb9 2059 if (g_isIdle)
a2053b27 2060 wxapp_install_idle_handler();
ca298c88 2061
a2053b27
RR		 2062 if (!win->m_hasVMT) return FALSE;
2063 if (g_blockEventsOnDrag) return FALSE;
47d67540 2064
a2053b27 2065 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
b292e2f5 2066
4a33eba6
RR		 2067 int x = 0;
2068 int y = 0;
2069 GdkModifierType state = (GdkModifierType)0;
ff8bfdbb 2070
a2053b27 2071 gdk_window_get_pointer( widget->window, &x, &y, &state );
ff8bfdbb 2072
edc1d330 2073 wxMouseEvent event( wxEVT_ENTER_WINDOW );
c5f9d156
VS		 2074 InitMouseEvent(win, event, gdk_event);
2075 wxPoint pt = win->GetClientAreaOrigin();
2076 event.m_x = x + pt.x;
2077 event.m_y = y + pt.y;
ff8bfdbb 2078
e380f72b 2079 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 2080 {
e380f72b 2081 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "enter_notify_event" );
034be888
RR		 2082 return TRUE;
2083 }
ca298c88 2084
034be888 2085 return FALSE;
b4071e91 2086}
47d67540 2087
b4071e91
RR		 2088//-----------------------------------------------------------------------------
2089// "leave_notify_event"
2090//-----------------------------------------------------------------------------
2091
1e6feb95 2092static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win )
b4071e91 2093{
3ac8d3bc
RR		 2094 DEBUG_MAIN_THREAD
2095
c50f1fb9 2096 if (g_isIdle)
a2053b27 2097 wxapp_install_idle_handler();
acfd422a 2098
a2053b27
RR		 2099 if (!win->m_hasVMT) return FALSE;
2100 if (g_blockEventsOnDrag) return FALSE;
b292e2f5 2101
a2053b27 2102 if (!win->IsOwnGtkWindow( gdk_event->window )) return FALSE;
c50f1fb9 2103
e380f72b 2104 wxMouseEvent event( wxEVT_LEAVE_WINDOW );
d1367c3d 2105 event.SetTimestamp( gdk_event->time );
e380f72b 2106 event.SetEventObject( win );
47d67540 2107
4a33eba6
RR		 2108 int x = 0;
2109 int y = 0;
2110 GdkModifierType state = (GdkModifierType)0;
ff8bfdbb 2111
4a33eba6 2112 gdk_window_get_pointer( widget->window, &x, &y, &state );
ff8bfdbb 2113
74710601
VZ		 2114 event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
2115 event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
2116 event.m_altDown = (state & GDK_MOD1_MASK) != 0;
2117 event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
2118 event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
2119 event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
2120 event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
4a33eba6 2121
c5f9d156
VS		 2122 wxPoint pt = win->GetClientAreaOrigin();
2123 event.m_x = x + pt.x;
2124 event.m_y = y + pt.y;
ff8bfdbb 2125
e380f72b 2126 if (win->GetEventHandler()->ProcessEvent( event ))
034be888 2127 {
e380f72b 2128 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "leave_notify_event" );
034be888
RR		 2129 return TRUE;
2130 }
ca298c88 2131
034be888 2132 return FALSE;
b4071e91 2133}
47d67540 2134
c801d85f 2135//-----------------------------------------------------------------------------
2f2aa628
RR		 2136// "value_changed" from m_vAdjust
2137//-----------------------------------------------------------------------------
c801d85f 2138
9e691f46
VZ		 2139static void gtk_window_vscroll_callback( GtkAdjustment *adjust,
2140 SCROLLBAR_CBACK_ARG
2141 wxWindowGTK *win )
c801d85f 2142{
3ac8d3bc
RR		 2143 DEBUG_MAIN_THREAD
2144
c50f1fb9 2145 if (g_isIdle)
a2053b27 2146 wxapp_install_idle_handler();
c801d85f 2147
a2053b27 2148 if (g_blockEventsOnDrag) return;
47d67540 2149
a2053b27 2150 if (!win->m_hasVMT) return;
148cd9b6 2151
5e014a0c 2152 float diff = adjust->value - win->m_oldVerticalPos;
e380f72b 2153 if (fabs(diff) < 0.2) return;
148cd9b6 2154
5e014a0c 2155 win->m_oldVerticalPos = adjust->value;
47d67540 2156
a8bf1826 2157#ifndef __WXGTK20__
6728fb61 2158 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
a8bf1826 2159#endif
6728fb61 2160 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->vscrollbar));
148cd9b6 2161
5e014a0c 2162 int value = (int)(adjust->value+0.5);
c801d85f 2163
c5b42c87 2164 wxScrollWinEvent event( command, value, wxVERTICAL );
e380f72b
RR		 2165 event.SetEventObject( win );
2166 win->GetEventHandler()->ProcessEvent( event );
362c6693 2167}
c801d85f
KB		 2168
2169//-----------------------------------------------------------------------------
2f2aa628
RR		 2170// "value_changed" from m_hAdjust
2171//-----------------------------------------------------------------------------
c801d85f 2172
9e691f46
VZ		 2173static void gtk_window_hscroll_callback( GtkAdjustment *adjust,
2174 SCROLLBAR_CBACK_ARG
2175 wxWindowGTK *win )
47d67540 2176{
3ac8d3bc
RR		 2177 DEBUG_MAIN_THREAD
2178
c50f1fb9 2179 if (g_isIdle)
a2053b27 2180 wxapp_install_idle_handler();
47d67540 2181
a2053b27
RR		 2182 if (g_blockEventsOnDrag) return;
2183 if (!win->m_hasVMT) return;
47d67540 2184
5e014a0c 2185 float diff = adjust->value - win->m_oldHorizontalPos;
e380f72b 2186 if (fabs(diff) < 0.2) return;
148cd9b6 2187
a8bf1826 2188#ifndef __WXGTK20__
6728fb61 2189 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(win->m_widget);
a8bf1826 2190#endif
6728fb61 2191 wxEventType command = GtkScrollWinTypeToWx(GET_SCROLL_TYPE(sw->hscrollbar));
148cd9b6 2192
9e691f46 2193 win->m_oldHorizontalPos = adjust->value;
148cd9b6 2194
5e014a0c 2195 int value = (int)(adjust->value+0.5);
47d67540 2196
c5b42c87 2197 wxScrollWinEvent event( command, value, wxHORIZONTAL );
e380f72b
RR		 2198 event.SetEventObject( win );
2199 win->GetEventHandler()->ProcessEvent( event );
362c6693 2200}
c801d85f 2201
cb43b372
RR		 2202//-----------------------------------------------------------------------------
2203// "button_press_event" from scrollbar
2204//-----------------------------------------------------------------------------
2205
2a23d363
RR		 2206static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
2207 GdkEventButton *gdk_event,
1e6feb95 2208 wxWindowGTK *win)
cb43b372 2209{
3ac8d3bc
RR		 2210 DEBUG_MAIN_THREAD
2211
c50f1fb9 2212 if (g_isIdle)
a2053b27
RR		 2213 wxapp_install_idle_handler();
2214
d6d26e04 2215
5b8a521e 2216 g_blockEventsOnScroll = TRUE;
9e691f46
VZ		 2217
2218 // FIXME: there is no 'slider' field in GTK+ 2.0 any more
2219#ifndef __WXGTK20__
2a23d363 2220 win->m_isScrolling = (gdk_event->window == widget->slider);
9e691f46 2221#endif
47d67540 2222
e380f72b 2223 return FALSE;
cb43b372
RR		 2224}
2225
2226//-----------------------------------------------------------------------------
2227// "button_release_event" from scrollbar
2228//-----------------------------------------------------------------------------
2229
88413fec 2230static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
8bbe427f 2231 GdkEventButton *WXUNUSED(gdk_event),
1e6feb95 2232 wxWindowGTK *win)
cb43b372 2233{
3ac8d3bc
RR		 2234 DEBUG_MAIN_THREAD
2235
1ecc4d80 2236// don't test here as we can release the mouse while being over
5e014a0c 2237// a different window than the slider
76ed8f8d
RR		 2238//
2239// if (gdk_event->window != widget->slider) return FALSE;
cb43b372 2240
5b8a521e 2241 g_blockEventsOnScroll = FALSE;
47d67540 2242
2a23d363 2243 if (win->m_isScrolling)
88413fec 2244 {
d6d26e04 2245 wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
2a23d363
RR		 2246 int value = -1;
2247 int dir = -1;
2daa0ce9 2248
2a23d363
RR		 2249 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
2250 if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
2251 {
2252 value = (int)(win->m_hAdjust->value+0.5);
2253 dir = wxHORIZONTAL;
2254 }
2255 if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
2256 {
2257 value = (int)(win->m_vAdjust->value+0.5);
2258 dir = wxVERTICAL;
2259 }
2daa0ce9 2260
2a23d363 2261 wxScrollWinEvent event( command, value, dir );
2a23d363
RR		 2262 event.SetEventObject( win );
2263 win->GetEventHandler()->ProcessEvent( event );
88413fec
RR		 2264 }
2265
2a23d363 2266 win->m_isScrolling = FALSE;
2daa0ce9 2267
e380f72b 2268 return FALSE;
cb43b372
RR		 2269}
2270
f03fc89f
VZ		 2271// ----------------------------------------------------------------------------
2272// this wxWindowBase function is implemented here (in platform-specific file)
2273// because it is static and so couldn't be made virtual
2274// ----------------------------------------------------------------------------
2b07d713 2275
f03fc89f 2276wxWindow *wxWindowBase::FindFocus()
2b07d713 2277{
1e6feb95
VZ		 2278 // the cast is necessary when we compile in wxUniversal mode
2279 return (wxWindow *)g_focusWindow;
2b07d713 2280}
ca298c88 2281
1a685a59 2282
a2053b27
RR		 2283//-----------------------------------------------------------------------------
2284// "realize" from m_widget
2285//-----------------------------------------------------------------------------
2286
b79395c5
RR		 2287/* We cannot set colours and fonts before the widget has
2288 been realized, so we do this directly after realization. */
a2053b27
RR		 2289
2290static gint
2b5f62a0 2291gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
a2053b27 2292{
3ac8d3bc
RR		 2293 DEBUG_MAIN_THREAD
2294
c50f1fb9 2295 if (g_isIdle)
a2053b27
RR		 2296 wxapp_install_idle_handler();
2297
739730ca 2298 if (win->m_delayedBackgroundColour)
ea323db3 2299 win->GtkSetBackgroundColour( win->GetBackgroundColour() );
a2053b27 2300
739730ca 2301 if (win->m_delayedForegroundColour)
ea323db3 2302 win->GtkSetForegroundColour( win->GetForegroundColour() );
a2053b27 2303
2b5f62a0
VZ		 2304#ifdef __WXGTK20__
2305 if (win->m_imContext)
2306 {
2307 GtkPizza *pizza = GTK_PIZZA( m_widget );
2308 gtk_im_context_set_client_window( (GtkIMContext*) win->m_imContext, pizza->bin_window );
2309 }
2310#endif
2311
3c679789
RR		 2312 wxWindowCreateEvent event( win );
2313 event.SetEventObject( win );
2314 win->GetEventHandler()->ProcessEvent( event );
1e6feb95 2315
a2053b27
RR		 2316 return FALSE;
2317}
2318
b79395c5
RR		 2319//-----------------------------------------------------------------------------
2320// "size_allocate"
2321//-----------------------------------------------------------------------------
2322
8f75cb6c 2323static
adc1999b
RR		 2324void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
2325 GtkAllocation *WXUNUSED(alloc),
8f75cb6c
RR		 2326 wxWindow *win )
2327{
2328 if (g_isIdle)
2329 wxapp_install_idle_handler();
2daa0ce9 2330
5b8a521e 2331 if (!win->m_hasScrolling) return;
2daa0ce9 2332
5b8a521e
RR		 2333 int client_width = 0;
2334 int client_height = 0;
2335 win->GetClientSize( &client_width, &client_height );
2336 if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
2337 return;
2daa0ce9 2338
5b8a521e
RR		 2339 win->m_oldClientWidth = client_width;
2340 win->m_oldClientHeight = client_height;
2daa0ce9 2341
5b8a521e
RR		 2342 if (!win->m_nativeSizeEvent)
2343 {
2344 wxSizeEvent event( win->GetSize(), win->GetId() );
2345 event.SetEventObject( win );
2346 win->GetEventHandler()->ProcessEvent( event );
2347 }
8f75cb6c
RR		 2348}
2349
2350
3ed2e7ce
VZ		 2351#ifdef HAVE_XIM
2352 #define WXUNUSED_UNLESS_XIM(param) param
2353#else
2354 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
2355#endif
2356
b79395c5
RR		 2357/* Resize XIM window */
2358
3ed2e7ce 2359static
8f75cb6c
RR		 2360void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget),
2361 GtkAllocation* WXUNUSED_UNLESS_XIM(alloc),
1e6feb95 2362 wxWindowGTK* WXUNUSED_UNLESS_XIM(win) )
b79395c5
RR		 2363{
2364 if (g_isIdle)
2365 wxapp_install_idle_handler();
2daa0ce9 2366
9a8c7620 2367#ifdef HAVE_XIM
b79395c5
RR		 2368 if (!win->m_ic)
2369 return;
2370
b79395c5
RR		 2371 if (gdk_ic_get_style (win->m_ic) & GDK_IM_PREEDIT_POSITION)
2372 {
2373 gint width, height;
2374
3ed2e7ce 2375 gdk_window_get_size (widget->window, &width, &height);
b79395c5
RR		 2376 win->m_icattr->preedit_area.width = width;
2377 win->m_icattr->preedit_area.height = height;
2378 gdk_ic_set_attr (win->m_ic, win->m_icattr, GDK_IC_PREEDIT_AREA);
2379 }
9a8c7620 2380#endif // HAVE_XIM
b79395c5
RR		 2381}
2382
63081513
RR		 2383//-----------------------------------------------------------------------------
2384// "realize" from m_wxwindow
2385//-----------------------------------------------------------------------------
2386
2387/* Initialize XIM support */
2388
2389static gint
3ed2e7ce 2390gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget),
1e6feb95 2391 wxWindowGTK * WXUNUSED_UNLESS_XIM(win) )
63081513
RR		 2392{
2393 if (g_isIdle)
2394 wxapp_install_idle_handler();
2395
d06800f1 2396#ifdef HAVE_XIM
63081513
RR		 2397 if (win->m_ic) return FALSE;
2398 if (!widget) return FALSE;
2399 if (!gdk_im_ready()) return FALSE;
2400
2401 win->m_icattr = gdk_ic_attr_new();
2402 if (!win->m_icattr) return FALSE;
2daa0ce9 2403
63081513
RR		 2404 gint width, height;
2405 GdkEventMask mask;
2406 GdkColormap *colormap;
2407 GdkICAttr *attr = win->m_icattr;
b58b1dfc 2408 unsigned attrmask = GDK_IC_ALL_REQ;
63081513 2409 GdkIMStyle style;
b79395c5
RR		 2410 GdkIMStyle supported_style = (GdkIMStyle)
2411 (GDK_IM_PREEDIT_NONE |
1e6feb95
VZ		 2412 GDK_IM_PREEDIT_NOTHING |
2413 GDK_IM_PREEDIT_POSITION |
2414 GDK_IM_STATUS_NONE |
2415 GDK_IM_STATUS_NOTHING);
63081513
RR		 2416
2417 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
1e6feb95 2418 supported_style = (GdkIMStyle)(supported_style & ~GDK_IM_PREEDIT_POSITION);
63081513
RR		 2419
2420 attr->style = style = gdk_im_decide_style (supported_style);
2421 attr->client_window = widget->window;
2422
2423 if ((colormap = gtk_widget_get_colormap (widget)) !=
1e6feb95 2424 gtk_widget_get_default_colormap ())
63081513 2425 {
5cd09f0b
RR		 2426 attrmask |= GDK_IC_PREEDIT_COLORMAP;
2427 attr->preedit_colormap = colormap;
63081513 2428 }
2daa0ce9 2429
63081513
RR		 2430 attrmask |= GDK_IC_PREEDIT_FOREGROUND;
2431 attrmask |= GDK_IC_PREEDIT_BACKGROUND;
2432 attr->preedit_foreground = widget->style->fg[GTK_STATE_NORMAL];
2433 attr->preedit_background = widget->style->base[GTK_STATE_NORMAL];
2434
2435 switch (style & GDK_IM_PREEDIT_MASK)
2436 {
1e6feb95
VZ		 2437 case GDK_IM_PREEDIT_POSITION:
2438 if (widget->style && widget->style->font->type != GDK_FONT_FONTSET)
2439 {
2440 g_warning ("over-the-spot style requires fontset");
2441 break;
2442 }
63081513 2443
1e6feb95 2444 gdk_window_get_size (widget->window, &width, &height);
63081513 2445
1e6feb95
VZ		 2446 attrmask |= GDK_IC_PREEDIT_POSITION_REQ;
2447 attr->spot_location.x = 0;
2448 attr->spot_location.y = height;
2449 attr->preedit_area.x = 0;
2450 attr->preedit_area.y = 0;
2451 attr->preedit_area.width = width;
2452 attr->preedit_area.height = height;
2453 attr->preedit_fontset = widget->style->font;
63081513 2454
1e6feb95 2455 break;
b79395c5 2456 }
2daa0ce9 2457
b58b1dfc 2458 win->m_ic = gdk_ic_new (attr, (GdkICAttributesType)attrmask);
2daa0ce9 2459
63081513 2460 if (win->m_ic == NULL)
1e6feb95 2461 g_warning ("Can't create input context.");
63081513 2462 else
1e6feb95
VZ		 2463 {
2464 mask = gdk_window_get_events (widget->window);
2465 mask = (GdkEventMask)(mask | gdk_ic_get_events (win->m_ic));
2466 gdk_window_set_events (widget->window, mask);
2467
2468 if (GTK_WIDGET_HAS_FOCUS(widget))
2469 gdk_im_begin (win->m_ic, widget->window);
2470 }
2471#endif // HAVE_XIM
63081513
RR		 2472
2473 return FALSE;
2474}
2475
6ca41e57 2476//-----------------------------------------------------------------------------
1e6feb95 2477// InsertChild for wxWindowGTK.
6ca41e57
RR		 2478//-----------------------------------------------------------------------------
2479
1e6feb95 2480/* Callback for wxWindowGTK. This very strange beast has to be used because
b1170810
RR		 2481 * C++ has no virtual methods in a constructor. We have to emulate a
2482 * virtual function here as wxNotebook requires a different way to insert
2483 * a child in it. I had opted for creating a wxNotebookPage window class
2484 * which would have made this superfluous (such in the MDI window system),
2485 * but no-one was listening to me... */
6ca41e57 2486
1e6feb95 2487static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
6ca41e57 2488{
bf0c00c6
RR		 2489 /* the window might have been scrolled already, do we
2490 have to adapt the position */
da048e3d
RR		 2491 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
2492 child->m_x += pizza->xoffset;
2493 child->m_y += pizza->yoffset;
148cd9b6 2494
da048e3d 2495 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
a2053b27
RR		 2496 GTK_WIDGET(child->m_widget),
2497 child->m_x,
2498 child->m_y,
2499 child->m_width,
2500 child->m_height );
6ca41e57
RR		 2501}
2502
bbe0af5b
RR		 2503//-----------------------------------------------------------------------------
2504// global functions
2505//-----------------------------------------------------------------------------
2506
1e6feb95 2507wxWindow *wxGetActiveWindow()
bbe0af5b 2508{
6cad4f1b 2509 return wxWindow::FindFocus();
bbe0af5b
RR		 2510}
2511
c801d85f 2512//-----------------------------------------------------------------------------
1e6feb95 2513// wxWindowGTK
c801d85f
KB		 2514//-----------------------------------------------------------------------------
2515
6522713c
VZ		 2516// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
2517// method
1e6feb95 2518#ifdef __WXUNIVERSAL__
6522713c
VZ		 2519 IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
2520#else // __WXGTK__
1e6feb95 2521 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
6522713c 2522#endif // __WXUNIVERSAL__/__WXGTK__
c801d85f 2523
1e6feb95 2524void wxWindowGTK::Init()
c801d85f 2525{
f03fc89f
VZ		 2526 // common init
2527 InitBase();
68995f26 2528
f03fc89f 2529 // GTK specific
a2053b27 2530 m_widget = (GtkWidget *) NULL;
e380f72b 2531 m_wxwindow = (GtkWidget *) NULL;
76fcf0f2 2532 m_focusWidget = (GtkWidget *) NULL;
8bbe427f 2533
f03fc89f 2534 // position/size
a2053b27
RR		 2535 m_x = 0;
2536 m_y = 0;
2537 m_width = 0;
e380f72b 2538 m_height = 0;
8bbe427f 2539
e380f72b
RR		 2540 m_sizeSet = FALSE;
2541 m_hasVMT = FALSE;
2542 m_needParent = TRUE;
31c6b4fc 2543 m_isBeingDeleted = FALSE;
148cd9b6 2544
147bc491 2545 m_noExpose = FALSE;
30760ce7 2546 m_nativeSizeEvent = FALSE;
94633ad9 2547
a2053b27 2548 m_hasScrolling = FALSE;
846e1424 2549 m_isScrolling = FALSE;
f03fc89f 2550
a2053b27 2551 m_hAdjust = (GtkAdjustment*) NULL;
e380f72b 2552 m_vAdjust = (GtkAdjustment*) NULL;
a2053b27 2553 m_oldHorizontalPos = 0.0;
e380f72b 2554 m_oldVerticalPos = 0.0;
8bbe427f 2555
e380f72b 2556 m_resizing = FALSE;
e380f72b 2557 m_widgetStyle = (GtkStyle*) NULL;
8bbe427f 2558
ddb6bc71 2559 m_insertCallback = (wxInsertChildFunction) NULL;
8bbe427f 2560
b292e2f5 2561 m_acceptsFocus = FALSE;
6cad4f1b 2562 m_hasFocus = FALSE;
148cd9b6 2563
b6fa52db 2564 m_clipPaintRegion = FALSE;
b6fa52db 2565
5e014a0c 2566 m_cursor = *wxSTANDARD_CURSOR;
2daa0ce9 2567
f6bcfd97
BP		 2568 m_delayedForegroundColour = FALSE;
2569 m_delayedBackgroundColour = FALSE;
1e6feb95 2570
2b5f62a0
VZ		 2571#ifdef __WXGTK20__
2572 m_imContext = NULL;
2573 m_x11Context = NULL;
2574#else
63081513
RR		 2575#ifdef HAVE_XIM
2576 m_ic = (GdkIC*) NULL;
2577 m_icattr = (GdkICAttr*) NULL;
2578#endif
2b5f62a0 2579#endif
362c6693 2580}
c801d85f 2581
1e6feb95 2582wxWindowGTK::wxWindowGTK()
68995f26
VZ		 2583{
2584 Init();
2585}
2586
1e6feb95
VZ		 2587wxWindowGTK::wxWindowGTK( wxWindow *parent,
2588 wxWindowID id,
2589 const wxPoint &pos,
2590 const wxSize &size,
2591 long style,
2592 const wxString &name )
6ca41e57 2593{
68995f26
VZ		 2594 Init();
2595
e380f72b 2596 Create( parent, id, pos, size, style, name );
6ca41e57 2597}
8bbe427f 2598
1e6feb95
VZ		 2599bool wxWindowGTK::Create( wxWindow *parent,
2600 wxWindowID id,
2601 const wxPoint &pos,
2602 const wxSize &size,
2603 long style,
2604 const wxString &name )
c801d85f 2605{
4dcaf11a
RR		 2606 if (!PreCreation( parent, pos, size ) ||
2607 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
2608 {
1e6feb95 2609 wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
b02da6b1 2610 return FALSE;
4dcaf11a 2611 }
47d67540 2612
ddb6bc71 2613 m_insertCallback = wxInsertChildInWindow;
2b5f62a0 2614
994bc575 2615 // always needed for background clearing
2b5f62a0 2616 m_delayedBackgroundColour = TRUE;
1e6feb95 2617
e380f72b 2618 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
38c7b3d3 2619 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
ff8bfdbb 2620
f03fc89f 2621 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
47d67540 2622
dd00f3f6 2623 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
e380f72b 2624 scroll_class->scrollbar_spacing = 0;
47d67540 2625
f03fc89f 2626 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
47d67540 2627
f03fc89f
VZ		 2628 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
2629 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
47d67540 2630
da048e3d 2631 m_wxwindow = gtk_pizza_new();
0fc5dbf5 2632
1e6feb95 2633#ifndef __WXUNIVERSAL__
da048e3d 2634 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
b292e2f5 2635
f03fc89f 2636 if (HasFlag(wxRAISED_BORDER))
034be888 2637 {
da048e3d 2638 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
034be888 2639 }
f03fc89f 2640 else if (HasFlag(wxSUNKEN_BORDER))
034be888 2641 {
da048e3d 2642 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
5e014a0c
RR		 2643 }
2644 else if (HasFlag(wxSIMPLE_BORDER))
2645 {
da048e3d 2646 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
034be888
RR		 2647 }
2648 else
2649 {
da048e3d 2650 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
034be888 2651 }
1e6feb95 2652#endif // __WXUNIVERSAL__
47d67540 2653
4e5a4c69
RR		 2654 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
2655
3da17724
RR		 2656 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
2657 m_acceptsFocus = TRUE;
ca298c88 2658
e380f72b 2659 // I _really_ don't want scrollbars in the beginning
a2053b27
RR		 2660 m_vAdjust->lower = 0.0;
2661 m_vAdjust->upper = 1.0;
2662 m_vAdjust->value = 0.0;
2663 m_vAdjust->step_increment = 1.0;
2664 m_vAdjust->page_increment = 1.0;
2665 m_vAdjust->page_size = 5.0;
2666 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
2667 m_hAdjust->lower = 0.0;
2668 m_hAdjust->upper = 1.0;
2669 m_hAdjust->value = 0.0;
2670 m_hAdjust->step_increment = 1.0;
2671 m_hAdjust->page_increment = 1.0;
2672 m_hAdjust->page_size = 5.0;
2673 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
f03fc89f
VZ		 2674
2675 // these handlers block mouse events to any window during scrolling such as
2676 // motion events and prevent GTK and wxWindows from fighting over where the
2677 // slider should be
2678
2679 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
76ed8f8d
RR		 2680 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2681
f03fc89f 2682 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
76ed8f8d
RR		 2683 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
2684
f03fc89f 2685 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
76ed8f8d
RR		 2686 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
2687
f03fc89f 2688 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
76ed8f8d 2689 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
8bbe427f 2690
034be888 2691 // these handlers get notified when screen updates are required either when
76ed8f8d
RR		 2692 // scrolling or when the window size (and therefore scrollbar configuration)
2693 // has changed
2694
2695 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
2696 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2697 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
2698 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2699
2b5f62a0
VZ		 2700#ifdef __WXGTK20__
2701 // Create input method handler
2702 m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new ();
2703
2704 // Cannot handle drawing preedited text yet
2705 gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE );
2706
2707 g_signal_connect (G_OBJECT (m_imContext), "commit",
2708 G_CALLBACK (gtk_wxwindow_commit_cb), this);
2709#endif
2710
f03fc89f 2711 gtk_widget_show( m_wxwindow );
47d67540 2712
f03fc89f
VZ		 2713 if (m_parent)
2714 m_parent->DoAddChild( this );
94633ad9 2715
76fcf0f2 2716 m_focusWidget = m_wxwindow;
8bbe427f 2717
e380f72b 2718 PostCreation();
8bbe427f 2719
e380f72b 2720 Show( TRUE );
c801d85f 2721
e380f72b 2722 return TRUE;
362c6693 2723}
c801d85f 2724
1e6feb95 2725wxWindowGTK::~wxWindowGTK()
c801d85f 2726{
7de59551
RD		 2727 SendDestroyEvent();
2728
44cd54c2
JS		 2729 if (g_focusWindow == this)
2730 g_focusWindow = NULL;
2731
e8c12a53
VS		 2732 if (g_activeFrame == this)
2733 g_activeFrame = NULL;
2734
3e679f01
VZ		 2735 if ( g_delayedFocus == this )
2736 g_delayedFocus = NULL;
2737
31c6b4fc 2738 m_isBeingDeleted = TRUE;
43a18898 2739 m_hasVMT = FALSE;
47d67540 2740
f03fc89f
VZ		 2741 if (m_widget)
2742 Show( FALSE );
8bbe427f 2743
a2053b27
RR		 2744 DestroyChildren();
2745
f03fc89f
VZ		 2746 if (m_parent)
2747 m_parent->RemoveChild( this );
c801d85f 2748
63081513
RR		 2749#ifdef HAVE_XIM
2750 if (m_ic)
2751 gdk_ic_destroy (m_ic);
2752 if (m_icattr)
2753 gdk_ic_attr_destroy (m_icattr);
2754#endif
2755
f03fc89f 2756 if (m_widgetStyle)
a2053b27 2757 {
a56fcaaf 2758#if DISABLE_STYLE_IF_BROKEN_THEME
bce1406b
RR		 2759 // don't delete if it's a pixmap theme style
2760 if (!m_widgetStyle->engine_data)
2761 gtk_style_unref( m_widgetStyle );
1e6feb95 2762#endif
c50f1fb9 2763 m_widgetStyle = (GtkStyle*) NULL;
a2053b27 2764 }
c801d85f 2765
f03fc89f 2766 if (m_wxwindow)
a2053b27 2767 {
f03fc89f 2768 gtk_widget_destroy( m_wxwindow );
c50f1fb9 2769 m_wxwindow = (GtkWidget*) NULL;
a2053b27 2770 }
8bbe427f 2771
f03fc89f 2772 if (m_widget)
a2053b27 2773 {
f03fc89f 2774 gtk_widget_destroy( m_widget );
c50f1fb9 2775 m_widget = (GtkWidget*) NULL;
a2053b27 2776 }
362c6693 2777}
c801d85f 2778
1e6feb95 2779bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
c801d85f 2780{
223d09f6 2781 wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") );
8bbe427f 2782
3013a903
RR		 2783 // This turns -1 into 30 so that a minimal window is
2784 // visible even although -1,-1 has been given as the
2785 // size of the window. the same trick is used in other
2786 // ports and should make debugging easier.
2787 m_width = WidthDefault(size.x) ;
f03fc89f 2788 m_height = HeightDefault(size.y);
8bbe427f 2789
43a18898
RR		 2790 m_x = (int)pos.x;
2791 m_y = (int)pos.y;
8bbe427f 2792
3013a903 2793 // some reasonable defaults
148cd9b6 2794 if (!parent)
6ca41e57 2795 {
43a18898
RR		 2796 if (m_x == -1)
2797 {
2798 m_x = (gdk_screen_width () - m_width) / 2;
2799 if (m_x < 10) m_x = 10;
2800 }
2801 if (m_y == -1)
2802 {
2803 m_y = (gdk_screen_height () - m_height) / 2;
2804 if (m_y < 10) m_y = 10;
2805 }
6ca41e57 2806 }
148cd9b6 2807
4dcaf11a 2808 return TRUE;
c801d85f
KB		 2809}
2810
1e6feb95 2811void wxWindowGTK::PostCreation()
c801d85f 2812{
223d09f6 2813 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
94633ad9 2814
43a18898
RR		 2815 if (m_wxwindow)
2816 {
147bc491 2817 if (!m_noExpose)
b02da6b1 2818 {
76fcf0f2 2819 // these get reported to wxWindows -> wxPaintEvent
1e6feb95 2820
b420fb6a
RR		 2821 gtk_pizza_set_external( GTK_PIZZA(m_wxwindow), TRUE );
2822
147bc491
RR		 2823 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
2824 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
2825
4e5a4c69 2826#ifndef __WXGTK20__
147bc491
RR		 2827 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
2828 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
0fc5dbf5 2829
e22454be
RR		 2830 if (HasFlag(wxNO_FULL_REPAINT_ON_RESIZE))
2831 {
2832 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "event",
2833 GTK_SIGNAL_FUNC(gtk_window_event_event_callback), (gpointer)this );
2834 }
4e5a4c69 2835#else
2b5f62a0
VZ		 2836 // gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ) );
2837#endif
2838
2839#ifdef __WXGTK20__
2840 // Create input method handler
2841 m_imContext = (GtkIMMulticontext*) gtk_im_multicontext_new ();
2842
2843 // Cannot handle drawing preedited text yet
2844 gtk_im_context_set_use_preedit( (GtkIMContext*) m_imContext, FALSE );
2845
2846 g_signal_connect (G_OBJECT (m_imContext), "commit",
2847 G_CALLBACK (gtk_wxwindow_commit_cb), this);
4e5a4c69 2848#endif
b02da6b1 2849 }
148cd9b6 2850
67d78217 2851 // these are called when the "sunken" or "raised" borders are drawn
034be888
RR		 2852 gtk_signal_connect( GTK_OBJECT(m_widget), "expose_event",
2853 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback), (gpointer)this );
2854
4e5a4c69 2855#ifndef __WXGTK20__
034be888
RR		 2856 gtk_signal_connect( GTK_OBJECT(m_widget), "draw",
2857 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback), (gpointer)this );
4e5a4c69 2858#endif
43a18898 2859 }
47d67540 2860
76fcf0f2 2861 // focus handling
63081513 2862
76fcf0f2
RR		 2863 if (m_focusWidget == NULL)
2864 m_focusWidget = m_widget;
2daa0ce9 2865
76fcf0f2
RR		 2866 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event",
2867 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this );
2868
2869 gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event",
2870 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this );
2871
2872 // connect to the various key and mouse handlers
63081513 2873
a2053b27 2874 GtkWidget *connect_widget = GetConnectWidget();
f03fc89f 2875
a2053b27 2876 ConnectWidget( connect_widget );
47d67540 2877
63081513 2878 /* We cannot set colours, fonts and cursors before the widget has
a2053b27
RR		 2879 been realized, so we do this directly after realization */
2880 gtk_signal_connect( GTK_OBJECT(connect_widget), "realize",
c50f1fb9 2881 GTK_SIGNAL_FUNC(gtk_window_realized_callback), (gpointer) this );
2daa0ce9 2882
63081513
RR		 2883 if (m_wxwindow)
2884 {
47c93b63 2885 // Catch native resize events
8f75cb6c
RR		 2886 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2887 GTK_SIGNAL_FUNC(gtk_window_size_callback), (gpointer)this );
2daa0ce9 2888
47c93b63 2889 // Initialize XIM support
63081513
RR		 2890 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
2891 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback), (gpointer) this );
8f75cb6c 2892
47c93b63 2893 // And resize XIM window
b79395c5
RR		 2894 gtk_signal_connect( GTK_OBJECT(m_wxwindow), "size_allocate",
2895 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this );
63081513 2896 }
2daa0ce9 2897
47c93b63
RR		 2898 if (!GTK_IS_COMBO(m_widget))
2899 {
2900 // This is needed if we want to add our windows into native
2901 // GTK control, such as the toolbar. With this callback, the
2902 // toolbar gets to know the correct size (the one set by the
2903 // programmer). Sadly, it misbehaves for wxComboBox. FIXME
2904 // when moving to GTK 2.0.
2905 gtk_signal_connect( GTK_OBJECT(m_widget), "size_request",
2906 GTK_SIGNAL_FUNC(gtk_window_size_request_callback), (gpointer) this );
2907 }
1e6feb95 2908
43a18898 2909 m_hasVMT = TRUE;
b4071e91
RR		 2910}
2911
1e6feb95 2912void wxWindowGTK::ConnectWidget( GtkWidget *widget )
b4071e91 2913{
43a18898
RR		 2914 gtk_signal_connect( GTK_OBJECT(widget), "key_press_event",
2915 GTK_SIGNAL_FUNC(gtk_window_key_press_callback), (gpointer)this );
c801d85f 2916
b666df2c
RR		 2917 gtk_signal_connect( GTK_OBJECT(widget), "key_release_event",
2918 GTK_SIGNAL_FUNC(gtk_window_key_release_callback), (gpointer)this );
2919
43a18898
RR		 2920 gtk_signal_connect( GTK_OBJECT(widget), "button_press_event",
2921 GTK_SIGNAL_FUNC(gtk_window_button_press_callback), (gpointer)this );
47d67540 2922
43a18898
RR		 2923 gtk_signal_connect( GTK_OBJECT(widget), "button_release_event",
2924 GTK_SIGNAL_FUNC(gtk_window_button_release_callback), (gpointer)this );
47d67540 2925
43a18898
RR		 2926 gtk_signal_connect( GTK_OBJECT(widget), "motion_notify_event",
2927 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback), (gpointer)this );
47d67540 2928
43a18898
RR		 2929 gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event",
2930 GTK_SIGNAL_FUNC(gtk_window_enter_callback), (gpointer)this );
47d67540 2931
43a18898
RR		 2932 gtk_signal_connect( GTK_OBJECT(widget), "leave_notify_event",
2933 GTK_SIGNAL_FUNC(gtk_window_leave_callback), (gpointer)this );
362c6693 2934}
c801d85f 2935
1e6feb95 2936bool wxWindowGTK::Destroy()
c801d85f 2937{
223d09f6 2938 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
47d67540 2939
43a18898 2940 m_hasVMT = FALSE;
c801d85f 2941
f03fc89f 2942 return wxWindowBase::Destroy();
362c6693 2943}
c801d85f 2944
1e6feb95 2945void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
23efdd02
RR		 2946{
2947 gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
2948}
2daa0ce9 2949
1e6feb95 2950void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
c801d85f 2951{
223d09f6 2952 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
1e6feb95 2953 wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
8bbe427f 2954
33611ebb 2955/*
f94fca1b 2956 printf( "DoSetSize: name %s, x,y,w,h: %d,%d,%d,%d \n", GetName().c_str(), x,y,width,height );
33611ebb
RR		 2957*/
2958
e27ce4e9 2959 if (m_resizing) return; /* I don't like recursions */
fb1585ae 2960 m_resizing = TRUE;
1e6feb95 2961
b9f29261
VS		 2962 int currentX, currentY;
2963 GetPosition(&currentX, &currentY);
2964 if (x == -1)
2965 x = currentX;
a200c35e 2966 if (y == -1)
b9f29261 2967 y = currentY;
a200c35e
VS		 2968 AdjustForParentClientOrigin(x, y, sizeFlags);
2969
a2053b27 2970 if (m_parent->m_wxwindow == NULL) /* i.e. wxNotebook */
fb1585ae 2971 {
e27ce4e9 2972 /* don't set the size for children of wxNotebook, just take the values. */
fb1585ae
RR		 2973 m_x = x;
2974 m_y = y;
2975 m_width = width;
ba4e3652 2976 m_height = height;
fb1585ae 2977 }
ba4e3652 2978 else
fb1585ae 2979 {
da048e3d 2980 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
85ad5eb5 2981 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
ba4e3652 2982 {
da048e3d
RR		 2983 if (x != -1) m_x = x + pizza->xoffset;
2984 if (y != -1) m_y = y + pizza->yoffset;
ba4e3652
RR		 2985 }
2986 else
2987 {
da048e3d
RR		 2988 m_x = x + pizza->xoffset;
2989 m_y = y + pizza->yoffset;
ba4e3652 2990 }
d44c23ce
RR		 2991 if (width != -1) m_width = width;
2992 if (height != -1) m_height = height;
47d67540 2993
ba4e3652
RR		 2994 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
2995 {
2996 if (width == -1) m_width = 80;
2997 }
2998
2999 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
3000 {
3001 if (height == -1) m_height = 26;
3002 }
8bbe427f 3003
e7dda1ff
VS		 3004 int minWidth = GetMinWidth(),
3005 minHeight = GetMinHeight(),
3006 maxWidth = GetMaxWidth(),
3007 maxHeight = GetMaxHeight();
3008
3009 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
3010 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
3011 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
3012 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
47d67540 3013
a2053b27 3014 int border = 0;
c50f1fb9 3015 int bottom_border = 0;
f03fc89f 3016
eb9e6a00 3017#ifndef __WXGTK20__
29f538ce 3018 if (GTK_WIDGET_CAN_DEFAULT(m_widget))
c50f1fb9
VZ		 3019 {
3020 /* the default button has a border around it */
3021 border = 6;
3022 bottom_border = 5;
3023 }
67d78217 3024#endif
c50f1fb9 3025
23efdd02
RR		 3026 DoMoveWindow( m_x-border,
3027 m_y-border,
3028 m_width+2*border,
3029 m_height+border+bottom_border );
54517652 3030 }
148cd9b6 3031
5b8a521e
RR		 3032 if (m_hasScrolling)
3033 {
1e6feb95 3034 /* Sometimes the client area changes size without the
b6fa52db
RR		 3035 whole windows's size changing, but if the whole
3036 windows's size doesn't change, no wxSizeEvent will
3037 normally be sent. Here we add an extra test if
3038 the client test has been changed and this will
3039 be used then. */
5b8a521e
RR		 3040 GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
3041 }
3042
54517652 3043/*
6d693bb4
RR		 3044 wxPrintf( "OnSize sent from " );
3045 if (GetClassInfo() && GetClassInfo()->GetClassName())
3046 wxPrintf( GetClassInfo()->GetClassName() );
3047 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
3048*/
3049
30760ce7
RR		 3050 if (!m_nativeSizeEvent)
3051 {
3052 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
3053 event.SetEventObject( this );
3054 GetEventHandler()->ProcessEvent( event );
3055 }
6d693bb4 3056
fb1585ae 3057 m_resizing = FALSE;
362c6693 3058}
c801d85f 3059
1e6feb95 3060void wxWindowGTK::OnInternalIdle()
9390a202 3061{
beab25bd 3062 // Update invalidated regions.
010afced 3063 GtkUpdate();
0fc5dbf5 3064
beab25bd 3065 // Synthetize activate events.
148cd9b6
VZ		 3066 if ( g_sendActivateEvent != -1 )
3067 {
3068 bool activate = g_sendActivateEvent != 0;
3069
3070 // do it only once
3071 g_sendActivateEvent = -1;
3072
1e6feb95 3073 wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast);
148cd9b6
VZ		 3074 }
3075
e8c12a53
VS		 3076 if ( g_activeFrameLostFocus )
3077 {
3078 if ( g_activeFrame )
3079 {
45eb5249 3080 wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame);
e8c12a53
VS		 3081 wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
3082 event.SetEventObject(g_activeFrame);
3083 g_activeFrame->GetEventHandler()->ProcessEvent(event);
3084 g_activeFrame = NULL;
3085 }
3086 g_activeFrameLostFocus = FALSE;
3087 }
2b5f62a0 3088
9146082c
RR		 3089 wxCursor cursor = m_cursor;
3090 if (g_globalCursor.Ok()) cursor = g_globalCursor;
c50f1fb9 3091
f7a11f8c 3092 if (cursor.Ok())
9146082c 3093 {
3017f78d 3094 /* I now set the cursor anew in every OnInternalIdle call
b02da6b1
VZ		 3095 as setting the cursor in a parent window also effects the
3096 windows above so that checking for the current cursor is
3097 not possible. */
148cd9b6 3098
9146082c 3099 if (m_wxwindow)
6a008b33 3100 {
da048e3d 3101 GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
6a008b33 3102 if (window)
c50f1fb9 3103 gdk_window_set_cursor( window, cursor.GetCursor() );
6a008b33
VZ		 3104
3105 if (!g_globalCursor.Ok())
3106 cursor = *wxSTANDARD_CURSOR;
3107
3108 window = m_widget->window;
5e014a0c 3109 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
9146082c 3110 gdk_window_set_cursor( window, cursor.GetCursor() );
5e014a0c 3111
6a008b33
VZ		 3112 }
3113 else
3114 {
5e014a0c 3115
9146082c 3116 GdkWindow *window = m_widget->window;
5e014a0c 3117 if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
9146082c 3118 gdk_window_set_cursor( window, cursor.GetCursor() );
5e014a0c 3119
6a008b33 3120 }
9146082c 3121 }
6a008b33 3122
9390a202
RR		 3123 UpdateWindowUI();
3124}
3125
1e6feb95 3126void wxWindowGTK::DoGetSize( int *width, int *height ) const
c801d85f 3127{
223d09f6 3128 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3129
fb1585ae
RR		 3130 if (width) (*width) = m_width;
3131 if (height) (*height) = m_height;
362c6693 3132}
c801d85f 3133
1e6feb95 3134void wxWindowGTK::DoSetClientSize( int width, int height )
c801d85f 3135{
223d09f6 3136 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3137
1ecc4d80 3138 if (!m_wxwindow)
c801d85f 3139 {
1ecc4d80 3140 SetSize( width, height );
c801d85f
KB		 3141 }
3142 else
3143 {
1ecc4d80
RR		 3144 int dw = 0;
3145 int dh = 0;
3146
1e6feb95 3147#ifndef __WXUNIVERSAL__
98d3fdbe
RR		 3148 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3149 {
5e014a0c 3150 /* when using GTK 1.2 we set the shadow border size to 2 */
6a008b33 3151 dw += 2 * 2;
98d3fdbe
RR		 3152 dh += 2 * 2;
3153 }
5e014a0c
RR		 3154 if (HasFlag(wxSIMPLE_BORDER))
3155 {
3156 /* when using GTK 1.2 we set the simple border size to 1 */
3157 dw += 1 * 2;
3158 dh += 1 * 2;
3159 }
1e6feb95 3160#endif // __WXUNIVERSAL__
034be888 3161
5b8a521e 3162 if (m_hasScrolling)
98d3fdbe 3163 {
324dbfec 3164 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2daa0ce9 3165
9000c624
RR		 3166 GtkRequisition vscroll_req;
3167 vscroll_req.width = 2;
3168 vscroll_req.height = 2;
dd00f3f6 3169 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
9000c624 3170 (scroll_window->vscrollbar, &vscroll_req );
2daa0ce9 3171
9000c624
RR		 3172 GtkRequisition hscroll_req;
3173 hscroll_req.width = 2;
3174 hscroll_req.height = 2;
dd00f3f6 3175 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
9000c624
RR		 3176 (scroll_window->hscrollbar, &hscroll_req );
3177
dd00f3f6 3178 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
324dbfec 3179
1ecc4d80
RR		 3180 if (scroll_window->vscrollbar_visible)
3181 {
9000c624 3182 dw += vscroll_req.width;
1ecc4d80
RR		 3183 dw += scroll_class->scrollbar_spacing;
3184 }
3185
3186 if (scroll_window->hscrollbar_visible)
3187 {
9000c624 3188 dh += hscroll_req.height;
63cc5d9d 3189 dh += scroll_class->scrollbar_spacing;
1ecc4d80 3190 }
9000c624 3191 }
1ecc4d80 3192
034be888 3193 SetSize( width+dw, height+dh );
1ecc4d80 3194 }
362c6693 3195}
c801d85f 3196
1e6feb95 3197void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
c801d85f 3198{
223d09f6 3199 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3200
1ecc4d80
RR		 3201 if (!m_wxwindow)
3202 {
3203 if (width) (*width) = m_width;
3204 if (height) (*height) = m_height;
c801d85f
KB		 3205 }
3206 else
3207 {
1ecc4d80
RR		 3208 int dw = 0;
3209 int dh = 0;
3210
1e6feb95 3211#ifndef __WXUNIVERSAL__
98d3fdbe
RR		 3212 if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
3213 {
5e014a0c 3214 /* when using GTK 1.2 we set the shadow border size to 2 */
6a008b33 3215 dw += 2 * 2;
98d3fdbe
RR		 3216 dh += 2 * 2;
3217 }
5e014a0c
RR		 3218 if (HasFlag(wxSIMPLE_BORDER))
3219 {
3220 /* when using GTK 1.2 we set the simple border size to 1 */
3221 dw += 1 * 2;
3222 dh += 1 * 2;
3223 }
1e6feb95 3224#endif // __WXUNIVERSAL__
9000c624 3225
5b8a521e 3226 if (m_hasScrolling)
98d3fdbe 3227 {
6a008b33 3228 GtkScrolledWindow *scroll_window = GTK_SCROLLED_WINDOW(m_widget);
2daa0ce9 3229
9000c624
RR		 3230 GtkRequisition vscroll_req;
3231 vscroll_req.width = 2;
3232 vscroll_req.height = 2;
dd00f3f6 3233 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->vscrollbar) )->size_request )
9000c624 3234 (scroll_window->vscrollbar, &vscroll_req );
2daa0ce9 3235
9000c624
RR		 3236 GtkRequisition hscroll_req;
3237 hscroll_req.width = 2;
3238 hscroll_req.height = 2;
dd00f3f6 3239 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(scroll_window->hscrollbar) )->size_request )
9000c624
RR		 3240 (scroll_window->hscrollbar, &hscroll_req );
3241
dd00f3f6 3242 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
6a008b33 3243
1ecc4d80
RR		 3244 if (scroll_window->vscrollbar_visible)
3245 {
9000c624 3246 dw += vscroll_req.width;
1ecc4d80
RR		 3247 dw += scroll_class->scrollbar_spacing;
3248 }
3249
3250 if (scroll_window->hscrollbar_visible)
3251 {
9000c624 3252 dh += hscroll_req.height;
1ecc4d80
RR		 3253 dh += scroll_class->scrollbar_spacing;
3254 }
6a008b33 3255 }
47d67540 3256
1ecc4d80
RR		 3257 if (width) (*width) = m_width - dw;
3258 if (height) (*height) = m_height - dh;
3259 }
1e6feb95 3260
f94fca1b
RR		 3261/*
3262 printf( "GetClientSize, name %s ", GetName().c_str() );
3263 if (width) printf( " width = %d", (*width) );
3264 if (height) printf( " height = %d", (*height) );
3265 printf( "\n" );
3266*/
362c6693 3267}
c801d85f 3268
1e6feb95 3269void wxWindowGTK::DoGetPosition( int *x, int *y ) const
c801d85f 3270{
223d09f6 3271 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3272
bf0c00c6
RR		 3273 int dx = 0;
3274 int dy = 0;
3275 if (m_parent && m_parent->m_wxwindow)
3276 {
da048e3d 3277 GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
b02da6b1
VZ		 3278 dx = pizza->xoffset;
3279 dy = pizza->yoffset;
bf0c00c6 3280 }
94633ad9 3281
496beb3f
VS		 3282 if (x) (*x) = m_x - dx;
3283 if (y) (*y) = m_y - dy;
362c6693 3284}
c801d85f 3285
1e6feb95 3286void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
c801d85f 3287{
223d09f6 3288 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3289
a2053b27
RR		 3290 if (!m_widget->window) return;
3291
43a18898
RR		 3292 GdkWindow *source = (GdkWindow *) NULL;
3293 if (m_wxwindow)
da048e3d 3294 source = GTK_PIZZA(m_wxwindow)->bin_window;
43a18898
RR		 3295 else
3296 source = m_widget->window;
47d67540 3297
43a18898
RR		 3298 int org_x = 0;
3299 int org_y = 0;
3300 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 3301
43a18898 3302 if (!m_wxwindow)
c801d85f 3303 {
43a18898
RR		 3304 if (GTK_WIDGET_NO_WINDOW (m_widget))
3305 {
3306 org_x += m_widget->allocation.x;
3307 org_y += m_widget->allocation.y;
3308 }
362c6693 3309 }
47d67540 3310
43a18898
RR		 3311 if (x) *x += org_x;
3312 if (y) *y += org_y;
362c6693 3313}
c801d85f 3314
1e6feb95 3315void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
c801d85f 3316{
223d09f6 3317 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3318
a2053b27
RR		 3319 if (!m_widget->window) return;
3320
1ecc4d80
RR		 3321 GdkWindow *source = (GdkWindow *) NULL;
3322 if (m_wxwindow)
da048e3d 3323 source = GTK_PIZZA(m_wxwindow)->bin_window;
1ecc4d80
RR		 3324 else
3325 source = m_widget->window;
47d67540 3326
1ecc4d80
RR		 3327 int org_x = 0;
3328 int org_y = 0;
3329 gdk_window_get_origin( source, &org_x, &org_y );
c801d85f 3330
1ecc4d80 3331 if (!m_wxwindow)
c801d85f 3332 {
1ecc4d80
RR		 3333 if (GTK_WIDGET_NO_WINDOW (m_widget))
3334 {
3335 org_x += m_widget->allocation.x;
3336 org_y += m_widget->allocation.y;
3337 }
362c6693 3338 }
47d67540 3339
1ecc4d80
RR		 3340 if (x) *x -= org_x;
3341 if (y) *y -= org_y;
362c6693 3342}
c801d85f 3343
1e6feb95 3344bool wxWindowGTK::Show( bool show )
c801d85f 3345{
223d09f6 3346 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
47d67540 3347
739730ca
RR		 3348 if (!wxWindowBase::Show(show))
3349 {
3350 // nothing to do
f03fc89f 3351 return FALSE;
739730ca 3352 }
8bbe427f 3353
f03fc89f
VZ		 3354 if (show)
3355 gtk_widget_show( m_widget );
1ecc4d80 3356 else
f03fc89f 3357 gtk_widget_hide( m_widget );
8bbe427f 3358
2b5f62a0
VZ		 3359 wxShowEvent eventShow(GetId(), show);
3360 eventShow.m_eventObject = this;
3361
3362 GetEventHandler()->ProcessEvent(eventShow);
3363
f03fc89f 3364 return TRUE;
362c6693 3365}
c801d85f 3366
3379ed37 3367static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable)
fdca68a6
JS		 3368{
3369 win->OnParentEnable(enable);
3370
3371 // Recurse, so that children have the opportunity to Do The Right Thing
3372 // and reset colours that have been messed up by a parent's (really ancestor's)
3373 // Enable call
3374 for ( wxWindowList::Node *node = win->GetChildren().GetFirst();
3375 node;
3376 node = node->GetNext() )
3377 {
3378 wxWindow *child = node->GetData();
3379 if (!child->IsKindOf(CLASSINFO(wxDialog)) && !child->IsKindOf(CLASSINFO(wxFrame)))
3380 wxWindowNotifyEnable(child, enable);
3381 }
3382}
3383
3379ed37 3384bool wxWindowGTK::Enable( bool enable )
c801d85f 3385{
223d09f6 3386 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
5e0aa05a 3387
739730ca
RR		 3388 if (!wxWindowBase::Enable(enable))
3389 {
3390 // nothing to do
f03fc89f 3391 return FALSE;
739730ca 3392 }
1ecc4d80 3393
f03fc89f
VZ		 3394 gtk_widget_set_sensitive( m_widget, enable );
3395 if ( m_wxwindow )
3396 gtk_widget_set_sensitive( m_wxwindow, enable );
ff8bfdbb 3397
fdca68a6 3398 wxWindowNotifyEnable(this, enable);
513903c4 3399
f03fc89f 3400 return TRUE;
362c6693 3401}
c801d85f 3402
1e6feb95 3403int wxWindowGTK::GetCharHeight() const
2f2aa628 3404{
223d09f6 3405 wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
47d67540 3406
223d09f6 3407 wxCHECK_MSG( m_font.Ok(), 12, wxT("invalid font") );
2f2aa628 3408
bbd006c0
RR		 3409#ifdef __WXGTK20__
3410 PangoContext *context = NULL;
3411 if (m_widget)
3412 context = gtk_widget_get_pango_context( m_widget );
3413
3414 if (!context)
3415 return 0;
3416
3417 PangoFontDescription *desc = m_font.GetNativeFontInfo()->description;
3418 PangoLayout *layout = pango_layout_new(context);
3419 pango_layout_set_font_description(layout, desc);
3420 pango_layout_set_text(layout, "H", 1);
3421 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3422
3423 PangoRectangle rect;
3424 pango_layout_line_get_extents(line, NULL, &rect);
3425
3426 g_object_unref( G_OBJECT( layout ) );
7de59551 3427
bbd006c0
RR		 3428 return (int) (rect.height / PANGO_SCALE);
3429#else
f03fc89f
VZ		 3430 GdkFont *font = m_font.GetInternalFont( 1.0 );
3431
3432 return font->ascent + font->descent;
bbd006c0 3433#endif
362c6693 3434}
c801d85f 3435
1e6feb95 3436int wxWindowGTK::GetCharWidth() const
c33c4050 3437{
223d09f6 3438 wxCHECK_MSG( (m_widget != NULL), 8, wxT("invalid window") );
47d67540 3439
223d09f6 3440 wxCHECK_MSG( m_font.Ok(), 8, wxT("invalid font") );
47d67540 3441
bbd006c0
RR		 3442#ifdef __WXGTK20__
3443 PangoContext *context = NULL;
3444 if (m_widget)
3445 context = gtk_widget_get_pango_context( m_widget );
3446
3447 if (!context)
3448 return 0;
3449
3450 PangoFontDescription *desc = m_font.GetNativeFontInfo()->description;
3451 PangoLayout *layout = pango_layout_new(context);
3452 pango_layout_set_font_description(layout, desc);
3453 pango_layout_set_text(layout, "H", 1);
3454 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
3455
3456 PangoRectangle rect;
3457 pango_layout_line_get_extents(line, NULL, &rect);
3458
3459 g_object_unref( G_OBJECT( layout ) );
7de59551 3460
bbd006c0
RR		 3461 return (int) (rect.width / PANGO_SCALE);
3462#else
463c1fa1 3463 GdkFont *font = m_font.GetInternalFont( 1.0 );
ff8bfdbb 3464
463c1fa1 3465 return gdk_string_width( font, "H" );
bbd006c0 3466#endif
c33c4050
RR		 3467}
3468
1e6feb95 3469void wxWindowGTK::GetTextExtent( const wxString& string,
f03fc89f
VZ		 3470 int *x,
3471 int *y,
3472 int *descent,
3473 int *externalLeading,
3474 const wxFont *theFont ) const
c33c4050 3475{
463c1fa1
RR		 3476 wxFont fontToUse = m_font;
3477 if (theFont) fontToUse = *theFont;
47d67540 3478
223d09f6 3479 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
2b5f62a0 3480
48d011c8
RR		 3481 if (string.IsEmpty())
3482 {
b15ed747
RR		 3483 if (x) (*x) = 0;
3484 if (y) (*y) = 0;
48d011c8
RR		 3485 return;
3486 }
47d67540 3487
2b5f62a0 3488#ifdef __WXGTK20__
48d011c8
RR		 3489 PangoContext *context = NULL;
3490 if (m_widget)
2b5f62a0
VZ		 3491 context = gtk_widget_get_pango_context( m_widget );
3492
48d011c8
RR		 3493 if (!context)
3494 {
b15ed747
RR		 3495 if (x) (*x) = 0;
3496 if (y) (*y) = 0;
48d011c8
RR		 3497 return;
3498 }
2b5f62a0 3499
48d011c8
RR		 3500 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
3501 PangoLayout *layout = pango_layout_new(context);
3502 pango_layout_set_font_description(layout, desc);
3503 {
fb3ed106 3504#if wxUSE_UNICODE
48d011c8
RR		 3505 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
3506 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
fb3ed106
RR		 3507#else
3508 const wxWCharBuffer wdata = wxConvLocal.cMB2WC( string );
3509 const wxCharBuffer data = wxConvUTF8.cWC2MB( wdata );
3510 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
3511#endif
48d011c8
RR		 3512 }
3513 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
2b5f62a0 3514
48d011c8
RR		 3515 PangoRectangle rect;
3516 pango_layout_line_get_extents(line, NULL, &rect);
2b5f62a0 3517
b15ed747
RR		 3518 if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
3519 if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
48d011c8
RR		 3520 if (descent)
3521 {
3522 // Do something about metrics here
3523 (*descent) = 0;
3524 }
3525 if (externalLeading) (*externalLeading) = 0; // ??
2b5f62a0 3526
48d011c8
RR		 3527 g_object_unref( G_OBJECT( layout ) );
3528#else
463c1fa1 3529 GdkFont *font = fontToUse.GetInternalFont( 1.0 );
fab591c5 3530 if (x) (*x) = gdk_string_width( font, wxGTK_CONV( string ) );
463c1fa1
RR		 3531 if (y) (*y) = font->ascent + font->descent;
3532 if (descent) (*descent) = font->descent;
3533 if (externalLeading) (*externalLeading) = 0; // ??
48d011c8 3534#endif
c33c4050
RR		 3535}
3536
1e6feb95 3537void wxWindowGTK::SetFocus()
c801d85f 3538{
6cad4f1b
VZ		 3539 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
3540
3541 if ( m_hasFocus )
3542 {
3543 // don't do anything if we already have focus
3544 return;
3545 }
2daa0ce9 3546
354aa1e3
RR		 3547 if (m_wxwindow)
3548 {
173348db 3549 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow))
b231914f 3550 {
173348db 3551 gtk_widget_grab_focus (m_wxwindow);
b231914f 3552 }
354aa1e3 3553 }
b231914f 3554 else if (m_widget)
c801d85f 3555 {
173348db 3556 if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) )
463c1fa1 3557 {
d7fa7eaa 3558 if (!GTK_WIDGET_REALIZED(m_widget))
6aeb6f2a 3559 {
6cad4f1b
VZ		 3560 // we can't set the focus to the widget now so we remember that
3561 // it should be focused and will do it later, during the idle
3562 // time, as soon as we can
3563 wxLogTrace(TRACE_FOCUS,
3564 _T("Delaying setting focus to %s(%s)"),
6aeb6f2a
VZ		 3565 GetClassInfo()->GetClassName(), GetLabel().c_str());
3566
d7fa7eaa 3567 g_delayedFocus = this;
6aeb6f2a 3568 }
d7fa7eaa 3569 else
6aeb6f2a 3570 {
6cad4f1b
VZ		 3571 wxLogTrace(TRACE_FOCUS,
3572 _T("Setting focus to %s(%s)"),
6aeb6f2a
VZ		 3573 GetClassInfo()->GetClassName(), GetLabel().c_str());
3574
d7fa7eaa 3575 gtk_widget_grab_focus (m_widget);
6aeb6f2a 3576 }
463c1fa1 3577 }
354aa1e3 3578 else if (GTK_IS_CONTAINER(m_widget))
ff8bfdbb 3579 {
9e691f46 3580 SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD );
ff8bfdbb
VZ		 3581 }
3582 else
3583 {
6cad4f1b
VZ		 3584 wxLogTrace(TRACE_FOCUS,
3585 _T("Can't set focus to %s(%s)"),
3586 GetClassInfo()->GetClassName(), GetLabel().c_str());
ff8bfdbb 3587 }
362c6693 3588 }
362c6693 3589}
c801d85f 3590
1e6feb95 3591bool wxWindowGTK::AcceptsFocus() const
b292e2f5 3592{
f03fc89f 3593 return m_acceptsFocus && wxWindowBase::AcceptsFocus();
b292e2f5
RR		 3594}
3595
1e6feb95 3596bool wxWindowGTK::Reparent( wxWindowBase *newParentBase )
463c1fa1 3597{
223d09f6 3598 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
c50f1fb9 3599
1e6feb95
VZ		 3600 wxWindowGTK *oldParent = m_parent,
3601 *newParent = (wxWindowGTK *)newParentBase;
a2053b27 3602
5fd11f09
RR		 3603 wxASSERT( GTK_IS_WIDGET(m_widget) );
3604
f03fc89f
VZ		 3605 if ( !wxWindowBase::Reparent(newParent) )
3606 return FALSE;
8bbe427f 3607
5fd11f09
RR		 3608 wxASSERT( GTK_IS_WIDGET(m_widget) );
3609
3610 /* prevent GTK from deleting the widget arbitrarily */
3611 gtk_widget_ref( m_widget );
3612
8ce63e9d
RR		 3613 if (oldParent)
3614 {
3017f78d 3615 gtk_container_remove( GTK_CONTAINER(m_widget->parent), m_widget );
8ce63e9d 3616 }
c50f1fb9 3617
5fd11f09
RR		 3618 wxASSERT( GTK_IS_WIDGET(m_widget) );
3619
8ce63e9d
RR		 3620 if (newParent)
3621 {
3622 /* insert GTK representation */
3623 (*(newParent->m_insertCallback))(newParent, this);
3624 }
c50f1fb9 3625
5fd11f09
RR		 3626 /* reverse: prevent GTK from deleting the widget arbitrarily */
3627 gtk_widget_unref( m_widget );
148cd9b6 3628
f03fc89f 3629 return TRUE;
362c6693 3630}
c801d85f 3631
1e6feb95 3632void wxWindowGTK::DoAddChild(wxWindowGTK *child)
ddb6bc71 3633{
223d09f6 3634 wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
ddb6bc71 3635
223d09f6 3636 wxASSERT_MSG( (child != NULL), wxT("invalid child window") );
ddb6bc71 3637
223d09f6 3638 wxASSERT_MSG( (m_insertCallback != NULL), wxT("invalid child insertion function") );
c50f1fb9 3639
ddb6bc71
RR		 3640 /* add to list */
3641 AddChild( child );
c50f1fb9 3642
ddb6bc71
RR		 3643 /* insert GTK representation */
3644 (*m_insertCallback)(this, child);
3645}
3646
1e6feb95 3647void wxWindowGTK::Raise()
362c6693 3648{
223d09f6 3649 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3650
a2053b27
RR		 3651 if (!m_widget->window) return;
3652
f03fc89f 3653 gdk_window_raise( m_widget->window );
362c6693
RR		 3654}
3655
1e6feb95 3656void wxWindowGTK::Lower()
362c6693 3657{
223d09f6 3658 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
47d67540 3659
a2053b27
RR		 3660 if (!m_widget->window) return;
3661
f03fc89f 3662 gdk_window_lower( m_widget->window );
362c6693 3663}
c801d85f 3664
1e6feb95 3665bool wxWindowGTK::SetCursor( const wxCursor &cursor )
86b29a61 3666{
223d09f6 3667 wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") );
86b29a61 3668
f6bcfd97
BP		 3669 if (cursor == m_cursor)
3670 return FALSE;
3671
3672 if (g_isIdle)
3673 wxapp_install_idle_handler();
1e6feb95 3674
f6bcfd97
BP		 3675 if (cursor == wxNullCursor)
3676 return wxWindowBase::SetCursor( *wxSTANDARD_CURSOR );
3677 else
3678 return wxWindowBase::SetCursor( cursor );
362c6693 3679}
c801d85f 3680
1e6feb95 3681void wxWindowGTK::WarpPointer( int x, int y )
4f22cf8d 3682{
223d09f6 3683 wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
85eb36c2 3684
3bcc8d15
RR		 3685 // We provide this function ourselves as it is
3686 // missing in GDK (top of this file).
148cd9b6 3687
ed673c6a
RR		 3688 GdkWindow *window = (GdkWindow*) NULL;
3689 if (m_wxwindow)
da048e3d 3690 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 3691 else
3692 window = GetConnectWidget()->window;
148cd9b6 3693
ed673c6a
RR		 3694 if (window)
3695 gdk_window_warp_pointer( window, x, y );
4f22cf8d
RR		 3696}
3697
3013a903 3698
1e6feb95 3699void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect )
c801d85f 3700{
f2593d0d 3701 if (!m_widget) return;
a2053b27 3702 if (!m_widget->window) return;
2b5f62a0 3703
4e5a4c69 3704#ifndef __WXGTK20__
ea323db3
RR		 3705 if (g_isIdle)
3706 wxapp_install_idle_handler();
2b5f62a0 3707
139adb6a 3708 if (eraseBackground && m_wxwindow && m_wxwindow->window)
c801d85f 3709 {
139adb6a
RR		 3710 if (rect)
3711 {
3bcc8d15
RR		 3712 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3713 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
139adb6a
RR		 3714 }
3715 else
3716 {
3bcc8d15
RR		 3717 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3718 m_clearRegion.Clear();
3719 m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
139adb6a
RR		 3720 }
3721 }
ff8bfdbb 3722
3bcc8d15 3723 if (rect)
139adb6a
RR		 3724 {
3725 if (m_wxwindow)
b02da6b1 3726 {
23716407 3727 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3bcc8d15 3728 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
b02da6b1 3729 }
ff8bfdbb 3730 else
b6fa52db 3731 {
3bcc8d15
RR		 3732 GdkRectangle gdk_rect;
3733 gdk_rect.x = rect->x;
3734 gdk_rect.y = rect->y;
3735 gdk_rect.width = rect->width;
3736 gdk_rect.height = rect->height;
3737 gtk_widget_draw( m_widget, &gdk_rect );
b6fa52db 3738 }
362c6693 3739 }
c801d85f 3740 else
139adb6a 3741 {
139adb6a 3742 if (m_wxwindow)
b02da6b1 3743 {
23716407 3744 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
3bcc8d15
RR		 3745 m_updateRegion.Clear();
3746 m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height );
b02da6b1 3747 }
139adb6a 3748 else
b6fa52db 3749 {
3bcc8d15 3750 gtk_widget_draw( m_widget, (GdkRectangle*) NULL );
b6fa52db 3751 }
139adb6a 3752 }
4e5a4c69
RR		 3753#else
3754 if (m_wxwindow)
3755 {
3756 if (rect)
3757 {
3758 GdkRectangle gdk_rect;
3759 gdk_rect.x = rect->x;
3760 gdk_rect.y = rect->y;
3761 gdk_rect.width = rect->width;
3762 gdk_rect.height = rect->height;
3763 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE );
3764 }
3765 else
3766 {
3767 gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE );
3768 }
3769 }
3770#endif
362c6693 3771}
c801d85f 3772
beab25bd 3773void wxWindowGTK::Update()
010afced
RR		 3774{
3775 GtkUpdate();
3776}
3777
3778void wxWindowGTK::GtkUpdate()
beab25bd 3779{
4e5a4c69
RR		 3780#ifdef __WXGTK20__
3781 if (m_wxwindow && GTK_PIZZA(m_wxwindow)->bin_window)
3782 gdk_window_process_updates( GTK_PIZZA(m_wxwindow)->bin_window, FALSE );
b15ed747 3783#else
beab25bd 3784 if (!m_updateRegion.IsEmpty())
23716407 3785 GtkSendPaintEvents();
b15ed747 3786#endif
beab25bd
RR		 3787}
3788
3789void wxWindowGTK::GtkSendPaintEvents()
3790{
3bcc8d15
RR		 3791 if (!m_wxwindow)
3792 {
2b5f62a0 3793#ifndef __WXGTK20__
3bcc8d15 3794 m_clearRegion.Clear();
b15ed747 3795#endif
3bcc8d15
RR		 3796 m_updateRegion.Clear();
3797 return;
3798 }
beab25bd 3799
f90566f5 3800 // Clip to paint region in wxClientDC
3bcc8d15 3801 m_clipPaintRegion = TRUE;
fab591c5 3802
b15ed747
RR		 3803#ifndef __WXGTK20__
3804 // widget to draw on
3805 GtkPizza *pizza = GTK_PIZZA (m_wxwindow);
2b5f62a0 3806
b15ed747 3807 // later for GTK 2.0, too.
f90566f5
RR		 3808 if (GetThemeEnabled())
3809 {
3810 // find ancestor from which to steal background
3811 wxWindow *parent = GetParent();
3812 while (parent && !parent->IsTopLevel())
3813 parent = parent->GetParent();
3814 if (!parent)
cc06fe74 3815 parent = (wxWindow*)this;
2b5f62a0 3816
f90566f5
RR		 3817 wxRegionIterator upd( m_updateRegion );
3818 while (upd)
3819 {
3820 GdkRectangle rect;
3821 rect.x = upd.GetX();
3822 rect.y = upd.GetY();
3823 rect.width = upd.GetWidth();
3824 rect.height = upd.GetHeight();
2b5f62a0 3825
f90566f5
RR		 3826 gtk_paint_flat_box( parent->m_widget->style,
3827 pizza->bin_window,
3828 GTK_STATE_NORMAL,
3829 GTK_SHADOW_NONE,
3830 &rect,
3831 parent->m_widget,
3832 (char *)"base",
3833 0, 0, -1, -1 );
2b5f62a0 3834
f90566f5
RR		 3835 upd ++;
3836 }
3837 }
3838 else
fab591c5 3839#endif
b15ed747
RR		 3840
3841#ifdef __WXGTK20__
3842 {
3843 wxWindowDC dc( (wxWindow*)this );
3844 dc.SetClippingRegion( m_updateRegion );
3845
3846 wxEraseEvent erase_event( GetId(), &dc );
3847 erase_event.SetEventObject( this );
3848
3849 GetEventHandler()->ProcessEvent(erase_event);
3850 }
3851#else
3852 // if (!m_clearRegion.IsEmpty()) // Always send an erase event under GTK 1.2
beab25bd 3853 {
3bcc8d15 3854 wxWindowDC dc( (wxWindow*)this );
62cb3cd8
RR		 3855 if (m_clearRegion.IsEmpty())
3856 dc.SetClippingRegion( m_updateRegion );
3857 else
3858 dc.SetClippingRegion( m_clearRegion );
0fc5dbf5 3859
3bcc8d15
RR		 3860 wxEraseEvent erase_event( GetId(), &dc );
3861 erase_event.SetEventObject( this );
0fc5dbf5 3862
beab25bd
RR		 3863 if (!GetEventHandler()->ProcessEvent(erase_event))
3864 {
994bc575
RR		 3865 if (!g_eraseGC)
3866 {
f90566f5 3867 g_eraseGC = gdk_gc_new( pizza->bin_window );
994bc575
RR		 3868 gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
3869 }
4e5a4c69 3870 gdk_gc_set_foreground( g_eraseGC, m_backgroundColour.GetColor() );
0fc5dbf5 3871
3bcc8d15 3872 wxRegionIterator upd( m_clearRegion );
beab25bd
RR		 3873 while (upd)
3874 {
f90566f5
RR		 3875 gdk_draw_rectangle( pizza->bin_window, g_eraseGC, 1,
3876 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
beab25bd
RR		 3877 upd ++;
3878 }
3879 }
3bcc8d15 3880 m_clearRegion.Clear();
beab25bd 3881 }
b15ed747 3882#endif
beab25bd
RR		 3883
3884 wxNcPaintEvent nc_paint_event( GetId() );
3885 nc_paint_event.SetEventObject( this );
3886 GetEventHandler()->ProcessEvent( nc_paint_event );
3887
3888 wxPaintEvent paint_event( GetId() );
3889 paint_event.SetEventObject( this );
3890 GetEventHandler()->ProcessEvent( paint_event );
3891
beab25bd 3892 m_clipPaintRegion = FALSE;
c89f5c02 3893
8f3e7ecc 3894#ifndef __WXUNIVERSAL__
4e5a4c69 3895#ifndef __WXGTK20__
8f3e7ecc
RR		 3896 // The following code will result in all window-less widgets
3897 // being redrawn because the wxWindows class is allowed to
3898 // paint over the window-less widgets.
0fc5dbf5 3899
8f3e7ecc
RR		 3900 GList *children = pizza->children;
3901 while (children)
c89f5c02 3902 {
8f3e7ecc
RR		 3903 GtkPizzaChild *child = (GtkPizzaChild*) children->data;
3904 children = children->next;
2b5f62a0 3905
8f3e7ecc
RR		 3906 if (GTK_WIDGET_NO_WINDOW (child->widget) &&
3907 GTK_WIDGET_DRAWABLE (child->widget))
3908 {
3909 // Get intersection of widget area and update region
3910 wxRegion region( m_updateRegion );
0fc5dbf5 3911
8f3e7ecc
RR		 3912 GdkEventExpose gdk_event;
3913 gdk_event.type = GDK_EXPOSE;
3914 gdk_event.window = pizza->bin_window;
3915 gdk_event.count = 0;
0fc5dbf5 3916
8f3e7ecc
RR		 3917 wxRegionIterator upd( m_updateRegion );
3918 while (upd)
c89f5c02 3919 {
8f3e7ecc
RR		 3920 GdkRectangle rect;
3921 rect.x = upd.GetX();
3922 rect.y = upd.GetY();
3923 rect.width = upd.GetWidth();
3924 rect.height = upd.GetHeight();
0fc5dbf5 3925
8f3e7ecc
RR		 3926 if (gtk_widget_intersect (child->widget, &rect, &gdk_event.area))
3927 {
3928 gtk_widget_event (child->widget, (GdkEvent*) &gdk_event);
3929 }
0fc5dbf5 3930
8f3e7ecc 3931 upd ++;
c89f5c02
RR		 3932 }
3933 }
3934 }
4e5a4c69 3935#endif
8f3e7ecc 3936#endif
c89f5c02
RR		 3937
3938 m_updateRegion.Clear();
beab25bd
RR		 3939}
3940
1e6feb95 3941void wxWindowGTK::Clear()
c801d85f 3942{
223d09f6 3943 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 3944
b15ed747 3945#ifndef __WXGTK20__
f234c60c
RR		 3946 if (m_wxwindow && m_wxwindow->window)
3947 {
d7fa7eaa
RR		 3948 m_clearRegion.Clear();
3949 wxSize size( GetClientSize() );
3950 m_clearRegion.Union( 0,0,size.x,size.y );
2b5f62a0 3951
d7fa7eaa 3952 // Better do this in idle?
010afced 3953 GtkUpdate();
f234c60c 3954 }
b15ed747 3955#endif
362c6693 3956}
c801d85f 3957
ff8bfdbb 3958#if wxUSE_TOOLTIPS
1e6feb95 3959void wxWindowGTK::DoSetToolTip( wxToolTip *tip )
b1170810 3960{
f03fc89f 3961 wxWindowBase::DoSetToolTip(tip);
ff8bfdbb 3962
f03fc89f 3963 if (m_tooltip)
3379ed37 3964 m_tooltip->Apply( (wxWindow *)this );
b1170810
RR		 3965}
3966
1e6feb95 3967void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip )
b1170810 3968{
dcf924a3 3969 gtk_tooltips_set_tip( tips, GetConnectWidget(), wxConvCurrent->cWX2MB(tip), (gchar*) NULL );
301cd871 3970}
ff8bfdbb 3971#endif // wxUSE_TOOLTIPS
b1170810 3972
ea323db3
RR		 3973void wxWindowGTK::GtkSetBackgroundColour( const wxColour &colour )
3974{
3975 GdkWindow *window = (GdkWindow*) NULL;
3976 if (m_wxwindow)
3977 window = GTK_PIZZA(m_wxwindow)->bin_window;
3978 else
3979 window = GetConnectWidget()->window;
3980
3981 wxASSERT( window );
2b5f62a0 3982
ea323db3
RR		 3983 // We need the pixel value e.g. for background clearing.
3984 m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
2b5f62a0 3985
f90566f5 3986 if (m_wxwindow)
ea323db3 3987 {
f90566f5 3988 // wxMSW doesn't clear the window here, either.
ea323db3
RR		 3989 gdk_window_set_background( window, m_backgroundColour.GetColor() );
3990 }
3991
3992 ApplyWidgetStyle();
3993}
3994
1e6feb95 3995bool wxWindowGTK::SetBackgroundColour( const wxColour &colour )
c801d85f 3996{
223d09f6 3997 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
8bbe427f 3998
739730ca 3999 if (!wxWindowBase::SetBackgroundColour(colour))
ea323db3 4000 return FALSE;
c50f1fb9 4001
ed673c6a
RR		 4002 GdkWindow *window = (GdkWindow*) NULL;
4003 if (m_wxwindow)
da048e3d 4004 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 4005 else
4006 window = GetConnectWidget()->window;
148cd9b6 4007
ed673c6a 4008 if (!window)
739730ca
RR		 4009 {
4010 // indicate that a new style has been set
c50f1fb9
VZ		 4011 // but it couldn't get applied as the
4012 // widget hasn't been realized yet.
4013 m_delayedBackgroundColour = TRUE;
ea323db3 4014 return TRUE;
739730ca 4015 }
ea323db3 4016 else
994bc575 4017 {
ea323db3 4018 GtkSetBackgroundColour( colour );
994bc575 4019 }
ca298c88 4020
ea323db3
RR		 4021 return TRUE;
4022}
8bbe427f 4023
ea323db3
RR		 4024void wxWindowGTK::GtkSetForegroundColour( const wxColour &colour )
4025{
4026 GdkWindow *window = (GdkWindow*) NULL;
4027 if (m_wxwindow)
4028 window = GTK_PIZZA(m_wxwindow)->bin_window;
4029 else
4030 window = GetConnectWidget()->window;
c801d85f 4031
ea323db3
RR		 4032 wxASSERT( window );
4033
4034 ApplyWidgetStyle();
6de97a3b
RR		 4035}
4036
1e6feb95 4037bool wxWindowGTK::SetForegroundColour( const wxColour &colour )
6de97a3b 4038{
223d09f6 4039 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
8bbe427f 4040
739730ca
RR		 4041 if (!wxWindowBase::SetForegroundColour(colour))
4042 {
4043 // don't leave if the GTK widget has just
4044 // been realized
4045 if (!m_delayedForegroundColour) return FALSE;
4046 }
c50f1fb9 4047
ed673c6a
RR		 4048 GdkWindow *window = (GdkWindow*) NULL;
4049 if (m_wxwindow)
da048e3d 4050 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a
RR		 4051 else
4052 window = GetConnectWidget()->window;
148cd9b6 4053
ed673c6a 4054 if (!window)
739730ca
RR		 4055 {
4056 // indicate that a new style has been set
c50f1fb9
VZ		 4057 // but it couldn't get applied as the
4058 // widget hasn't been realized yet.
4059 m_delayedForegroundColour = TRUE;
739730ca 4060 }
ea323db3
RR		 4061 else
4062 {
4063 GtkSetForegroundColour( colour );
4064 }
f03fc89f
VZ		 4065
4066 return TRUE;
58614078
RR		 4067}
4068
2b5f62a0
VZ		 4069#ifdef __WXGTK20__
4070PangoContext *wxWindowGTK::GtkGetPangoDefaultContext()
4071{
4072 return gtk_widget_get_pango_context( m_widget );
4073}
4074
4075PangoContext *wxWindowGTK::GtkGetPangoX11Context()
4076{
4077 if (!m_x11Context)
4078 m_x11Context = pango_x_get_context( gdk_display );
4079
4080 return m_x11Context;
4081}
4082#endif
4083
1e6feb95 4084GtkStyle *wxWindowGTK::GetWidgetStyle()
58614078 4085{
103aab26
RR		 4086 if (m_widgetStyle)
4087 {
4088 GtkStyle *remake = gtk_style_copy( m_widgetStyle );
9e691f46
VZ		 4089
4090 // FIXME: no more klass in 2.0
4091#ifndef __WXGTK20__
103aab26 4092 remake->klass = m_widgetStyle->klass;
dd00f3f6 4093#endif
2daa0ce9 4094
103aab26
RR		 4095 gtk_style_unref( m_widgetStyle );
4096 m_widgetStyle = remake;
4097 }
4098 else
4099 {
4100 GtkStyle *def = gtk_rc_get_style( m_widget );
e6527f9d 4101
103aab26
RR		 4102 if (!def)
4103 def = gtk_widget_get_default_style();
e6527f9d 4104
103aab26 4105 m_widgetStyle = gtk_style_copy( def );
9e691f46
VZ		 4106
4107 // FIXME: no more klass in 2.0
4108#ifndef __WXGTK20__
103aab26 4109 m_widgetStyle->klass = def->klass;
dd00f3f6 4110#endif
103aab26 4111 }
8bbe427f 4112
1ecc4d80 4113 return m_widgetStyle;
58614078
RR		 4114}
4115
1e6feb95 4116void wxWindowGTK::SetWidgetStyle()
58614078 4117{
8f3e7ecc 4118#if DISABLE_STYLE_IF_BROKEN_THEME
fb65642c
RR		 4119 if (m_widget->style->engine_data)
4120 {
4121 static bool s_warningPrinted = FALSE;
4122 if (!s_warningPrinted)
4123 {
4124 printf( "wxWindows warning: Widget styles disabled due to buggy GTK theme.\n" );
4125 s_warningPrinted = TRUE;
4126 }
4127 m_widgetStyle = m_widget->style;
4128 return;
4129 }
a56fcaaf 4130#endif
fb65642c 4131
1ecc4d80
RR		 4132 GtkStyle *style = GetWidgetStyle();
4133
a756f210 4134 if (m_font != wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT ))
db434467 4135 {
288059b2
RR		 4136#ifdef __WXGTK20__
4137 pango_font_description_free( style->font_desc );
4138 pango_font_description_copy( m_font.GetNativeFontInfo()->description );
4139#else
4140 gdk_font_unref( style->font );
f77cf4e6 4141 style->font = gdk_font_ref( m_font.GetInternalFont( 1.0 ) );
cfcc3932 4142#endif
288059b2 4143 }
1ecc4d80
RR		 4144
4145 if (m_foregroundColour.Ok())
4146 {
454e2a22 4147 m_foregroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
a756f210 4148 if (m_foregroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNTEXT))
db434467
RR		 4149 {
4150 style->fg[GTK_STATE_NORMAL] = *m_foregroundColour.GetColor();
4151 style->fg[GTK_STATE_PRELIGHT] = *m_foregroundColour.GetColor();
4152 style->fg[GTK_STATE_ACTIVE] = *m_foregroundColour.GetColor();
4153 }
1e6feb95 4154 else
f6bcfd97
BP		 4155 {
4156 // Try to restore the gtk default style. This is still a little
4157 // oversimplified for what is probably really needed here for controls
4158 // other than buttons, but is better than not being able to (re)set a
4159 // control's foreground colour to *wxBLACK -- RL
4160 GtkStyle *def = gtk_rc_get_style( m_widget );
4161
4162 if (!def)
4163 def = gtk_widget_get_default_style();
4164
4165 style->fg[GTK_STATE_NORMAL] = def->fg[GTK_STATE_NORMAL];
4166 style->fg[GTK_STATE_PRELIGHT] = def->fg[GTK_STATE_PRELIGHT];
4167 style->fg[GTK_STATE_ACTIVE] = def->fg[GTK_STATE_ACTIVE];
4168 }
1ecc4d80
RR		 4169 }
4170
4171 if (m_backgroundColour.Ok())
4172 {
454e2a22 4173 m_backgroundColour.CalcPixel( gtk_widget_get_colormap( m_widget ) );
a756f210 4174 if (m_backgroundColour != wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE))
db434467
RR		 4175 {
4176 style->bg[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4177 style->base[GTK_STATE_NORMAL] = *m_backgroundColour.GetColor();
4178 style->bg[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4179 style->base[GTK_STATE_PRELIGHT] = *m_backgroundColour.GetColor();
4180 style->bg[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4181 style->base[GTK_STATE_ACTIVE] = *m_backgroundColour.GetColor();
4182 style->bg[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
4183 style->base[GTK_STATE_INSENSITIVE] = *m_backgroundColour.GetColor();
f6bcfd97
BP		 4184 }
4185 else
4186 {
4187 // Try to restore the gtk default style. This is still a little
4188 // oversimplified for what is probably really needed here for controls
4189 // other than buttons, but is better than not being able to (re)set a
4190 // control's background colour to default grey and means resetting a
1e6feb95 4191 // button to wxSYS_COLOUR_BTNFACE will restore its usual highlighting
f6bcfd97
BP		 4192 // behavior -- RL
4193 GtkStyle *def = gtk_rc_get_style( m_widget );
4194
4195 if (!def)
4196 def = gtk_widget_get_default_style();
4197
4198 style->bg[GTK_STATE_NORMAL] = def->bg[GTK_STATE_NORMAL];
4199 style->base[GTK_STATE_NORMAL] = def->base[GTK_STATE_NORMAL];
4200 style->bg[GTK_STATE_PRELIGHT] = def->bg[GTK_STATE_PRELIGHT];
4201 style->base[GTK_STATE_PRELIGHT] = def->base[GTK_STATE_PRELIGHT];
4202 style->bg[GTK_STATE_ACTIVE] = def->bg[GTK_STATE_ACTIVE];
4203 style->base[GTK_STATE_ACTIVE] = def->base[GTK_STATE_ACTIVE];
4204 style->bg[GTK_STATE_INSENSITIVE] = def->bg[GTK_STATE_INSENSITIVE];
4205 style->base[GTK_STATE_INSENSITIVE] = def->base[GTK_STATE_INSENSITIVE];
4206 }
1ecc4d80 4207 }
a81258be
RR		 4208}
4209
1e6feb95 4210void wxWindowGTK::ApplyWidgetStyle()
a81258be 4211{
6de97a3b
RR		 4212}
4213
2259e007
RR		 4214//-----------------------------------------------------------------------------
4215// Pop-up menu stuff
4216//-----------------------------------------------------------------------------
4217
6522713c 4218#if wxUSE_MENUS_NATIVE
1e6feb95 4219
90350682
VZ		 4220extern "C"
4221void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting )
2259e007
RR		 4222{
4223 *is_waiting = FALSE;
4224}
4225
1e6feb95 4226static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win )
30dea054 4227{
1ecc4d80 4228 menu->SetInvokingWindow( win );
1987af7e 4229 wxMenuItemList::Node *node = menu->GetMenuItems().GetFirst();
1ecc4d80
RR		 4230 while (node)
4231 {
1987af7e 4232 wxMenuItem *menuitem = node->GetData();
1ecc4d80
RR		 4233 if (menuitem->IsSubMenu())
4234 {
ff8bfdbb
VZ		 4235 SetInvokingWindow( menuitem->GetSubMenu(), win );
4236 }
1987af7e
VZ		 4237
4238 node = node->GetNext();
1ecc4d80 4239 }
362c6693 4240}
30dea054 4241
e3473203
VZ		 4242// used to pass the coordinates from wxWindowGTK::DoPopupMenu() to
4243// wxPopupMenuPositionCallback()
4244//
4245// should be safe even in the MT case as the user can hardly popup 2 menus
4246// simultaneously, can he?
0c77152e
RR		 4247static gint gs_pop_x = 0;
4248static gint gs_pop_y = 0;
4249
295272bd
VZ		 4250extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu,
4251 gint *x, gint *y,
9e691f46
VZ		 4252#ifdef __WXGTK20__
4253 gboolean * WXUNUSED(whatever),
4254#endif
295272bd 4255 gpointer WXUNUSED(user_data) )
0c77152e 4256{
e3473203
VZ		 4257 // ensure that the menu appears entirely on screen
4258 GtkRequisition req;
4259 gtk_widget_get_child_requisition(GTK_WIDGET(menu), &req);
4260
4261 wxSize sizeScreen = wxGetDisplaySize();
4262
4263 gint xmax = sizeScreen.x - req.width,
4264 ymax = sizeScreen.y - req.height;
4265
4266 *x = gs_pop_x < xmax ? gs_pop_x : xmax;
4267 *y = gs_pop_y < ymax ? gs_pop_y : ymax;
0c77152e
RR		 4268}
4269
1e6feb95 4270bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y )
30dea054 4271{
223d09f6 4272 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
47d67540 4273
223d09f6 4274 wxCHECK_MSG( menu != NULL, FALSE, wxT("invalid popup-menu") );
8bbe427f 4275
1ecc4d80 4276 SetInvokingWindow( menu, this );
ff8bfdbb 4277
631f1bfe
JS		 4278 menu->UpdateUI();
4279
0c77152e
RR		 4280 gs_pop_x = x;
4281 gs_pop_y = y;
e3473203 4282 ClientToScreen( &gs_pop_x, &gs_pop_y );
ff8bfdbb 4283
2259e007 4284 bool is_waiting = TRUE;
148cd9b6 4285
90350682
VZ		 4286 gtk_signal_connect( GTK_OBJECT(menu->m_menu),
4287 "hide",
4288 GTK_SIGNAL_FUNC(gtk_pop_hide_callback),
4289 (gpointer)&is_waiting );
2259e007 4290
1ecc4d80 4291 gtk_menu_popup(
47d67540 4292 GTK_MENU(menu->m_menu),
e3473203
VZ		 4293 (GtkWidget *) NULL, // parent menu shell
4294 (GtkWidget *) NULL, // parent menu item
4295 wxPopupMenuPositionCallback, // function to position it
4296 NULL, // client data
4297 0, // button used to activate it
4298 gs_timeLastClick // the time of activation
47d67540 4299 );
148cd9b6 4300
956dbab1
RR		 4301 while (is_waiting)
4302 {
4303 while (gtk_events_pending())
4304 gtk_main_iteration();
4305 }
2259e007 4306
1ecc4d80 4307 return TRUE;
30dea054
RR		 4308}
4309
6522713c 4310#endif // wxUSE_MENUS_NATIVE
1e6feb95 4311
06cfab17 4312#if wxUSE_DRAG_AND_DROP
ac57418f 4313
1e6feb95 4314void wxWindowGTK::SetDropTarget( wxDropTarget *dropTarget )
c801d85f 4315{
223d09f6 4316 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 4317
1ecc4d80 4318 GtkWidget *dnd_widget = GetConnectWidget();
47d67540 4319
1ecc4d80 4320 if (m_dropTarget) m_dropTarget->UnregisterWidget( dnd_widget );
47d67540 4321
1ecc4d80
RR		 4322 if (m_dropTarget) delete m_dropTarget;
4323 m_dropTarget = dropTarget;
47d67540 4324
1ecc4d80 4325 if (m_dropTarget) m_dropTarget->RegisterWidget( dnd_widget );
362c6693 4326}
c801d85f 4327
f03fc89f 4328#endif // wxUSE_DRAG_AND_DROP
ac57418f 4329
1e6feb95 4330GtkWidget* wxWindowGTK::GetConnectWidget()
e3e65dac 4331{
1ecc4d80
RR		 4332 GtkWidget *connect_widget = m_widget;
4333 if (m_wxwindow) connect_widget = m_wxwindow;
47d67540 4334
1ecc4d80 4335 return connect_widget;
e3e65dac 4336}
47d67540 4337
1e6feb95 4338bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window )
903f689b 4339{
148cd9b6 4340 if (m_wxwindow)
da048e3d 4341 return (window == GTK_PIZZA(m_wxwindow)->bin_window);
148cd9b6 4342
1ecc4d80 4343 return (window == m_widget->window);
903f689b
RR		 4344}
4345
1e6feb95 4346bool wxWindowGTK::SetFont( const wxFont &font )
c801d85f 4347{
223d09f6 4348 wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") );
c801d85f 4349
739730ca
RR		 4350 if (!wxWindowBase::SetFont(font))
4351 {
454e2a22 4352 return FALSE;
739730ca 4353 }
9c288e4d 4354
a756f210 4355 wxColour sysbg = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
f03fc89f 4356 if ( sysbg == m_backgroundColour )
ae0bdb01
RR		 4357 {
4358 m_backgroundColour = wxNullColour;
4359 ApplyWidgetStyle();
ff8bfdbb
VZ		 4360 m_backgroundColour = sysbg;
4361 }
ae0bdb01
RR		 4362 else
4363 {
4364 ApplyWidgetStyle();
4365 }
c801d85f 4366
f03fc89f 4367 return TRUE;
362c6693 4368}
c801d85f 4369
94633ad9 4370void wxWindowGTK::DoCaptureMouse()
c801d85f 4371{
b231914f
VZ		 4372 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4373
ed673c6a 4374 GdkWindow *window = (GdkWindow*) NULL;
b231914f
VZ		 4375 if (m_wxwindow)
4376 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a 4377 else
b231914f 4378 window = GetConnectWidget()->window;
148cd9b6 4379
e4606ed9 4380 wxCHECK_RET( window, _T("CaptureMouse() failed") );
c50f1fb9 4381
b231914f 4382 wxCursor* cursor = & m_cursor;
cca602ac
JS		 4383 if (!cursor->Ok())
4384 cursor = wxSTANDARD_CURSOR;
4385
ed673c6a 4386 gdk_pointer_grab( window, FALSE,
1ecc4d80
RR		 4387 (GdkEventMask)
4388 (GDK_BUTTON_PRESS_MASK |
4389 GDK_BUTTON_RELEASE_MASK |
148cd9b6 4390 GDK_POINTER_MOTION_HINT_MASK |
1ecc4d80 4391 GDK_POINTER_MOTION_MASK),
ff8bfdbb 4392 (GdkWindow *) NULL,
cca602ac 4393 cursor->GetCursor(),
b02da6b1 4394 (guint32)GDK_CURRENT_TIME );
b231914f 4395 g_captureWindow = this;
1e6feb95 4396 g_captureWindowHasMouse = TRUE;
362c6693 4397}
c801d85f 4398
94633ad9 4399void wxWindowGTK::DoReleaseMouse()
c801d85f 4400{
b231914f
VZ		 4401 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
4402
e4606ed9 4403 wxCHECK_RET( g_captureWindow, wxT("can't release mouse - not captured") );
47d67540 4404
c43430bb
VS		 4405 g_captureWindow = (wxWindowGTK*) NULL;
4406
ed673c6a 4407 GdkWindow *window = (GdkWindow*) NULL;
b231914f
VZ		 4408 if (m_wxwindow)
4409 window = GTK_PIZZA(m_wxwindow)->bin_window;
ed673c6a 4410 else
b231914f 4411 window = GetConnectWidget()->window;
148cd9b6 4412
b02da6b1
VZ		 4413 if (!window)
4414 return;
c50f1fb9 4415
b02da6b1 4416 gdk_pointer_ungrab ( (guint32)GDK_CURRENT_TIME );
362c6693 4417}
c801d85f 4418
1e6feb95
VZ		 4419/* static */
4420wxWindow *wxWindowBase::GetCapture()
4421{
4422 return (wxWindow *)g_captureWindow;
4423}
4424
4425bool wxWindowGTK::IsRetained() const
c801d85f 4426{
1ecc4d80 4427 return FALSE;
362c6693 4428}
c801d85f 4429
1e6feb95 4430void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible,
cb43b372 4431 int range, bool refresh )
c801d85f 4432{
223d09f6 4433 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
8bbe427f 4434
223d09f6 4435 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
c801d85f 4436
1ecc4d80 4437 m_hasScrolling = TRUE;
47d67540 4438
1ecc4d80 4439 if (orient == wxHORIZONTAL)
cb43b372 4440 {
1ecc4d80
RR		 4441 float fpos = (float)pos;
4442 float frange = (float)range;
4443 float fthumb = (float)thumbVisible;
4444 if (fpos > frange-fthumb) fpos = frange-fthumb;
4445 if (fpos < 0.0) fpos = 0.0;
4446
4447 if ((fabs(frange-m_hAdjust->upper) < 0.2) &&
4448 (fabs(fthumb-m_hAdjust->page_size) < 0.2))
4449 {
4450 SetScrollPos( orient, pos, refresh );
4451 return;
4452 }
47d67540 4453
1ecc4d80 4454 m_oldHorizontalPos = fpos;
47d67540 4455
1ecc4d80
RR		 4456 m_hAdjust->lower = 0.0;
4457 m_hAdjust->upper = frange;
4458 m_hAdjust->value = fpos;
4459 m_hAdjust->step_increment = 1.0;
4460 m_hAdjust->page_increment = (float)(wxMax(fthumb,0));
4461 m_hAdjust->page_size = fthumb;
cb43b372 4462 }
1ecc4d80
RR		 4463 else
4464 {
4465 float fpos = (float)pos;
4466 float frange = (float)range;
4467 float fthumb = (float)thumbVisible;
4468 if (fpos > frange-fthumb) fpos = frange-fthumb;
4469 if (fpos < 0.0) fpos = 0.0;
4470
4471 if ((fabs(frange-m_vAdjust->upper) < 0.2) &&
4472 (fabs(fthumb-m_vAdjust->page_size) < 0.2))
4473 {
4474 SetScrollPos( orient, pos, refresh );
4475 return;
4476 }
47d67540 4477
1ecc4d80 4478 m_oldVerticalPos = fpos;
47d67540 4479
1ecc4d80
RR		 4480 m_vAdjust->lower = 0.0;
4481 m_vAdjust->upper = frange;
4482 m_vAdjust->value = fpos;
4483 m_vAdjust->step_increment = 1.0;
4484 m_vAdjust->page_increment = (float)(wxMax(fthumb,0));
4485 m_vAdjust->page_size = fthumb;
4486 }
47d67540 4487
eb082a08
RR		 4488 if (orient == wxHORIZONTAL)
4489 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
4490 else
4491 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
362c6693 4492}
c801d85f 4493
1e6feb95 4494void wxWindowGTK::SetScrollPos( int orient, int pos, bool WXUNUSED(refresh) )
c801d85f 4495{
223d09f6 4496 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
1ecc4d80 4497
223d09f6 4498 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
1ecc4d80
RR		 4499
4500 if (orient == wxHORIZONTAL)
4501 {
4502 float fpos = (float)pos;
4503 if (fpos > m_hAdjust->upper - m_hAdjust->page_size) fpos = m_hAdjust->upper - m_hAdjust->page_size;
4504 if (fpos < 0.0) fpos = 0.0;
4505 m_oldHorizontalPos = fpos;
4506
4507 if (fabs(fpos-m_hAdjust->value) < 0.2) return;
4508 m_hAdjust->value = fpos;
4509 }
4510 else
4511 {
4512 float fpos = (float)pos;
4513 if (fpos > m_vAdjust->upper - m_vAdjust->page_size) fpos = m_vAdjust->upper - m_vAdjust->page_size;
4514 if (fpos < 0.0) fpos = 0.0;
4515 m_oldVerticalPos = fpos;
ff8bfdbb 4516
1ecc4d80
RR		 4517 if (fabs(fpos-m_vAdjust->value) < 0.2) return;
4518 m_vAdjust->value = fpos;
4519 }
47d67540 4520
5b8a521e 4521 if (m_wxwindow->window)
47d67540 4522 {
5b8a521e 4523 if (orient == wxHORIZONTAL)
473d087e
RR		 4524 {
4525 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
4526 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
2daa0ce9 4527
5b8a521e 4528 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
2daa0ce9 4529
473d087e
RR		 4530 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
4531 (GtkSignalFunc) gtk_window_hscroll_callback, (gpointer) this );
4532 }
5b8a521e 4533 else
473d087e
RR		 4534 {
4535 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
4536 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
2daa0ce9 4537
5b8a521e 4538 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
473d087e
RR		 4539
4540 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
4541 (GtkSignalFunc) gtk_window_vscroll_callback, (gpointer) this );
4542 }
cb43b372 4543 }
362c6693 4544}
c801d85f 4545
1e6feb95 4546int wxWindowGTK::GetScrollThumb( int orient ) const
c801d85f 4547{
223d09f6 4548 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 4549
223d09f6 4550 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
47d67540 4551
1ecc4d80
RR		 4552 if (orient == wxHORIZONTAL)
4553 return (int)(m_hAdjust->page_size+0.5);
4554 else
4555 return (int)(m_vAdjust->page_size+0.5);
362c6693 4556}
c801d85f 4557
1e6feb95 4558int wxWindowGTK::GetScrollPos( int orient ) const
c801d85f 4559{
223d09f6 4560 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 4561
223d09f6 4562 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
c801d85f 4563
1ecc4d80
RR		 4564 if (orient == wxHORIZONTAL)
4565 return (int)(m_hAdjust->value+0.5);
4566 else
4567 return (int)(m_vAdjust->value+0.5);
362c6693 4568}
c801d85f 4569
1e6feb95 4570int wxWindowGTK::GetScrollRange( int orient ) const
c801d85f 4571{
223d09f6 4572 wxCHECK_MSG( m_widget != NULL, 0, wxT("invalid window") );
47d67540 4573
223d09f6 4574 wxCHECK_MSG( m_wxwindow != NULL, 0, wxT("window needs client area for scrolling") );
c801d85f 4575
1ecc4d80
RR		 4576 if (orient == wxHORIZONTAL)
4577 return (int)(m_hAdjust->upper+0.5);
4578 else
4579 return (int)(m_vAdjust->upper+0.5);
362c6693 4580}
c801d85f 4581
1e6feb95 4582void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) )
c801d85f 4583{
223d09f6 4584 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
47d67540 4585
223d09f6 4586 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
2b5f62a0 4587
f47ae6e7 4588 // No scrolling requested.
8e217128 4589 if ((dx == 0) && (dy == 0)) return;
0fc5dbf5 4590
4e5a4c69 4591#ifndef __WXGTK20__
35917d22
RR		 4592 if (!m_updateRegion.IsEmpty())
4593 {
4594 m_updateRegion.Offset( dx, dy );
0fc5dbf5 4595
35917d22
RR		 4596 int cw = 0;
4597 int ch = 0;
4598 GetClientSize( &cw, &ch );
4599 m_updateRegion.Intersect( 0, 0, cw, ch );
4600 }
0fc5dbf5 4601
3bcc8d15
RR		 4602 if (!m_clearRegion.IsEmpty())
4603 {
4604 m_clearRegion.Offset( dx, dy );
0fc5dbf5 4605
3bcc8d15
RR		 4606 int cw = 0;
4607 int ch = 0;
4608 GetClientSize( &cw, &ch );
4609 m_clearRegion.Intersect( 0, 0, cw, ch );
4610 }
3fc6e5fa
RR		 4611#endif
4612
b6fa52db 4613 m_clipPaintRegion = TRUE;
0fc5dbf5 4614
da048e3d 4615 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy );
0fc5dbf5 4616
b6fa52db 4617 m_clipPaintRegion = FALSE;
c801d85f 4618}
3723b7b1 4619
4e5a4c69 4620
3723b7b1
JS		 4621// Find the wxWindow at the current mouse position, also returning the mouse
4622// position.
4623wxWindow* wxFindWindowAtPointer(wxPoint& pt)
4624{
59a12e90
JS		 4625 pt = wxGetMousePosition();
4626 wxWindow* found = wxFindWindowAtPoint(pt);
4627 return found;
3723b7b1
JS		 4628}
4629
4630// Get the current mouse position.
4631wxPoint wxGetMousePosition()
4632{
59a12e90
JS		 4633 /* This crashes when used within wxHelpContext,
4634 so we have to use the X-specific implementation below.
4635 gint x, y;
4636 GdkModifierType *mask;
4637 (void) gdk_window_get_pointer(NULL, &x, &y, mask);
4638
4639 return wxPoint(x, y);
4640 */
4641
3723b7b1
JS		 4642 int x, y;
4643 GdkWindow* windowAtPtr = gdk_window_at_pointer(& x, & y);
59a12e90 4644
37d81cc2 4645 Display *display = windowAtPtr ? GDK_WINDOW_XDISPLAY(windowAtPtr) : GDK_DISPLAY();
59a12e90
JS		 4646 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
4647 Window rootReturn, childReturn;
4648 int rootX, rootY, winX, winY;
4649 unsigned int maskReturn;
4650
4651 XQueryPointer (display,
5cd09f0b
RR		 4652 rootWindow,
4653 &rootReturn,
59a12e90
JS		 4654 &childReturn,
4655 &rootX, &rootY, &winX, &winY, &maskReturn);
4656 return wxPoint(rootX, rootY);
4657
3723b7b1
JS		 4658}
4659
4e5a4c69
RR		 4660// ----------------------------------------------------------------------------
4661// wxDCModule
4662// ----------------------------------------------------------------------------
4663
4664class wxWinModule : public wxModule
4665{
4666public:
4667 bool OnInit();
4668 void OnExit();
4669
4670private:
4671 DECLARE_DYNAMIC_CLASS(wxWinModule)
4672};
4673
4674IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
4675
4676bool wxWinModule::OnInit()
4677{
994bc575
RR		 4678 // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() );
4679 // gdk_gc_set_fill( g_eraseGC, GDK_SOLID );
0fc5dbf5 4680
4e5a4c69
RR		 4681 return TRUE;
4682}
4683
4684void wxWinModule::OnExit()
4685{
994bc575
RR		 4686 if (g_eraseGC)
4687 gdk_gc_unref( g_eraseGC );
4e5a4c69
RR		 4688}
4689
6728fb61 4690// vi:sts=4:sw=4:et
wxWidgets (Impactor)