1 /////////////////////////////////////////////////////////////////////////////
4 // Author: Robert Roebling
6 // Copyright: (c) 1998 Robert Roebling, Julian Smart
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
12 #pragma implementation "window.h"
16 #include "wx/window.h"
20 #include "wx/layout.h"
22 #include "wx/dialog.h"
23 #include "wx/msgdlg.h"
25 #if wxUSE_DRAG_AND_DROP
30 #include "wx/tooltip.h"
34 #include "wx/statusbr.h"
36 #include "wx/settings.h"
40 #include "wx/thread.h"
47 #include <gdk/gdkprivate.h>
48 #include <gdk/gdkkeysyms.h>
49 #include <wx/gtk/win_gtk.h>
53 //-----------------------------------------------------------------------------
54 // documentation on internals
55 //-----------------------------------------------------------------------------
58 I have been asked several times about writing some documentation about
59 the GTK port of wxWindows, especially its internal structures. Obviously,
60 you cannot understand wxGTK without knowing a little about the GTK, but
61 some more information about what the wxWindow, which is the base class
62 for all other window classes, does seems required as well.
66 What does wxWindow do? It contains the common interface for the following
67 jobs of its descendants:
69 1) Define the rudimentary behaviour common to all window classes, such as
70 resizing, intercepting user input (so as to make it possible to use these
71 events for special purposes in a derived class), window names etc.
73 2) Provide the possibility to contain and manage children, if the derived
74 class is allowed to contain children, which holds true for those window
75 classes which do not display a native GTK widget. To name them, these
76 classes are wxPanel, wxScrolledWindow, wxDialog, wxFrame. The MDI frame-
77 work classes are a special case and are handled a bit differently from
78 the rest. The same holds true for the wxNotebook class.
80 3) Provide the possibility to draw into a client area of a window. This,
81 too, only holds true for classes that do not display a native GTK widget
84 4) Provide the entire mechanism for scrolling widgets. This actual inter-
85 face for this is usually in wxScrolledWindow, but the GTK implementation
88 5) A multitude of helper or extra methods for special purposes, such as
89 Drag'n'Drop, managing validators etc.
91 6) Display a border (sunken, raised, simple or none).
93 Normally one might expect, that one wxWindows window would always correspond
94 to one GTK widget. Under GTK, there is no such allround widget that has all
95 the functionality. Moreover, the GTK defines a client area as a different
96 widget from the actual widget you are handling. Last but not least some
97 special classes (e.g. wxFrame) handle different categories of widgets and
98 still have the possibility to draw something in the client area.
99 It was therefore required to write a special purpose GTK widget, that would
100 represent a client area in the sense of wxWindows capable to do the jobs
101 2), 3) and 4). I have written this class and it resides in win_gtk.c of
104 All windows must have a widget, with which they interact with other under-
105 lying GTK widgets. It is this widget, e.g. that has to be resized etc and
106 thw wxWindow class has a member variable called m_widget which holds a
107 pointer to this widget. When the window class represents a GTK native widget,
108 this is (in most cases) the only GTK widget the class manages. E.g. the
109 wxStatitText class handles only a GtkLabel widget a pointer to which you
110 can find in m_widget (defined in wxWindow)
112 When the class has a client area for drawing into and for containing children
113 it has to handle the client area widget (of the type GtkPizza, defined in
114 win_gtk.c), but there could be any number of widgets, handled by a class
115 The common rule for all windows is only, that the widget that interacts with
116 the rest of GTK must be referenced in m_widget and all other widgets must be
117 children of this widget on the GTK level. The top-most widget, which also
118 represents the client area, must be in the m_wxwindow field and must be of
121 As I said, the window classes that display a GTK native widget only have
122 one widget, so in the case of e.g. the wxButton class m_widget holds a
123 pointer to a GtkButton widget. But windows with client areas (for drawing
124 and children) have a m_widget field that is a pointer to a GtkScrolled-
125 Window and a m_wxwindow field that is pointer to a GtkPizza and this
126 one is (in the GTK sense) a child of the GtkScrolledWindow.
128 If the m_wxwindow field is set, then all input to this widget is inter-
129 cepted and sent to the wxWindows class. If not, all input to the widget
130 that gets pointed to by m_widget gets intercepted and sent to the class.
134 The design of scrolling in wxWindows is markedly different from that offered
135 by the GTK itself and therefore we cannot simply take it as it is. In GTK,
136 clicking on a scrollbar belonging to scrolled window will inevitably move
137 the window. In wxWindows, the scrollbar will only emit an event, send this
138 to (normally) a wxScrolledWindow and that class will call ScrollWindow()
139 which actually moves the window and its subchildren. Note that GtkPizza
140 memorizes how much it has been scrolled but that wxWindows forgets this
141 so that the two coordinates systems have to be kept in synch. This is done
142 in various places using the pizza->xoffset and pizza->yoffset values.
146 Singularily the most broken code in GTK is the code that is supposes to
147 inform subwindows (child windows) about new positions. Very often, duplicate
148 events are sent without changes in size or position, equally often no
149 events are sent at all (All this is due to a bug in the GtkContainer code
150 which got fixed in GTK 1.2.6). For that reason, wxGTK completely ignores
151 GTK's own system and it simply waits for size events for toplevel windows
152 and then iterates down the respective size events to all window. This has
153 the disadvantage, that windows might get size events before the GTK widget
154 actually has the reported size. This doesn't normally pose any problem, but
155 the OpenGl drawing routines rely on correct behaviour. Therefore, I have
156 added the m_nativeSizeEvents flag, which is true only for the OpenGL canvas,
157 i.e. the wxGLCanvas will emit a size event, when (and not before) the X11
158 window that is used for OpenGl output really has that size (as reported by
163 If someone at some point of time feels the immense desire to have a look at,
164 change or attempt to optimse the Refresh() logic, this person will need an
165 intimate understanding of what a "draw" and what an "expose" events are and
166 what there are used for, in particular when used in connection with GTK's
167 own windowless widgets. Beware.
171 Cursors, too, have been a constant source of pleasure. The main difficulty
172 is that a GdkWindow inherits a cursor if the programmer sets a new cursor
173 for the parent. To prevent this from doing too much harm, I use idle time
174 to set the cursor over and over again, starting from the toplevel windows
175 and ending with the youngest generation (speaking of parent and child windows).
176 Also don't forget that cursors (like much else) are connected to GdkWindows,
177 not GtkWidgets and that the "window" field of a GtkWidget might very well
178 point to the GdkWindow of the parent widget (-> "window less widget") and
179 that the two obviously have very different meanings.
183 //-----------------------------------------------------------------------------
185 //-----------------------------------------------------------------------------
187 extern wxList wxPendingDelete
;
188 extern bool g_blockEventsOnDrag
;
189 extern bool g_blockEventsOnScroll
;
190 extern wxCursor g_globalCursor
;
191 static wxWindow
*g_captureWindow
= (wxWindow
*) NULL
;
193 /* extern */ wxWindow
*g_focusWindow
= (wxWindow
*) NULL
;
195 // if we detect that the app has got/lost the focus, we set this variable to
196 // either TRUE or FALSE and an activate event will be sent during the next
197 // OnIdle() call and it is reset to -1: this value means that we shouldn't
198 // send any activate events at all
199 static int g_sendActivateEvent
= -1;
201 /* hack: we need something to pass to gtk_menu_popup, so we store the time of
202 the last click here */
203 static guint32 gs_timeLastClick
= 0;
205 extern bool g_mainThreadLocked
;
207 //-----------------------------------------------------------------------------
209 //-----------------------------------------------------------------------------
214 # define DEBUG_MAIN_THREAD if (wxThread::IsMain() && g_mainThreadLocked) printf("gui reentrance");
216 # define DEBUG_MAIN_THREAD
219 static gint
gtk_debug_focus_in_callback( GtkWidget
*WXUNUSED(widget
),
220 GdkEvent
*WXUNUSED(event
),
221 const wxChar
*WXUNUSED(name
) )
224 static bool s_done = FALSE;
227 wxLog::AddTraceMask("focus");
230 wxLogTrace(wxT("FOCUS NOW AT: %s"), name);
236 void debug_focus_in( GtkWidget
* widget
, const wxChar
* name
, const wxChar
*window
)
238 // suppress warnings about gtk_debug_focus_in_callback being unused with
243 tmp
+= wxT(" FROM ");
246 wxChar
*s
= new wxChar
[tmp
.Length()+1];
250 gtk_signal_connect( GTK_OBJECT(widget
), "focus_in_event",
251 GTK_SIGNAL_FUNC(gtk_debug_focus_in_callback
), (gpointer
)s
);
256 #define DEBUG_MAIN_THREAD
259 //-----------------------------------------------------------------------------
260 // missing gdk functions
261 //-----------------------------------------------------------------------------
264 gdk_window_warp_pointer (GdkWindow
*window
,
268 GdkWindowPrivate
*priv
;
271 window
= (GdkWindow
*) &gdk_root_parent
;
273 priv
= (GdkWindowPrivate
*) window
;
275 if (!priv
->destroyed
)
277 XWarpPointer (priv
->xdisplay
,
278 None
, /* not source window -> move from anywhere */
279 priv
->xwindow
, /* dest window */
280 0, 0, 0, 0, /* not source window -> move from anywhere */
285 //-----------------------------------------------------------------------------
287 //-----------------------------------------------------------------------------
289 extern void wxapp_install_idle_handler();
290 extern bool g_isIdle
;
292 //-----------------------------------------------------------------------------
293 // local code (see below)
294 //-----------------------------------------------------------------------------
296 static void draw_frame( GtkWidget
*widget
, wxWindow
*win
)
304 if (win
->HasScrolling())
306 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(widget
);
308 GtkRequisition vscroll_req
;
309 vscroll_req
.width
= 2;
310 vscroll_req
.height
= 2;
311 (* GTK_WIDGET_CLASS( GTK_OBJECT(scroll_window
->vscrollbar
)->klass
)->size_request
)
312 (scroll_window
->vscrollbar
, &vscroll_req
);
314 GtkRequisition hscroll_req
;
315 hscroll_req
.width
= 2;
316 hscroll_req
.height
= 2;
317 (* GTK_WIDGET_CLASS( GTK_OBJECT(scroll_window
->hscrollbar
)->klass
)->size_request
)
318 (scroll_window
->hscrollbar
, &hscroll_req
);
320 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(widget
)->klass
);
322 if (scroll_window
->vscrollbar_visible
)
324 dw
+= vscroll_req
.width
;
325 dw
+= scroll_class
->scrollbar_spacing
;
328 if (scroll_window
->hscrollbar_visible
)
330 dh
+= hscroll_req
.height
;
331 dh
+= scroll_class
->scrollbar_spacing
;
337 if (GTK_WIDGET_NO_WINDOW (widget
))
339 dx
+= widget
->allocation
.x
;
340 dy
+= widget
->allocation
.y
;
343 if (win
->HasFlag(wxRAISED_BORDER
))
345 gtk_draw_shadow( widget
->style
,
350 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
354 if (win
->HasFlag(wxSUNKEN_BORDER
))
356 gtk_draw_shadow( widget
->style
,
361 widget
->allocation
.width
-dw
, widget
->allocation
.height
-dh
);
365 if (win
->HasFlag(wxSIMPLE_BORDER
))
368 gc
= gdk_gc_new( widget
->window
);
369 gdk_gc_set_foreground( gc
, &widget
->style
->black
);
370 gdk_draw_rectangle( widget
->window
, gc
, FALSE
,
372 widget
->allocation
.width
-dw
-1, widget
->allocation
.height
-dh
-1 );
378 //-----------------------------------------------------------------------------
379 // "expose_event" of m_widget
380 //-----------------------------------------------------------------------------
382 static void gtk_window_own_expose_callback( GtkWidget
*widget
, GdkEventExpose
*gdk_event
, wxWindow
*win
)
384 if (gdk_event
->count
> 0) return;
385 draw_frame( widget
, win
);
388 //-----------------------------------------------------------------------------
389 // "draw" of m_widget
390 //-----------------------------------------------------------------------------
392 static void gtk_window_own_draw_callback( GtkWidget
*widget
, GdkRectangle
*WXUNUSED(rect
), wxWindow
*win
)
394 draw_frame( widget
, win
);
397 //-----------------------------------------------------------------------------
398 // key code mapping routines
399 //-----------------------------------------------------------------------------
401 static long map_to_unmodified_wx_keysym( KeySym keysym
)
408 case GDK_Shift_R
: key_code
= WXK_SHIFT
; break;
410 case GDK_Control_R
: key_code
= WXK_CONTROL
; break;
416 case GDK_Super_R
: key_code
= WXK_ALT
; break;
417 case GDK_Menu
: key_code
= WXK_MENU
; break;
418 case GDK_Help
: key_code
= WXK_HELP
; break;
419 case GDK_BackSpace
: key_code
= WXK_BACK
; break;
420 case GDK_ISO_Left_Tab
:
421 case GDK_Tab
: key_code
= WXK_TAB
; break;
422 case GDK_Linefeed
: key_code
= WXK_RETURN
; break;
423 case GDK_Clear
: key_code
= WXK_CLEAR
; break;
424 case GDK_Return
: key_code
= WXK_RETURN
; break;
425 case GDK_Pause
: key_code
= WXK_PAUSE
; break;
426 case GDK_Scroll_Lock
: key_code
= WXK_SCROLL
; break;
427 case GDK_Escape
: key_code
= WXK_ESCAPE
; break;
428 case GDK_Delete
: key_code
= WXK_DELETE
; break;
429 case GDK_Home
: key_code
= WXK_HOME
; break;
430 case GDK_Left
: key_code
= WXK_LEFT
; break;
431 case GDK_Up
: key_code
= WXK_UP
; break;
432 case GDK_Right
: key_code
= WXK_RIGHT
; break;
433 case GDK_Down
: key_code
= WXK_DOWN
; break;
434 case GDK_Prior
: key_code
= WXK_PRIOR
; break;
435 // case GDK_Page_Up: key_code = WXK_PAGEUP; break;
436 case GDK_Next
: key_code
= WXK_NEXT
; break;
437 // case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
438 case GDK_End
: key_code
= WXK_END
; break;
439 case GDK_Begin
: key_code
= WXK_HOME
; break;
440 case GDK_Select
: key_code
= WXK_SELECT
; break;
441 case GDK_Print
: key_code
= WXK_PRINT
; break;
442 case GDK_Execute
: key_code
= WXK_EXECUTE
; break;
443 case GDK_Insert
: key_code
= WXK_INSERT
; break;
444 case GDK_Num_Lock
: key_code
= WXK_NUMLOCK
; break;
446 case GDK_KP_0
: key_code
= WXK_NUMPAD0
; break;
447 case GDK_KP_1
: key_code
= WXK_NUMPAD1
; break;
448 case GDK_KP_2
: key_code
= WXK_NUMPAD2
; break;
449 case GDK_KP_3
: key_code
= WXK_NUMPAD3
; break;
450 case GDK_KP_4
: key_code
= WXK_NUMPAD4
; break;
451 case GDK_KP_5
: key_code
= WXK_NUMPAD5
; break;
452 case GDK_KP_6
: key_code
= WXK_NUMPAD6
; break;
453 case GDK_KP_7
: key_code
= WXK_NUMPAD7
; break;
454 case GDK_KP_8
: key_code
= WXK_NUMPAD8
; break;
455 case GDK_KP_9
: key_code
= WXK_NUMPAD9
; break;
456 case GDK_KP_Space
: key_code
= WXK_NUMPAD_SPACE
; break;
457 case GDK_KP_Tab
: key_code
= WXK_NUMPAD_TAB
; break;
458 case GDK_KP_Enter
: key_code
= WXK_NUMPAD_ENTER
; break;
459 case GDK_KP_F1
: key_code
= WXK_NUMPAD_F1
; break;
460 case GDK_KP_F2
: key_code
= WXK_NUMPAD_F2
; break;
461 case GDK_KP_F3
: key_code
= WXK_NUMPAD_F3
; break;
462 case GDK_KP_F4
: key_code
= WXK_NUMPAD_F4
; break;
463 case GDK_KP_Home
: key_code
= WXK_NUMPAD_HOME
; break;
464 case GDK_KP_Left
: key_code
= WXK_NUMPAD_LEFT
; break;
465 case GDK_KP_Up
: key_code
= WXK_NUMPAD_UP
; break;
466 case GDK_KP_Right
: key_code
= WXK_NUMPAD_RIGHT
; break;
467 case GDK_KP_Down
: key_code
= WXK_NUMPAD_DOWN
; break;
468 case GDK_KP_Prior
: key_code
= WXK_NUMPAD_PRIOR
; break;
469 // case GDK_KP_Page_Up: key_code = WXK_NUMPAD_PAGEUP; break;
470 case GDK_KP_Next
: key_code
= WXK_NUMPAD_NEXT
; break;
471 // case GDK_KP_Page_Down: key_code = WXK_NUMPAD_PAGEDOWN; break;
472 case GDK_KP_End
: key_code
= WXK_NUMPAD_END
; break;
473 case GDK_KP_Begin
: key_code
= WXK_NUMPAD_BEGIN
; break;
474 case GDK_KP_Insert
: key_code
= WXK_NUMPAD_INSERT
; break;
475 case GDK_KP_Delete
: key_code
= WXK_NUMPAD_DELETE
; break;
476 case GDK_KP_Equal
: key_code
= WXK_NUMPAD_EQUAL
; break;
477 case GDK_KP_Multiply
: key_code
= WXK_NUMPAD_MULTIPLY
; break;
478 case GDK_KP_Add
: key_code
= WXK_NUMPAD_ADD
; break;
479 case GDK_KP_Separator
: key_code
= WXK_NUMPAD_SEPARATOR
; break;
480 case GDK_KP_Subtract
: key_code
= WXK_NUMPAD_SUBTRACT
; break;
481 case GDK_KP_Decimal
: key_code
= WXK_NUMPAD_DECIMAL
; break;
482 case GDK_KP_Divide
: key_code
= WXK_NUMPAD_DIVIDE
; break;
484 case GDK_F1
: key_code
= WXK_F1
; break;
485 case GDK_F2
: key_code
= WXK_F2
; break;
486 case GDK_F3
: key_code
= WXK_F3
; break;
487 case GDK_F4
: key_code
= WXK_F4
; break;
488 case GDK_F5
: key_code
= WXK_F5
; break;
489 case GDK_F6
: key_code
= WXK_F6
; break;
490 case GDK_F7
: key_code
= WXK_F7
; break;
491 case GDK_F8
: key_code
= WXK_F8
; break;
492 case GDK_F9
: key_code
= WXK_F9
; break;
493 case GDK_F10
: key_code
= WXK_F10
; break;
494 case GDK_F11
: key_code
= WXK_F11
; break;
495 case GDK_F12
: key_code
= WXK_F12
; break;
500 guint upper
= gdk_keyval_to_upper( (guint
)keysym
);
501 keysym
= (upper
!= 0 ? upper
: keysym
); /* to be MSW compatible */
502 key_code
= (guint
)keysym
;
510 static long map_to_wx_keysym( KeySym keysym
)
516 case GDK_Menu
: key_code
= WXK_MENU
; break;
517 case GDK_Help
: key_code
= WXK_HELP
; break;
518 case GDK_BackSpace
: key_code
= WXK_BACK
; break;
519 case GDK_ISO_Left_Tab
:
520 case GDK_Tab
: key_code
= WXK_TAB
; break;
521 case GDK_Linefeed
: key_code
= WXK_RETURN
; break;
522 case GDK_Clear
: key_code
= WXK_CLEAR
; break;
523 case GDK_Return
: key_code
= WXK_RETURN
; break;
524 case GDK_Pause
: key_code
= WXK_PAUSE
; break;
525 case GDK_Scroll_Lock
: key_code
= WXK_SCROLL
; break;
526 case GDK_Escape
: key_code
= WXK_ESCAPE
; break;
527 case GDK_Delete
: key_code
= WXK_DELETE
; break;
528 case GDK_Home
: key_code
= WXK_HOME
; break;
529 case GDK_Left
: key_code
= WXK_LEFT
; break;
530 case GDK_Up
: key_code
= WXK_UP
; break;
531 case GDK_Right
: key_code
= WXK_RIGHT
; break;
532 case GDK_Down
: key_code
= WXK_DOWN
; break;
533 case GDK_Prior
: key_code
= WXK_PRIOR
; break;
534 // case GDK_Page_Up: key_code = WXK_PAGEUP; break;
535 case GDK_Next
: key_code
= WXK_NEXT
; break;
536 // case GDK_Page_Down: key_code = WXK_PAGEDOWN; break;
537 case GDK_End
: key_code
= WXK_END
; break;
538 case GDK_Begin
: key_code
= WXK_HOME
; break;
539 case GDK_Select
: key_code
= WXK_SELECT
; break;
540 case GDK_Print
: key_code
= WXK_PRINT
; break;
541 case GDK_Execute
: key_code
= WXK_EXECUTE
; break;
542 case GDK_Insert
: key_code
= WXK_INSERT
; break;
543 case GDK_Num_Lock
: key_code
= WXK_NUMLOCK
; break;
545 case GDK_KP_0
: key_code
= '0'; break;
546 case GDK_KP_1
: key_code
= '1'; break;
547 case GDK_KP_2
: key_code
= '2'; break;
548 case GDK_KP_3
: key_code
= '3'; break;
549 case GDK_KP_4
: key_code
= '4'; break;
550 case GDK_KP_5
: key_code
= '5'; break;
551 case GDK_KP_6
: key_code
= '6'; break;
552 case GDK_KP_7
: key_code
= '7'; break;
553 case GDK_KP_8
: key_code
= '8'; break;
554 case GDK_KP_9
: key_code
= '9'; break;
555 case GDK_KP_Space
: key_code
= ' '; break;
556 case GDK_KP_Tab
: key_code
= WXK_TAB
; break; /* or '\t' ??? */
557 case GDK_KP_Enter
: key_code
= WXK_RETURN
; break; /* or '\r' ??? */
558 case GDK_KP_F1
: key_code
= WXK_NUMPAD_F1
; break;
559 case GDK_KP_F2
: key_code
= WXK_NUMPAD_F2
; break;
560 case GDK_KP_F3
: key_code
= WXK_NUMPAD_F3
; break;
561 case GDK_KP_F4
: key_code
= WXK_NUMPAD_F4
; break;
562 case GDK_KP_Home
: key_code
= WXK_HOME
; break;
563 case GDK_KP_Left
: key_code
= WXK_LEFT
; break;
564 case GDK_KP_Up
: key_code
= WXK_UP
; break;
565 case GDK_KP_Right
: key_code
= WXK_RIGHT
; break;
566 case GDK_KP_Down
: key_code
= WXK_DOWN
; break;
567 case GDK_KP_Prior
: key_code
= WXK_PRIOR
; break;
568 // case GDK_KP_Page_Up: key_code = WXK_PAGEUP; break;
569 case GDK_KP_Next
: key_code
= WXK_NEXT
; break;
570 // case GDK_KP_Page_Down: key_code = WXK_PAGEDOWN; break;
571 case GDK_KP_End
: key_code
= WXK_END
; break;
572 case GDK_KP_Begin
: key_code
= WXK_HOME
; break;
573 case GDK_KP_Insert
: key_code
= WXK_INSERT
; break;
574 case GDK_KP_Delete
: key_code
= WXK_DELETE
; break;
575 case GDK_KP_Equal
: key_code
= '='; break;
576 case GDK_KP_Multiply
: key_code
= '*'; break;
577 case GDK_KP_Add
: key_code
= '+'; break;
578 case GDK_KP_Separator
: key_code
= ','; break;
579 case GDK_KP_Subtract
: key_code
= '-'; break;
580 case GDK_KP_Decimal
: key_code
= '.'; break;
581 case GDK_KP_Divide
: key_code
= '/'; break;
583 case GDK_F1
: key_code
= WXK_F1
; break;
584 case GDK_F2
: key_code
= WXK_F2
; break;
585 case GDK_F3
: key_code
= WXK_F3
; break;
586 case GDK_F4
: key_code
= WXK_F4
; break;
587 case GDK_F5
: key_code
= WXK_F5
; break;
588 case GDK_F6
: key_code
= WXK_F6
; break;
589 case GDK_F7
: key_code
= WXK_F7
; break;
590 case GDK_F8
: key_code
= WXK_F8
; break;
591 case GDK_F9
: key_code
= WXK_F9
; break;
592 case GDK_F10
: key_code
= WXK_F10
; break;
593 case GDK_F11
: key_code
= WXK_F11
; break;
594 case GDK_F12
: key_code
= WXK_F12
; break;
599 key_code
= (guint
)keysym
;
607 //-----------------------------------------------------------------------------
608 // "expose_event" of m_wxwindow
609 //-----------------------------------------------------------------------------
611 static void gtk_window_expose_callback( GtkWidget
*WXUNUSED(widget
), GdkEventExpose
*gdk_event
, wxWindow
*win
)
618 win
->GetUpdateRegion().Union( gdk_event
->area
.x
,
620 gdk_event
->area
.width
,
621 gdk_event
->area
.height
);
624 wxPrintf( "OnExpose from " );
625 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
626 wxPrintf( win->GetClassInfo()->GetClassName() );
627 wxPrintf( " %d %d %d %d\n", (int)gdk_event->area.x,
628 (int)gdk_event->area.y,
629 (int)gdk_event->area.width,
630 (int)gdk_event->area.height );
633 if (gdk_event
->count
> 0)
636 wxEraseEvent
eevent( win
->GetId() );
637 eevent
.SetEventObject( win
);
638 win
->GetEventHandler()->ProcessEvent(eevent
);
640 wxPaintEvent
event( win
->GetId() );
641 event
.SetEventObject( win
);
642 win
->GetEventHandler()->ProcessEvent( event
);
644 win
->GetUpdateRegion().Clear();
647 //-----------------------------------------------------------------------------
648 // "draw" of m_wxwindow
649 //-----------------------------------------------------------------------------
651 static void gtk_window_draw_callback( GtkWidget
*WXUNUSED(widget
),
652 GdkRectangle
*rect
, wxWindow
*win
)
657 wxapp_install_idle_handler();
662 win
->GetUpdateRegion().Union( rect
->x
, rect
->y
,
663 rect
->width
, rect
->height
);
666 wxPrintf( "OnDraw from " );
667 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
668 printf( win->GetClassInfo()->GetClassName() );
669 wxPrintf( " %d %d %d %d\n", (int)rect->x,
675 wxEraseEvent
eevent( win
->GetId() );
676 eevent
.SetEventObject( win
);
677 win
->GetEventHandler()->ProcessEvent(eevent
);
679 wxPaintEvent
event( win
->GetId() );
680 event
.SetEventObject( win
);
681 win
->GetEventHandler()->ProcessEvent( event
);
683 win
->GetUpdateRegion().Clear();
686 //-----------------------------------------------------------------------------
687 // "key_press_event" from any window
688 //-----------------------------------------------------------------------------
690 static gint
gtk_window_key_press_callback( GtkWidget
*widget
, GdkEventKey
*gdk_event
, wxWindow
*win
)
695 wxapp_install_idle_handler();
697 if (!win
->m_hasVMT
) return FALSE
;
698 if (g_blockEventsOnDrag
) return FALSE
;
702 tmp += (char)gdk_event->keyval;
703 printf( "KeyDown-Code is: %s.\n", tmp.c_str() );
704 printf( "KeyDown-ScanCode is: %d.\n", gdk_event->keyval );
709 GdkModifierType state
;
710 if (gdk_event
->window
) gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
714 long key_code
= map_to_unmodified_wx_keysym( gdk_event
->keyval
);
715 /* sending unknown key events doesn't really make sense */
716 if (key_code
== 0) return FALSE
;
718 wxKeyEvent
event( wxEVT_KEY_DOWN
);
719 event
.SetTimestamp( gdk_event
->time
);
720 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
721 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
722 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
723 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
724 event
.m_keyCode
= key_code
;
725 event
.m_scanCode
= gdk_event
->keyval
;
728 event
.SetEventObject( win
);
729 ret
= win
->GetEventHandler()->ProcessEvent( event
);
734 wxWindow
*ancestor
= win
;
737 int command
= ancestor
->GetAcceleratorTable()->GetCommand( event
);
740 wxCommandEvent
command_event( wxEVT_COMMAND_MENU_SELECTED
, command
);
741 ret
= ancestor
->GetEventHandler()->ProcessEvent( command_event
);
744 if (ancestor
->m_isFrame
)
746 ancestor
= ancestor
->GetParent();
749 #endif // wxUSE_ACCEL
751 /* wxMSW doesn't send char events with Alt pressed */
752 /* Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
753 will only be sent if it is not in an accelerator table. */
754 key_code
= map_to_wx_keysym( gdk_event
->keyval
);
759 wxKeyEvent
event2( wxEVT_CHAR
);
760 event2
.SetTimestamp( gdk_event
->time
);
761 event2
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
762 event2
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
763 event2
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
764 event2
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
765 event2
.m_keyCode
= key_code
;
766 event2
.m_scanCode
= gdk_event
->keyval
;
769 event2
.SetEventObject( win
);
770 ret
= win
->GetEventHandler()->ProcessEvent( event2
);
773 /* win is a control: tab can be propagated up */
775 ((gdk_event
->keyval
== GDK_Tab
) || (gdk_event
->keyval
== GDK_ISO_Left_Tab
)) &&
776 (!win
->HasFlag(wxTE_PROCESS_TAB
)) &&
777 (win
->GetParent()) &&
778 (win
->GetParent()->HasFlag( wxTAB_TRAVERSAL
)) )
780 wxNavigationKeyEvent new_event
;
781 new_event
.SetEventObject( win
);
782 /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
783 new_event
.SetDirection( (gdk_event
->keyval
== GDK_Tab
) );
784 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
785 new_event
.SetWindowChange( (gdk_event
->state
& GDK_CONTROL_MASK
) );
786 new_event
.SetCurrentFocus( win
);
787 ret
= win
->GetEventHandler()->ProcessEvent( new_event
);
790 /* generate wxID_CANCEL if <esc> has been pressed (typically in dialogs) */
792 (gdk_event
->keyval
== GDK_Escape
) )
794 wxCommandEvent
new_event(wxEVT_COMMAND_BUTTON_CLICKED
,wxID_CANCEL
);
795 new_event
.SetEventObject( win
);
796 ret
= win
->GetEventHandler()->ProcessEvent( new_event
);
799 #if (GTK_MINOR_VERSION > 0)
800 /* Pressing F10 will activate the menu bar of the top frame. */
804 (gdk_event->keyval == GDK_F10) )
806 wxWindow *ancestor = win;
809 if (wxIsKindOf(ancestor,wxFrame))
811 wxFrame *frame = (wxFrame*) ancestor;
812 wxMenuBar *menubar = frame->GetMenuBar();
815 wxNode *node = menubar->GetMenus().First();
818 wxMenu *firstMenu = (wxMenu*) node->Data();
819 gtk_menu_item_select( GTK_MENU_ITEM(firstMenu->m_owner) );
825 ancestor = ancestor->GetParent();
833 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_press_event" );
840 //-----------------------------------------------------------------------------
841 // "key_release_event" from any window
842 //-----------------------------------------------------------------------------
844 static gint
gtk_window_key_release_callback( GtkWidget
*widget
, GdkEventKey
*gdk_event
, wxWindow
*win
)
849 wxapp_install_idle_handler();
851 if (!win
->m_hasVMT
) return FALSE
;
852 if (g_blockEventsOnDrag
) return FALSE
;
855 printf( "KeyUp-ScanCode is: %d.\n", gdk_event->keyval );
856 if (gdk_event->state & GDK_SHIFT_MASK)
857 printf( "ShiftDown.\n" );
859 printf( "ShiftUp.\n" );
860 if (gdk_event->state & GDK_CONTROL_MASK)
861 printf( "ControlDown.\n" );
863 printf( "ControlUp.\n" );
867 long key_code
= map_to_unmodified_wx_keysym( gdk_event
->keyval
);
869 /* sending unknown key events doesn't really make sense */
870 if (key_code
== 0) return FALSE
;
874 GdkModifierType state
;
875 if (gdk_event
->window
) gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
877 wxKeyEvent
event( wxEVT_KEY_UP
);
878 event
.SetTimestamp( gdk_event
->time
);
879 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
880 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
881 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
882 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
883 event
.m_keyCode
= key_code
;
884 event
.m_scanCode
= gdk_event
->keyval
;
887 event
.SetEventObject( win
);
889 if (win
->GetEventHandler()->ProcessEvent( event
))
891 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "key_release_event" );
898 //-----------------------------------------------------------------------------
899 // "button_press_event"
900 //-----------------------------------------------------------------------------
902 static gint
gtk_window_button_press_callback( GtkWidget
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
907 wxapp_install_idle_handler();
910 wxPrintf( wxT("1) OnButtonPress from ") );
911 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
912 wxPrintf( win->GetClassInfo()->GetClassName() );
913 wxPrintf( wxT(".\n") );
915 if (!win
->m_hasVMT
) return FALSE
;
916 if (g_blockEventsOnDrag
) return TRUE
;
917 if (g_blockEventsOnScroll
) return TRUE
;
919 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
923 if (GTK_WIDGET_CAN_FOCUS(win
->m_wxwindow
) && !GTK_WIDGET_HAS_FOCUS (win
->m_wxwindow
) )
925 gtk_widget_grab_focus (win
->m_wxwindow
);
928 wxPrintf( wxT("GrabFocus from ") );
929 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
930 wxPrintf( win->GetClassInfo()->GetClassName() );
931 wxPrintf( wxT(".\n") );
937 wxEventType event_type
= wxEVT_LEFT_DOWN
;
939 if (gdk_event
->button
== 1)
941 switch (gdk_event
->type
)
943 case GDK_BUTTON_PRESS
: event_type
= wxEVT_LEFT_DOWN
; break;
944 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_LEFT_DCLICK
; break;
948 else if (gdk_event
->button
== 2)
950 switch (gdk_event
->type
)
952 case GDK_BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DOWN
; break;
953 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_MIDDLE_DCLICK
; break;
957 else if (gdk_event
->button
== 3)
959 switch (gdk_event
->type
)
961 case GDK_BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DOWN
; break;
962 case GDK_2BUTTON_PRESS
: event_type
= wxEVT_RIGHT_DCLICK
; break;
967 wxMouseEvent
event( event_type
);
968 event
.SetTimestamp( gdk_event
->time
);
969 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
970 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
971 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
972 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
973 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
974 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
975 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
977 event
.m_x
= (wxCoord
)gdk_event
->x
;
978 event
.m_y
= (wxCoord
)gdk_event
->y
;
980 // Some control don't have their own X window and thus cannot get
983 if (!g_captureWindow
)
985 wxCoord x
= event
.m_x
;
986 wxCoord y
= event
.m_y
;
989 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
994 wxNode
*node
= win
->GetChildren().First();
997 wxWindow
*child
= (wxWindow
*)node
->Data();
1000 if (!child
->IsShown())
1003 if (child
->m_isStaticBox
)
1005 // wxStaticBox is transparent in the box itself
1006 int xx1
= child
->m_x
;
1007 int yy1
= child
->m_y
;
1008 int xx2
= child
->m_x
+ child
->m_width
;
1009 int yy2
= child
->m_x
+ child
->m_height
;
1012 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
1014 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
1016 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
1018 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
1021 event
.m_x
-= child
->m_x
;
1022 event
.m_y
-= child
->m_y
;
1029 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1030 (child
->m_x
<= x
) &&
1031 (child
->m_y
<= y
) &&
1032 (child
->m_x
+child
->m_width
>= x
) &&
1033 (child
->m_y
+child
->m_height
>= y
))
1036 event
.m_x
-= child
->m_x
;
1037 event
.m_y
-= child
->m_y
;
1044 event
.SetEventObject( win
);
1046 gs_timeLastClick
= gdk_event
->time
;
1049 wxPrintf( wxT("2) OnButtonPress from ") );
1050 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1051 wxPrintf( win->GetClassInfo()->GetClassName() );
1052 wxPrintf( wxT(".\n") );
1055 if (win
->GetEventHandler()->ProcessEvent( event
))
1057 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_press_event" );
1064 //-----------------------------------------------------------------------------
1065 // "button_release_event"
1066 //-----------------------------------------------------------------------------
1068 static gint
gtk_window_button_release_callback( GtkWidget
*widget
, GdkEventButton
*gdk_event
, wxWindow
*win
)
1073 wxapp_install_idle_handler();
1075 if (!win
->m_hasVMT
) return FALSE
;
1076 if (g_blockEventsOnDrag
) return FALSE
;
1077 if (g_blockEventsOnScroll
) return FALSE
;
1079 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1082 printf( "OnButtonRelease from " );
1083 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1084 printf( win->GetClassInfo()->GetClassName() );
1088 wxEventType event_type
= wxEVT_NULL
;
1090 switch (gdk_event
->button
)
1092 case 1: event_type
= wxEVT_LEFT_UP
; break;
1093 case 2: event_type
= wxEVT_MIDDLE_UP
; break;
1094 case 3: event_type
= wxEVT_RIGHT_UP
; break;
1097 wxMouseEvent
event( event_type
);
1098 event
.SetTimestamp( gdk_event
->time
);
1099 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1100 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1101 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1102 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1103 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1104 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1105 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1106 event
.m_x
= (wxCoord
)gdk_event
->x
;
1107 event
.m_y
= (wxCoord
)gdk_event
->y
;
1109 // Some control don't have their own X window and thus cannot get
1112 if (!g_captureWindow
)
1114 wxCoord x
= event
.m_x
;
1115 wxCoord y
= event
.m_y
;
1116 if (win
->m_wxwindow
)
1118 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1119 x
+= pizza
->xoffset
;
1120 y
+= pizza
->yoffset
;
1123 wxNode
*node
= win
->GetChildren().First();
1126 wxWindow
*child
= (wxWindow
*)node
->Data();
1128 node
= node
->Next();
1129 if (!child
->IsShown())
1132 if (child
->m_isStaticBox
)
1134 // wxStaticBox is transparent in the box itself
1135 int xx1
= child
->m_x
;
1136 int yy1
= child
->m_y
;
1137 int xx2
= child
->m_x
+ child
->m_width
;
1138 int yy2
= child
->m_x
+ child
->m_height
;
1141 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
1143 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
1145 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
1147 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
1150 event
.m_x
-= child
->m_x
;
1151 event
.m_y
-= child
->m_y
;
1158 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1159 (child
->m_x
<= x
) &&
1160 (child
->m_y
<= y
) &&
1161 (child
->m_x
+child
->m_width
>= x
) &&
1162 (child
->m_y
+child
->m_height
>= y
))
1165 event
.m_x
-= child
->m_x
;
1166 event
.m_y
-= child
->m_y
;
1173 event
.SetEventObject( win
);
1175 if (win
->GetEventHandler()->ProcessEvent( event
))
1177 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "button_release_event" );
1184 //-----------------------------------------------------------------------------
1185 // "motion_notify_event"
1186 //-----------------------------------------------------------------------------
1188 static gint
gtk_window_motion_notify_callback( GtkWidget
*widget
, GdkEventMotion
*gdk_event
, wxWindow
*win
)
1193 wxapp_install_idle_handler();
1195 if (!win
->m_hasVMT
) return FALSE
;
1196 if (g_blockEventsOnDrag
) return FALSE
;
1197 if (g_blockEventsOnScroll
) return FALSE
;
1199 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1201 if (gdk_event
->is_hint
)
1205 GdkModifierType state
;
1206 gdk_window_get_pointer(gdk_event
->window
, &x
, &y
, &state
);
1212 printf( "OnMotion from " );
1213 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1214 printf( win->GetClassInfo()->GetClassName() );
1218 wxMouseEvent
event( wxEVT_MOTION
);
1219 event
.SetTimestamp( gdk_event
->time
);
1220 event
.m_shiftDown
= (gdk_event
->state
& GDK_SHIFT_MASK
);
1221 event
.m_controlDown
= (gdk_event
->state
& GDK_CONTROL_MASK
);
1222 event
.m_altDown
= (gdk_event
->state
& GDK_MOD1_MASK
);
1223 event
.m_metaDown
= (gdk_event
->state
& GDK_MOD2_MASK
);
1224 event
.m_leftDown
= (gdk_event
->state
& GDK_BUTTON1_MASK
);
1225 event
.m_middleDown
= (gdk_event
->state
& GDK_BUTTON2_MASK
);
1226 event
.m_rightDown
= (gdk_event
->state
& GDK_BUTTON3_MASK
);
1228 event
.m_x
= (wxCoord
)gdk_event
->x
;
1229 event
.m_y
= (wxCoord
)gdk_event
->y
;
1231 // Some control don't have their own X window and thus cannot get
1234 if (!g_captureWindow
)
1236 wxCoord x
= event
.m_x
;
1237 wxCoord y
= event
.m_y
;
1238 if (win
->m_wxwindow
)
1240 GtkPizza
*pizza
= GTK_PIZZA(win
->m_wxwindow
);
1241 x
+= pizza
->xoffset
;
1242 y
+= pizza
->yoffset
;
1245 wxNode
*node
= win
->GetChildren().First();
1248 wxWindow
*child
= (wxWindow
*)node
->Data();
1250 node
= node
->Next();
1251 if (!child
->IsShown())
1254 if (child
->m_isStaticBox
)
1256 // wxStaticBox is transparent in the box itself
1257 int xx1
= child
->m_x
;
1258 int yy1
= child
->m_y
;
1259 int xx2
= child
->m_x
+ child
->m_width
;
1260 int yy2
= child
->m_x
+ child
->m_height
;
1263 if (((x
>= xx1
) && (x
<= xx1
+10) && (y
>= yy1
) && (y
<= yy2
)) ||
1265 ((x
>= xx2
-10) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy2
)) ||
1267 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy1
) && (y
<= yy1
+10)) ||
1269 ((x
>= xx1
) && (x
<= xx2
) && (y
>= yy2
-1) && (y
<= yy2
)))
1272 event
.m_x
-= child
->m_x
;
1273 event
.m_y
-= child
->m_y
;
1280 if ((child
->m_wxwindow
== (GtkWidget
*) NULL
) &&
1281 (child
->m_x
<= x
) &&
1282 (child
->m_y
<= y
) &&
1283 (child
->m_x
+child
->m_width
>= x
) &&
1284 (child
->m_y
+child
->m_height
>= y
))
1287 event
.m_x
-= child
->m_x
;
1288 event
.m_y
-= child
->m_y
;
1295 event
.SetEventObject( win
);
1297 if (win
->GetEventHandler()->ProcessEvent( event
))
1299 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "motion_notify_event" );
1306 //-----------------------------------------------------------------------------
1308 //-----------------------------------------------------------------------------
1310 static gint
gtk_window_focus_in_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
1315 wxapp_install_idle_handler();
1317 if (!win
->m_hasVMT
) return FALSE
;
1318 if (g_blockEventsOnDrag
) return FALSE
;
1320 switch ( g_sendActivateEvent
)
1323 // we've got focus from outside, synthtize wxActivateEvent
1324 g_sendActivateEvent
= 1;
1328 // another our window just lost focus, it was already ours before
1329 // - don't send any wxActivateEvent
1330 g_sendActivateEvent
= -1;
1334 g_focusWindow
= win
;
1337 printf( "OnSetFocus from " );
1338 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1339 printf( win->GetClassInfo()->GetClassName() );
1341 printf( WXSTRINGCAST win->GetLabel() );
1345 wxPanel
*panel
= wxDynamicCast(win
->GetParent(), wxPanel
);
1348 panel
->SetLastFocus(win
);
1353 gdk_im_begin(win
->m_ic
, win
->m_wxwindow
->window
);
1356 wxFocusEvent
event( wxEVT_SET_FOCUS
, win
->GetId() );
1357 event
.SetEventObject( win
);
1359 if (win
->GetEventHandler()->ProcessEvent( event
))
1361 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_in_event" );
1368 //-----------------------------------------------------------------------------
1369 // "focus_out_event"
1370 //-----------------------------------------------------------------------------
1372 static gint
gtk_window_focus_out_callback( GtkWidget
*widget
, GdkEvent
*WXUNUSED(event
), wxWindow
*win
)
1377 wxapp_install_idle_handler();
1379 if (!win
->m_hasVMT
) return FALSE
;
1380 if (g_blockEventsOnDrag
) return FALSE
;
1382 // if the focus goes out of our app alltogether, OnIdle() will send
1383 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
1384 // g_sendActivateEvent to -1
1385 g_sendActivateEvent
= 0;
1387 g_focusWindow
= (wxWindow
*)NULL
;
1390 printf( "OnKillFocus from " );
1391 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
1392 printf( win->GetClassInfo()->GetClassName() );
1401 wxFocusEvent
event( wxEVT_KILL_FOCUS
, win
->GetId() );
1402 event
.SetEventObject( win
);
1404 if (win
->GetEventHandler()->ProcessEvent( event
))
1406 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "focus_out_event" );
1413 //-----------------------------------------------------------------------------
1414 // "enter_notify_event"
1415 //-----------------------------------------------------------------------------
1417 static gint
gtk_window_enter_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
1422 wxapp_install_idle_handler();
1424 if (!win
->m_hasVMT
) return FALSE
;
1425 if (g_blockEventsOnDrag
) return FALSE
;
1427 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1429 wxMouseEvent
event( wxEVT_ENTER_WINDOW
);
1430 #if (GTK_MINOR_VERSION > 0)
1431 event
.SetTimestamp( gdk_event
->time
);
1433 event
.SetEventObject( win
);
1437 GdkModifierType state
= (GdkModifierType
)0;
1439 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1441 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
);
1442 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
);
1443 event
.m_altDown
= (state
& GDK_MOD1_MASK
);
1444 event
.m_metaDown
= (state
& GDK_MOD2_MASK
);
1445 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
);
1446 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
);
1447 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
);
1452 if (win
->GetEventHandler()->ProcessEvent( event
))
1454 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "enter_notify_event" );
1461 //-----------------------------------------------------------------------------
1462 // "leave_notify_event"
1463 //-----------------------------------------------------------------------------
1465 static gint
gtk_window_leave_callback( GtkWidget
*widget
, GdkEventCrossing
*gdk_event
, wxWindow
*win
)
1470 wxapp_install_idle_handler();
1472 if (!win
->m_hasVMT
) return FALSE
;
1473 if (g_blockEventsOnDrag
) return FALSE
;
1475 if (!win
->IsOwnGtkWindow( gdk_event
->window
)) return FALSE
;
1477 wxMouseEvent
event( wxEVT_LEAVE_WINDOW
);
1478 #if (GTK_MINOR_VERSION > 0)
1479 event
.SetTimestamp( gdk_event
->time
);
1481 event
.SetEventObject( win
);
1485 GdkModifierType state
= (GdkModifierType
)0;
1487 gdk_window_get_pointer( widget
->window
, &x
, &y
, &state
);
1489 event
.m_shiftDown
= (state
& GDK_SHIFT_MASK
);
1490 event
.m_controlDown
= (state
& GDK_CONTROL_MASK
);
1491 event
.m_altDown
= (state
& GDK_MOD1_MASK
);
1492 event
.m_metaDown
= (state
& GDK_MOD2_MASK
);
1493 event
.m_leftDown
= (state
& GDK_BUTTON1_MASK
);
1494 event
.m_middleDown
= (state
& GDK_BUTTON2_MASK
);
1495 event
.m_rightDown
= (state
& GDK_BUTTON3_MASK
);
1500 if (win
->GetEventHandler()->ProcessEvent( event
))
1502 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget
), "leave_notify_event" );
1509 //-----------------------------------------------------------------------------
1510 // "value_changed" from m_vAdjust
1511 //-----------------------------------------------------------------------------
1513 static void gtk_window_vscroll_callback( GtkAdjustment
*adjust
, wxWindow
*win
)
1518 wxapp_install_idle_handler();
1520 if (g_blockEventsOnDrag
) return;
1522 if (!win
->m_hasVMT
) return;
1524 float diff
= adjust
->value
- win
->m_oldVerticalPos
;
1525 if (fabs(diff
) < 0.2) return;
1527 win
->m_oldVerticalPos
= adjust
->value
;
1529 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(win
->m_widget
);
1530 GtkRange
*range
= GTK_RANGE( scrolledWindow
->vscrollbar
);
1532 wxEventType command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1533 if (range
->scroll_type
== GTK_SCROLL_STEP_BACKWARD
) command
= wxEVT_SCROLLWIN_LINEUP
;
1534 else if (range
->scroll_type
== GTK_SCROLL_STEP_FORWARD
) command
= wxEVT_SCROLLWIN_LINEDOWN
;
1535 else if (range
->scroll_type
== GTK_SCROLL_PAGE_BACKWARD
) command
= wxEVT_SCROLLWIN_PAGEUP
;
1536 else if (range
->scroll_type
== GTK_SCROLL_PAGE_FORWARD
) command
= wxEVT_SCROLLWIN_PAGEDOWN
;
1538 int value
= (int)(adjust
->value
+0.5);
1540 wxScrollWinEvent
event( command
, value
, wxVERTICAL
);
1541 event
.SetEventObject( win
);
1542 win
->GetEventHandler()->ProcessEvent( event
);
1545 //-----------------------------------------------------------------------------
1546 // "value_changed" from m_hAdjust
1547 //-----------------------------------------------------------------------------
1549 static void gtk_window_hscroll_callback( GtkAdjustment
*adjust
, wxWindow
*win
)
1554 wxapp_install_idle_handler();
1556 if (g_blockEventsOnDrag
) return;
1557 if (!win
->m_hasVMT
) return;
1559 float diff
= adjust
->value
- win
->m_oldHorizontalPos
;
1560 if (fabs(diff
) < 0.2) return;
1562 win
->m_oldHorizontalPos
= adjust
->value
;
1564 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(win
->m_widget
);
1565 GtkRange
*range
= GTK_RANGE( scrolledWindow
->hscrollbar
);
1567 wxEventType command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1568 if (range
->scroll_type
== GTK_SCROLL_STEP_BACKWARD
) command
= wxEVT_SCROLLWIN_LINEUP
;
1569 else if (range
->scroll_type
== GTK_SCROLL_STEP_FORWARD
) command
= wxEVT_SCROLLWIN_LINEDOWN
;
1570 else if (range
->scroll_type
== GTK_SCROLL_PAGE_BACKWARD
) command
= wxEVT_SCROLLWIN_PAGEUP
;
1571 else if (range
->scroll_type
== GTK_SCROLL_PAGE_FORWARD
) command
= wxEVT_SCROLLWIN_PAGEDOWN
;
1573 int value
= (int)(adjust
->value
+0.5);
1575 wxScrollWinEvent
event( command
, value
, wxHORIZONTAL
);
1576 event
.SetEventObject( win
);
1577 win
->GetEventHandler()->ProcessEvent( event
);
1580 //-----------------------------------------------------------------------------
1581 // "changed" from m_vAdjust
1582 //-----------------------------------------------------------------------------
1584 static void gtk_window_vscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1589 wxapp_install_idle_handler();
1591 if (g_blockEventsOnDrag
) return;
1592 if (!win
->m_hasVMT
) return;
1594 wxEventType command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1595 int value
= (int)(win
->m_vAdjust
->value
+0.5);
1597 wxScrollWinEvent
event( command
, value
, wxVERTICAL
);
1598 event
.SetEventObject( win
);
1599 win
->GetEventHandler()->ProcessEvent( event
);
1602 //-----------------------------------------------------------------------------
1603 // "changed" from m_hAdjust
1604 //-----------------------------------------------------------------------------
1606 static void gtk_window_hscroll_change_callback( GtkWidget
*WXUNUSED(widget
), wxWindow
*win
)
1611 wxapp_install_idle_handler();
1613 if (g_blockEventsOnDrag
) return;
1614 if (!win
->m_hasVMT
) return;
1616 wxEventType command
= wxEVT_SCROLLWIN_THUMBTRACK
;
1617 int value
= (int)(win
->m_hAdjust
->value
+0.5);
1619 wxScrollWinEvent
event( command
, value
, wxHORIZONTAL
);
1620 event
.SetEventObject( win
);
1621 win
->GetEventHandler()->ProcessEvent( event
);
1624 //-----------------------------------------------------------------------------
1625 // "button_press_event" from scrollbar
1626 //-----------------------------------------------------------------------------
1628 static gint
gtk_scrollbar_button_press_callback( GtkRange
*WXUNUSED(widget
),
1629 GdkEventButton
*WXUNUSED(gdk_event
),
1635 wxapp_install_idle_handler();
1637 // don't test here as we can release the mouse while being over
1638 // a different window than the slider
1640 // if (gdk_event->window != widget->slider) return FALSE;
1642 win
->SetScrolling( TRUE
);
1647 //-----------------------------------------------------------------------------
1648 // "button_release_event" from scrollbar
1649 //-----------------------------------------------------------------------------
1651 static gint
gtk_scrollbar_button_release_callback( GtkRange
*WXUNUSED(widget
),
1652 GdkEventButton
*WXUNUSED(gdk_event
),
1658 // don't test here as we can release the mouse while being over
1659 // a different window than the slider
1661 // if (gdk_event->window != widget->slider) return FALSE;
1663 win
->SetScrolling( FALSE
);
1668 // ----------------------------------------------------------------------------
1669 // this wxWindowBase function is implemented here (in platform-specific file)
1670 // because it is static and so couldn't be made virtual
1671 // ----------------------------------------------------------------------------
1673 wxWindow
*wxWindowBase::FindFocus()
1675 return g_focusWindow
;
1678 //-----------------------------------------------------------------------------
1679 // "realize" from m_widget
1680 //-----------------------------------------------------------------------------
1682 /* We cannot set colours and fonts before the widget has
1683 been realized, so we do this directly after realization. */
1686 gtk_window_realized_callback( GtkWidget
*WXUNUSED(m_widget
), wxWindow
*win
)
1691 wxapp_install_idle_handler();
1693 if (win
->m_delayedBackgroundColour
)
1694 win
->SetBackgroundColour( win
->GetBackgroundColour() );
1696 if (win
->m_delayedForegroundColour
)
1697 win
->SetForegroundColour( win
->GetForegroundColour() );
1699 wxWindowCreateEvent
event( win
);
1700 event
.SetEventObject( win
);
1701 win
->GetEventHandler()->ProcessEvent( event
);
1706 //-----------------------------------------------------------------------------
1708 //-----------------------------------------------------------------------------
1711 void gtk_window_size_callback( GtkWidget
*widget
,
1712 GtkAllocation
*alloc
,
1716 wxapp_install_idle_handler();
1718 wxSizeEvent
event( win
->GetSize(), win
->GetId() );
1719 event
.SetEventObject( win
);
1720 win
->GetEventHandler()->ProcessEvent( event
);
1725 #define WXUNUSED_UNLESS_XIM(param) param
1727 #define WXUNUSED_UNLESS_XIM(param) WXUNUSED(param)
1730 /* Resize XIM window */
1733 void gtk_wxwindow_size_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
1734 GtkAllocation
* WXUNUSED_UNLESS_XIM(alloc
),
1735 wxWindow
* WXUNUSED_UNLESS_XIM(win
) )
1738 wxapp_install_idle_handler();
1744 if (gdk_ic_get_style (win
->m_ic
) & GDK_IM_PREEDIT_POSITION
)
1748 gdk_window_get_size (widget
->window
, &width
, &height
);
1749 win
->m_icattr
->preedit_area
.width
= width
;
1750 win
->m_icattr
->preedit_area
.height
= height
;
1751 gdk_ic_set_attr (win
->m_ic
, win
->m_icattr
, GDK_IC_PREEDIT_AREA
);
1756 //-----------------------------------------------------------------------------
1757 // "realize" from m_wxwindow
1758 //-----------------------------------------------------------------------------
1760 /* Initialize XIM support */
1763 gtk_wxwindow_realized_callback( GtkWidget
* WXUNUSED_UNLESS_XIM(widget
),
1764 wxWindow
* WXUNUSED_UNLESS_XIM(win
) )
1767 wxapp_install_idle_handler();
1770 if (win
->m_ic
) return FALSE
;
1771 if (!widget
) return FALSE
;
1772 if (!gdk_im_ready()) return FALSE
;
1774 win
->m_icattr
= gdk_ic_attr_new();
1775 if (!win
->m_icattr
) return FALSE
;
1779 GdkColormap
*colormap
;
1780 GdkICAttr
*attr
= win
->m_icattr
;
1781 unsigned attrmask
= GDK_IC_ALL_REQ
;
1783 GdkIMStyle supported_style
= (GdkIMStyle
)
1784 (GDK_IM_PREEDIT_NONE
|
1785 GDK_IM_PREEDIT_NOTHING
|
1786 GDK_IM_PREEDIT_POSITION
|
1787 GDK_IM_STATUS_NONE
|
1788 GDK_IM_STATUS_NOTHING
);
1790 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
1791 supported_style
= (GdkIMStyle
)(supported_style
& ~GDK_IM_PREEDIT_POSITION
);
1793 attr
->style
= style
= gdk_im_decide_style (supported_style
);
1794 attr
->client_window
= widget
->window
;
1796 if ((colormap
= gtk_widget_get_colormap (widget
)) !=
1797 gtk_widget_get_default_colormap ())
1799 attrmask
|= GDK_IC_PREEDIT_COLORMAP
;
1800 attr
->preedit_colormap
= colormap
;
1803 attrmask
|= GDK_IC_PREEDIT_FOREGROUND
;
1804 attrmask
|= GDK_IC_PREEDIT_BACKGROUND
;
1805 attr
->preedit_foreground
= widget
->style
->fg
[GTK_STATE_NORMAL
];
1806 attr
->preedit_background
= widget
->style
->base
[GTK_STATE_NORMAL
];
1808 switch (style
& GDK_IM_PREEDIT_MASK
)
1810 case GDK_IM_PREEDIT_POSITION
:
1811 if (widget
->style
&& widget
->style
->font
->type
!= GDK_FONT_FONTSET
)
1813 g_warning ("over-the-spot style requires fontset");
1817 gdk_window_get_size (widget
->window
, &width
, &height
);
1819 attrmask
|= GDK_IC_PREEDIT_POSITION_REQ
;
1820 attr
->spot_location
.x
= 0;
1821 attr
->spot_location
.y
= height
;
1822 attr
->preedit_area
.x
= 0;
1823 attr
->preedit_area
.y
= 0;
1824 attr
->preedit_area
.width
= width
;
1825 attr
->preedit_area
.height
= height
;
1826 attr
->preedit_fontset
= widget
->style
->font
;
1831 win
->m_ic
= gdk_ic_new (attr
, (GdkICAttributesType
)attrmask
);
1833 if (win
->m_ic
== NULL
)
1834 g_warning ("Can't create input context.");
1837 mask
= gdk_window_get_events (widget
->window
);
1838 mask
= (GdkEventMask
)(mask
| gdk_ic_get_events (win
->m_ic
));
1839 gdk_window_set_events (widget
->window
, mask
);
1841 if (GTK_WIDGET_HAS_FOCUS(widget
))
1842 gdk_im_begin (win
->m_ic
, widget
->window
);
1849 //-----------------------------------------------------------------------------
1850 // InsertChild for wxWindow.
1851 //-----------------------------------------------------------------------------
1853 /* Callback for wxWindow. This very strange beast has to be used because
1854 * C++ has no virtual methods in a constructor. We have to emulate a
1855 * virtual function here as wxNotebook requires a different way to insert
1856 * a child in it. I had opted for creating a wxNotebookPage window class
1857 * which would have made this superfluous (such in the MDI window system),
1858 * but no-one was listening to me... */
1860 static void wxInsertChildInWindow( wxWindow
* parent
, wxWindow
* child
)
1862 /* the window might have been scrolled already, do we
1863 have to adapt the position */
1864 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
1865 child
->m_x
+= pizza
->xoffset
;
1866 child
->m_y
+= pizza
->yoffset
;
1868 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
1869 GTK_WIDGET(child
->m_widget
),
1876 //-----------------------------------------------------------------------------
1878 //-----------------------------------------------------------------------------
1880 wxWindow
* wxGetActiveWindow()
1882 return g_focusWindow
;
1885 //-----------------------------------------------------------------------------
1887 //-----------------------------------------------------------------------------
1889 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
1891 void wxWindow::Init()
1897 m_widget
= (GtkWidget
*) NULL
;
1898 m_wxwindow
= (GtkWidget
*) NULL
;
1908 m_needParent
= TRUE
;
1909 m_isBeingDeleted
= FALSE
;
1912 m_nativeSizeEvent
= FALSE
;
1914 m_hasScrolling
= FALSE
;
1915 m_isScrolling
= FALSE
;
1917 m_hAdjust
= (GtkAdjustment
*) NULL
;
1918 m_vAdjust
= (GtkAdjustment
*) NULL
;
1919 m_oldHorizontalPos
= 0.0;
1920 m_oldVerticalPos
= 0.0;
1923 m_widgetStyle
= (GtkStyle
*) NULL
;
1925 m_insertCallback
= (wxInsertChildFunction
) NULL
;
1927 m_isStaticBox
= FALSE
;
1928 m_isRadioButton
= FALSE
;
1930 m_acceptsFocus
= FALSE
;
1932 m_cursor
= *wxSTANDARD_CURSOR
;
1935 m_ic
= (GdkIC
*) NULL
;
1936 m_icattr
= (GdkICAttr
*) NULL
;
1940 wxWindow::wxWindow()
1945 wxWindow::wxWindow( wxWindow
*parent
, wxWindowID id
,
1946 const wxPoint
&pos
, const wxSize
&size
,
1947 long style
, const wxString
&name
)
1951 Create( parent
, id
, pos
, size
, style
, name
);
1954 bool wxWindow::Create( wxWindow
*parent
, wxWindowID id
,
1955 const wxPoint
&pos
, const wxSize
&size
,
1956 long style
, const wxString
&name
)
1958 if (!PreCreation( parent
, pos
, size
) ||
1959 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
1961 wxFAIL_MSG( wxT("wxWindow creation failed") );
1965 m_insertCallback
= wxInsertChildInWindow
;
1967 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
1968 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
1971 debug_focus_in( m_widget
, wxT("wxWindow::m_widget"), name
);
1974 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
1977 debug_focus_in( scrolledWindow
->hscrollbar
, wxT("wxWindow::hsrcollbar"), name
);
1978 debug_focus_in( scrolledWindow
->vscrollbar
, wxT("wxWindow::vsrcollbar"), name
);
1981 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
1982 scroll_class
->scrollbar_spacing
= 0;
1984 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
1986 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->hscrollbar
) );
1987 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->vscrollbar
) );
1989 m_wxwindow
= gtk_pizza_new();
1992 debug_focus_in( m_wxwindow
, wxT("wxWindow::m_wxwindow"), name
);
1995 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
1997 #if (GTK_MINOR_VERSION > 0)
1998 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2000 if (HasFlag(wxRAISED_BORDER
))
2002 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
2004 else if (HasFlag(wxSUNKEN_BORDER
))
2006 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
2008 else if (HasFlag(wxSIMPLE_BORDER
))
2010 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
2014 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
2016 #else // GTK_MINOR_VERSION == 0
2017 GtkViewport
*viewport
= GTK_VIEWPORT(scrolledWindow
->viewport
);
2019 if (HasFlag(wxRAISED_BORDER
))
2021 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_OUT
);
2023 else if (HasFlag(wxSUNKEN_BORDER
))
2025 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_IN
);
2029 gtk_viewport_set_shadow_type( viewport
, GTK_SHADOW_NONE
);
2031 #endif // GTK_MINOR_VERSION
2033 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
2034 m_acceptsFocus
= TRUE
;
2036 #if (GTK_MINOR_VERSION == 0)
2037 // shut the viewport up
2038 gtk_viewport_set_hadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
2039 gtk_viewport_set_vadjustment( viewport
, (GtkAdjustment
*) gtk_adjustment_new( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0) );
2040 #endif // GTK_MINOR_VERSION == 0
2042 // I _really_ don't want scrollbars in the beginning
2043 m_vAdjust
->lower
= 0.0;
2044 m_vAdjust
->upper
= 1.0;
2045 m_vAdjust
->value
= 0.0;
2046 m_vAdjust
->step_increment
= 1.0;
2047 m_vAdjust
->page_increment
= 1.0;
2048 m_vAdjust
->page_size
= 5.0;
2049 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
2050 m_hAdjust
->lower
= 0.0;
2051 m_hAdjust
->upper
= 1.0;
2052 m_hAdjust
->value
= 0.0;
2053 m_hAdjust
->step_increment
= 1.0;
2054 m_hAdjust
->page_increment
= 1.0;
2055 m_hAdjust
->page_size
= 5.0;
2056 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
2058 // these handlers block mouse events to any window during scrolling such as
2059 // motion events and prevent GTK and wxWindows from fighting over where the
2062 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_press_event",
2063 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2065 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_press_event",
2066 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
2068 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_release_event",
2069 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2071 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_release_event",
2072 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
2074 // these handlers get notified when screen updates are required either when
2075 // scrolling or when the window size (and therefore scrollbar configuration)
2078 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
2079 (GtkSignalFunc
) gtk_window_hscroll_callback
, (gpointer
) this );
2080 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
2081 (GtkSignalFunc
) gtk_window_vscroll_callback
, (gpointer
) this );
2083 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "changed",
2084 (GtkSignalFunc
) gtk_window_hscroll_change_callback
, (gpointer
) this );
2085 gtk_signal_connect(GTK_OBJECT(m_vAdjust
), "changed",
2086 (GtkSignalFunc
) gtk_window_vscroll_change_callback
, (gpointer
) this );
2088 gtk_widget_show( m_wxwindow
);
2091 m_parent
->DoAddChild( this );
2100 wxWindow::~wxWindow()
2102 m_isBeingDeleted
= TRUE
;
2111 m_parent
->RemoveChild( this );
2115 gdk_ic_destroy (m_ic
);
2117 gdk_ic_attr_destroy (m_icattr
);
2122 gtk_style_unref( m_widgetStyle
);
2123 m_widgetStyle
= (GtkStyle
*) NULL
;
2128 gtk_widget_destroy( m_wxwindow
);
2129 m_wxwindow
= (GtkWidget
*) NULL
;
2134 gtk_widget_destroy( m_widget
);
2135 m_widget
= (GtkWidget
*) NULL
;
2139 bool wxWindow::PreCreation( wxWindow
*parent
, const wxPoint
&pos
, const wxSize
&size
)
2141 wxCHECK_MSG( !m_needParent
|| parent
, FALSE
, wxT("Need complete parent.") );
2143 /* this turns -1 into 20 so that a minimal window is
2144 visible even although -1,-1 has been given as the
2145 size of the window. the same trick is used in other
2146 ports and should make debugging easier */
2147 m_width
= WidthDefault(size
.x
);
2148 m_height
= HeightDefault(size
.y
);
2153 /* some reasonable defaults */
2158 m_x
= (gdk_screen_width () - m_width
) / 2;
2159 if (m_x
< 10) m_x
= 10;
2163 m_y
= (gdk_screen_height () - m_height
) / 2;
2164 if (m_y
< 10) m_y
= 10;
2171 void wxWindow::PostCreation()
2173 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2179 /* these get reported to wxWindows -> wxPaintEvent */
2180 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "expose_event",
2181 GTK_SIGNAL_FUNC(gtk_window_expose_callback
), (gpointer
)this );
2183 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "draw",
2184 GTK_SIGNAL_FUNC(gtk_window_draw_callback
), (gpointer
)this );
2187 #if (GTK_MINOR_VERSION > 0)
2188 /* these are called when the "sunken" or "raised" borders are drawn */
2189 gtk_signal_connect( GTK_OBJECT(m_widget
), "expose_event",
2190 GTK_SIGNAL_FUNC(gtk_window_own_expose_callback
), (gpointer
)this );
2192 gtk_signal_connect( GTK_OBJECT(m_widget
), "draw",
2193 GTK_SIGNAL_FUNC(gtk_window_own_draw_callback
), (gpointer
)this );
2197 if (m_wxwindow
&& m_needParent
)
2199 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "focus_in_event",
2200 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
2202 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "focus_out_event",
2203 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
2207 // For dialogs and frames, we are interested mainly in
2208 // m_widget's focus.
2210 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus_in_event",
2211 GTK_SIGNAL_FUNC(gtk_window_focus_in_callback
), (gpointer
)this );
2213 gtk_signal_connect( GTK_OBJECT(m_widget
), "focus_out_event",
2214 GTK_SIGNAL_FUNC(gtk_window_focus_out_callback
), (gpointer
)this );
2217 GtkWidget
*connect_widget
= GetConnectWidget();
2219 ConnectWidget( connect_widget
);
2221 /* We cannot set colours, fonts and cursors before the widget has
2222 been realized, so we do this directly after realization */
2223 gtk_signal_connect( GTK_OBJECT(connect_widget
), "realize",
2224 GTK_SIGNAL_FUNC(gtk_window_realized_callback
), (gpointer
) this );
2228 /* Catch native resize events. */
2229 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2230 GTK_SIGNAL_FUNC(gtk_window_size_callback
), (gpointer
)this );
2232 /* Initialize XIM support. */
2233 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "realize",
2234 GTK_SIGNAL_FUNC(gtk_wxwindow_realized_callback
), (gpointer
) this );
2236 /* And resize XIM window. */
2237 gtk_signal_connect( GTK_OBJECT(m_wxwindow
), "size_allocate",
2238 GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback
), (gpointer
)this );
2244 void wxWindow::ConnectWidget( GtkWidget
*widget
)
2246 gtk_signal_connect( GTK_OBJECT(widget
), "key_press_event",
2247 GTK_SIGNAL_FUNC(gtk_window_key_press_callback
), (gpointer
)this );
2249 gtk_signal_connect( GTK_OBJECT(widget
), "key_release_event",
2250 GTK_SIGNAL_FUNC(gtk_window_key_release_callback
), (gpointer
)this );
2252 gtk_signal_connect( GTK_OBJECT(widget
), "button_press_event",
2253 GTK_SIGNAL_FUNC(gtk_window_button_press_callback
), (gpointer
)this );
2255 gtk_signal_connect( GTK_OBJECT(widget
), "button_release_event",
2256 GTK_SIGNAL_FUNC(gtk_window_button_release_callback
), (gpointer
)this );
2258 gtk_signal_connect( GTK_OBJECT(widget
), "motion_notify_event",
2259 GTK_SIGNAL_FUNC(gtk_window_motion_notify_callback
), (gpointer
)this );
2261 gtk_signal_connect( GTK_OBJECT(widget
), "enter_notify_event",
2262 GTK_SIGNAL_FUNC(gtk_window_enter_callback
), (gpointer
)this );
2264 gtk_signal_connect( GTK_OBJECT(widget
), "leave_notify_event",
2265 GTK_SIGNAL_FUNC(gtk_window_leave_callback
), (gpointer
)this );
2268 bool wxWindow::Destroy()
2270 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2274 return wxWindowBase::Destroy();
2277 void wxWindow::DoMoveWindow(int x
, int y
, int width
, int height
)
2279 gtk_pizza_set_size( GTK_PIZZA(m_parent
->m_wxwindow
), m_widget
, x
, y
, width
, height
);
2282 void wxWindow::DoSetSize( int x
, int y
, int width
, int height
, int sizeFlags
)
2284 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2285 wxASSERT_MSG( (m_parent
!= NULL
), wxT("wxWindow::SetSize requires parent.\n") );
2287 if (m_resizing
) return; /* I don't like recursions */
2290 if (m_parent
->m_wxwindow
== NULL
) /* i.e. wxNotebook */
2292 /* don't set the size for children of wxNotebook, just take the values. */
2300 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2302 if ((sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) == 0)
2304 if (x
!= -1) m_x
= x
+ pizza
->xoffset
;
2305 if (y
!= -1) m_y
= y
+ pizza
->yoffset
;
2306 if (width
!= -1) m_width
= width
;
2307 if (height
!= -1) m_height
= height
;
2311 m_x
= x
+ pizza
->xoffset
;
2312 m_y
= y
+ pizza
->yoffset
;
2317 if ((sizeFlags
& wxSIZE_AUTO_WIDTH
) == wxSIZE_AUTO_WIDTH
)
2319 if (width
== -1) m_width
= 80;
2322 if ((sizeFlags
& wxSIZE_AUTO_HEIGHT
) == wxSIZE_AUTO_HEIGHT
)
2324 if (height
== -1) m_height
= 26;
2327 if ((m_minWidth
!= -1) && (m_width
< m_minWidth
)) m_width
= m_minWidth
;
2328 if ((m_minHeight
!= -1) && (m_height
< m_minHeight
)) m_height
= m_minHeight
;
2329 if ((m_maxWidth
!= -1) && (m_width
> m_maxWidth
)) m_width
= m_maxWidth
;
2330 if ((m_maxHeight
!= -1) && (m_height
> m_maxHeight
)) m_height
= m_maxHeight
;
2333 int bottom_border
= 0;
2335 if (GTK_WIDGET_CAN_DEFAULT(m_widget
))
2337 /* the default button has a border around it */
2342 DoMoveWindow( m_x
-border
,
2345 m_height
+border
+bottom_border
);
2349 wxPrintf( "OnSize sent from " );
2350 if (GetClassInfo() && GetClassInfo()->GetClassName())
2351 wxPrintf( GetClassInfo()->GetClassName() );
2352 wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
2355 if (!m_nativeSizeEvent
)
2357 wxSizeEvent
event( wxSize(m_width
,m_height
), GetId() );
2358 event
.SetEventObject( this );
2359 GetEventHandler()->ProcessEvent( event
);
2365 void wxWindow::OnInternalIdle()
2367 if ( g_sendActivateEvent
!= -1 )
2369 bool activate
= g_sendActivateEvent
!= 0;
2372 g_sendActivateEvent
= -1;
2374 wxActivateEvent
event(wxEVT_ACTIVATE
, activate
, GetId());
2375 event
.SetEventObject(this);
2377 (void)GetEventHandler()->ProcessEvent(event
);
2380 wxCursor cursor
= m_cursor
;
2381 if (g_globalCursor
.Ok()) cursor
= g_globalCursor
;
2385 /* I now set the cursor anew in every OnInternalIdle call
2386 as setting the cursor in a parent window also effects the
2387 windows above so that checking for the current cursor is
2392 GdkWindow
*window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2394 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2396 if (!g_globalCursor
.Ok())
2397 cursor
= *wxSTANDARD_CURSOR
;
2399 window
= m_widget
->window
;
2400 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2401 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2407 GdkWindow
*window
= m_widget
->window
;
2408 if ((window
) && !(GTK_WIDGET_NO_WINDOW(m_widget
)))
2409 gdk_window_set_cursor( window
, cursor
.GetCursor() );
2417 void wxWindow::DoGetSize( int *width
, int *height
) const
2419 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2421 if (width
) (*width
) = m_width
;
2422 if (height
) (*height
) = m_height
;
2425 void wxWindow::DoSetClientSize( int width
, int height
)
2427 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2431 SetSize( width
, height
);
2438 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2440 /* when using GTK 1.2 we set the shadow border size to 2 */
2444 if (HasFlag(wxSIMPLE_BORDER
))
2446 /* when using GTK 1.2 we set the simple border size to 1 */
2453 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
2455 GtkRequisition vscroll_req
;
2456 vscroll_req
.width
= 2;
2457 vscroll_req
.height
= 2;
2458 (* GTK_WIDGET_CLASS( GTK_OBJECT(scroll_window
->vscrollbar
)->klass
)->size_request
)
2459 (scroll_window
->vscrollbar
, &vscroll_req
);
2461 GtkRequisition hscroll_req
;
2462 hscroll_req
.width
= 2;
2463 hscroll_req
.height
= 2;
2464 (* GTK_WIDGET_CLASS( GTK_OBJECT(scroll_window
->hscrollbar
)->klass
)->size_request
)
2465 (scroll_window
->hscrollbar
, &hscroll_req
);
2467 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
2469 if (scroll_window
->vscrollbar_visible
)
2471 dw
+= vscroll_req
.width
;
2472 dw
+= scroll_class
->scrollbar_spacing
;
2475 if (scroll_window
->hscrollbar_visible
)
2477 dh
+= hscroll_req
.height
;
2478 dh
+= scroll_class
->scrollbar_spacing
;
2482 SetSize( width
+dw
, height
+dh
);
2486 void wxWindow::DoGetClientSize( int *width
, int *height
) const
2488 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2492 if (width
) (*width
) = m_width
;
2493 if (height
) (*height
) = m_height
;
2500 if (HasFlag(wxRAISED_BORDER
) || HasFlag(wxSUNKEN_BORDER
))
2502 /* when using GTK 1.2 we set the shadow border size to 2 */
2506 if (HasFlag(wxSIMPLE_BORDER
))
2508 /* when using GTK 1.2 we set the simple border size to 1 */
2515 GtkScrolledWindow
*scroll_window
= GTK_SCROLLED_WINDOW(m_widget
);
2517 GtkRequisition vscroll_req
;
2518 vscroll_req
.width
= 2;
2519 vscroll_req
.height
= 2;
2520 (* GTK_WIDGET_CLASS( GTK_OBJECT(scroll_window
->vscrollbar
)->klass
)->size_request
)
2521 (scroll_window
->vscrollbar
, &vscroll_req
);
2523 GtkRequisition hscroll_req
;
2524 hscroll_req
.width
= 2;
2525 hscroll_req
.height
= 2;
2526 (* GTK_WIDGET_CLASS( GTK_OBJECT(scroll_window
->hscrollbar
)->klass
)->size_request
)
2527 (scroll_window
->hscrollbar
, &hscroll_req
);
2529 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT(m_widget
)->klass
);
2531 if (scroll_window
->vscrollbar_visible
)
2533 dw
+= vscroll_req
.width
;
2534 dw
+= scroll_class
->scrollbar_spacing
;
2537 if (scroll_window
->hscrollbar_visible
)
2539 dh
+= hscroll_req
.height
;
2540 dh
+= scroll_class
->scrollbar_spacing
;
2544 if (width
) (*width
) = m_width
- dw
;
2545 if (height
) (*height
) = m_height
- dh
;
2549 void wxWindow::DoGetPosition( int *x
, int *y
) const
2551 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2555 if (m_parent
&& m_parent
->m_wxwindow
)
2557 GtkPizza
*pizza
= GTK_PIZZA(m_parent
->m_wxwindow
);
2558 dx
= pizza
->xoffset
;
2559 dy
= pizza
->yoffset
;
2562 if (x
) (*x
) = m_x
- dx
;
2563 if (y
) (*y
) = m_y
- dy
;
2566 void wxWindow::DoClientToScreen( int *x
, int *y
) const
2568 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2570 if (!m_widget
->window
) return;
2572 GdkWindow
*source
= (GdkWindow
*) NULL
;
2574 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2576 source
= m_widget
->window
;
2580 gdk_window_get_origin( source
, &org_x
, &org_y
);
2584 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2586 org_x
+= m_widget
->allocation
.x
;
2587 org_y
+= m_widget
->allocation
.y
;
2595 void wxWindow::DoScreenToClient( int *x
, int *y
) const
2597 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2599 if (!m_widget
->window
) return;
2601 GdkWindow
*source
= (GdkWindow
*) NULL
;
2603 source
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2605 source
= m_widget
->window
;
2609 gdk_window_get_origin( source
, &org_x
, &org_y
);
2613 if (GTK_WIDGET_NO_WINDOW (m_widget
))
2615 org_x
+= m_widget
->allocation
.x
;
2616 org_y
+= m_widget
->allocation
.y
;
2624 bool wxWindow::Show( bool show
)
2626 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
2628 if (!wxWindowBase::Show(show
))
2635 gtk_widget_show( m_widget
);
2637 gtk_widget_hide( m_widget
);
2642 bool wxWindow::Enable( bool enable
)
2644 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
2646 if (!wxWindowBase::Enable(enable
))
2652 gtk_widget_set_sensitive( m_widget
, enable
);
2654 gtk_widget_set_sensitive( m_wxwindow
, enable
);
2659 int wxWindow::GetCharHeight() const
2661 wxCHECK_MSG( (m_widget
!= NULL
), 12, wxT("invalid window") );
2663 wxCHECK_MSG( m_font
.Ok(), 12, wxT("invalid font") );
2665 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
2667 return font
->ascent
+ font
->descent
;
2670 int wxWindow::GetCharWidth() const
2672 wxCHECK_MSG( (m_widget
!= NULL
), 8, wxT("invalid window") );
2674 wxCHECK_MSG( m_font
.Ok(), 8, wxT("invalid font") );
2676 GdkFont
*font
= m_font
.GetInternalFont( 1.0 );
2678 return gdk_string_width( font
, "H" );
2681 void wxWindow::GetTextExtent( const wxString
& string
,
2685 int *externalLeading
,
2686 const wxFont
*theFont
) const
2688 wxFont fontToUse
= m_font
;
2689 if (theFont
) fontToUse
= *theFont
;
2691 wxCHECK_RET( fontToUse
.Ok(), wxT("invalid font") );
2693 GdkFont
*font
= fontToUse
.GetInternalFont( 1.0 );
2694 if (x
) (*x
) = gdk_string_width( font
, string
.mbc_str() );
2695 if (y
) (*y
) = font
->ascent
+ font
->descent
;
2696 if (descent
) (*descent
) = font
->descent
;
2697 if (externalLeading
) (*externalLeading
) = 0; // ??
2700 void wxWindow::SetFocus()
2702 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2706 if (!GTK_WIDGET_HAS_FOCUS (m_wxwindow
))
2707 gtk_widget_grab_focus (m_wxwindow
);
2713 if (GTK_WIDGET_CAN_FOCUS(m_widget
) && !GTK_WIDGET_HAS_FOCUS (m_widget
) )
2715 gtk_widget_grab_focus (m_widget
);
2717 else if (GTK_IS_CONTAINER(m_widget
))
2719 gtk_container_focus( GTK_CONTAINER(m_widget
), GTK_DIR_TAB_FORWARD
);
2728 bool wxWindow::AcceptsFocus() const
2730 return m_acceptsFocus
&& wxWindowBase::AcceptsFocus();
2733 bool wxWindow::Reparent( wxWindowBase
*newParentBase
)
2735 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
2737 wxWindow
*oldParent
= m_parent
,
2738 *newParent
= (wxWindow
*)newParentBase
;
2740 wxASSERT( GTK_IS_WIDGET(m_widget
) );
2742 if ( !wxWindowBase::Reparent(newParent
) )
2745 wxASSERT( GTK_IS_WIDGET(m_widget
) );
2747 /* prevent GTK from deleting the widget arbitrarily */
2748 gtk_widget_ref( m_widget
);
2752 gtk_container_remove( GTK_CONTAINER(m_widget
->parent
), m_widget
);
2755 wxASSERT( GTK_IS_WIDGET(m_widget
) );
2759 /* insert GTK representation */
2760 (*(newParent
->m_insertCallback
))(newParent
, this);
2763 /* reverse: prevent GTK from deleting the widget arbitrarily */
2764 gtk_widget_unref( m_widget
);
2769 void wxWindow::DoAddChild(wxWindow
*child
)
2771 wxASSERT_MSG( (m_widget
!= NULL
), wxT("invalid window") );
2773 wxASSERT_MSG( (child
!= NULL
), wxT("invalid child window") );
2775 wxASSERT_MSG( (m_insertCallback
!= NULL
), wxT("invalid child insertion function") );
2780 /* insert GTK representation */
2781 (*m_insertCallback
)(this, child
);
2784 void wxWindow::Raise()
2786 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2788 if (!m_widget
->window
) return;
2790 gdk_window_raise( m_widget
->window
);
2793 void wxWindow::Lower()
2795 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2797 if (!m_widget
->window
) return;
2799 gdk_window_lower( m_widget
->window
);
2802 bool wxWindow::SetCursor( const wxCursor
&cursor
)
2804 wxCHECK_MSG( (m_widget
!= NULL
), FALSE
, wxT("invalid window") );
2806 return wxWindowBase::SetCursor( cursor
);
2809 void wxWindow::WarpPointer( int x
, int y
)
2811 wxCHECK_RET( (m_widget
!= NULL
), wxT("invalid window") );
2813 /* we provide this function ourselves as it is
2814 missing in GDK (top of this file) */
2816 GdkWindow
*window
= (GdkWindow
*) NULL
;
2818 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2820 window
= GetConnectWidget()->window
;
2823 gdk_window_warp_pointer( window
, x
, y
);
2826 void wxWindow::Refresh( bool eraseBackground
, const wxRect
*rect
)
2828 if (!m_widget
) return;
2829 if (!m_widget
->window
) return;
2831 if (eraseBackground
&& m_wxwindow
&& m_wxwindow
->window
)
2835 gdk_window_clear_area( GTK_PIZZA(m_wxwindow
)->bin_window
,
2837 rect
->width
, rect
->height
);
2841 gdk_window_clear( GTK_PIZZA(m_wxwindow
)->bin_window
);
2845 /* there is no GTK equivalent of "draw only, don't clear" so we
2846 invent our own in the GtkPizza widget */
2852 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2853 gboolean old_clear
= pizza
->clear_on_draw
;
2854 gtk_pizza_set_clear( pizza
, FALSE
);
2856 gtk_widget_draw( m_wxwindow
, (GdkRectangle
*) NULL
);
2858 gtk_pizza_set_clear( pizza
, old_clear
);
2861 gtk_widget_draw( m_widget
, (GdkRectangle
*) NULL
);
2865 GdkRectangle gdk_rect
;
2866 gdk_rect
.x
= rect
->x
;
2867 gdk_rect
.y
= rect
->y
;
2868 gdk_rect
.width
= rect
->width
;
2869 gdk_rect
.height
= rect
->height
;
2873 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
2874 gboolean old_clear
= pizza
->clear_on_draw
;
2875 gtk_pizza_set_clear( pizza
, FALSE
);
2877 gtk_widget_draw( m_wxwindow
, &gdk_rect
);
2879 gtk_pizza_set_clear( pizza
, old_clear
);
2882 gtk_widget_draw( m_widget
, &gdk_rect
);
2886 void wxWindow::Clear()
2888 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
2890 if (!m_widget
->window
) return;
2892 if (m_wxwindow
&& m_wxwindow
->window
)
2894 gdk_window_clear( m_wxwindow
->window
);
2899 void wxWindow::DoSetToolTip( wxToolTip
*tip
)
2901 wxWindowBase::DoSetToolTip(tip
);
2904 m_tooltip
->Apply( this );
2907 void wxWindow::ApplyToolTip( GtkTooltips
*tips
, const wxChar
*tip
)
2909 gtk_tooltips_set_tip( tips
, GetConnectWidget(), wxConvCurrent
->cWX2MB(tip
), (gchar
*) NULL
);
2911 #endif // wxUSE_TOOLTIPS
2913 bool wxWindow::SetBackgroundColour( const wxColour
&colour
)
2915 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
2917 if (!wxWindowBase::SetBackgroundColour(colour
))
2919 // don't leave if the GTK widget has just
2921 if (!m_delayedBackgroundColour
) return FALSE
;
2924 GdkWindow
*window
= (GdkWindow
*) NULL
;
2926 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2928 window
= GetConnectWidget()->window
;
2932 // indicate that a new style has been set
2933 // but it couldn't get applied as the
2934 // widget hasn't been realized yet.
2935 m_delayedBackgroundColour
= TRUE
;
2937 // pretend we have done something
2942 (m_backgroundColour
!= wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE
)))
2944 /* wxMSW doesn't clear the window here. I don't do that either to
2945 provide compatibility. call Clear() to do the job. */
2947 m_backgroundColour
.CalcPixel( gdk_window_get_colormap( window
) );
2948 gdk_window_set_background( window
, m_backgroundColour
.GetColor() );
2956 bool wxWindow::SetForegroundColour( const wxColour
&colour
)
2958 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
2960 if (!wxWindowBase::SetForegroundColour(colour
))
2962 // don't leave if the GTK widget has just
2964 if (!m_delayedForegroundColour
) return FALSE
;
2967 GdkWindow
*window
= (GdkWindow
*) NULL
;
2969 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
2971 window
= GetConnectWidget()->window
;
2975 // indicate that a new style has been set
2976 // but it couldn't get applied as the
2977 // widget hasn't been realized yet.
2978 m_delayedForegroundColour
= TRUE
;
2980 // pretend we have done something
2989 GtkStyle
*wxWindow::GetWidgetStyle()
2991 if (m_widgetStyle
) return m_widgetStyle
;
2993 GtkStyle
*def
= gtk_rc_get_style( m_widget
);
2996 def
= gtk_widget_get_default_style();
2998 m_widgetStyle
= gtk_style_copy( def
);
2999 m_widgetStyle
->klass
= def
->klass
;
3001 return m_widgetStyle
;
3004 void wxWindow::SetWidgetStyle()
3006 GtkStyle
*style
= GetWidgetStyle();
3008 if (m_font
!= wxSystemSettings::GetSystemFont( wxSYS_DEFAULT_GUI_FONT
))
3010 gdk_font_unref( style
->font
);
3011 style
->font
= gdk_font_ref( m_font
.GetInternalFont( 1.0 ) );
3014 if (m_foregroundColour
.Ok())
3016 m_foregroundColour
.CalcPixel( gtk_widget_get_colormap( m_widget
) );
3017 if (m_foregroundColour
!= wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNTEXT
))
3019 style
->fg
[GTK_STATE_NORMAL
] = *m_foregroundColour
.GetColor();
3020 style
->fg
[GTK_STATE_PRELIGHT
] = *m_foregroundColour
.GetColor();
3021 style
->fg
[GTK_STATE_ACTIVE
] = *m_foregroundColour
.GetColor();
3025 if (m_backgroundColour
.Ok())
3027 m_backgroundColour
.CalcPixel( gtk_widget_get_colormap( m_widget
) );
3028 if (m_backgroundColour
!= wxSystemSettings::GetSystemColour(wxSYS_COLOUR_BTNFACE
))
3030 style
->bg
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
3031 style
->base
[GTK_STATE_NORMAL
] = *m_backgroundColour
.GetColor();
3032 style
->bg
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
3033 style
->base
[GTK_STATE_PRELIGHT
] = *m_backgroundColour
.GetColor();
3034 style
->bg
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
3035 style
->base
[GTK_STATE_ACTIVE
] = *m_backgroundColour
.GetColor();
3036 style
->bg
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
3037 style
->base
[GTK_STATE_INSENSITIVE
] = *m_backgroundColour
.GetColor();
3042 void wxWindow::ApplyWidgetStyle()
3046 //-----------------------------------------------------------------------------
3047 // Pop-up menu stuff
3048 //-----------------------------------------------------------------------------
3050 static void gtk_pop_hide_callback( GtkWidget
*WXUNUSED(widget
), bool* is_waiting
)
3052 *is_waiting
= FALSE
;
3055 static void SetInvokingWindow( wxMenu
*menu
, wxWindow
*win
)
3057 menu
->SetInvokingWindow( win
);
3058 wxMenuItemList::Node
*node
= menu
->GetMenuItems().GetFirst();
3061 wxMenuItem
*menuitem
= node
->GetData();
3062 if (menuitem
->IsSubMenu())
3064 SetInvokingWindow( menuitem
->GetSubMenu(), win
);
3067 node
= node
->GetNext();
3071 static gint gs_pop_x
= 0;
3072 static gint gs_pop_y
= 0;
3074 static void pop_pos_callback( GtkMenu
* WXUNUSED(menu
),
3078 win
->ClientToScreen( &gs_pop_x
, &gs_pop_y
);
3083 bool wxWindow::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
3085 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
3087 wxCHECK_MSG( menu
!= NULL
, FALSE
, wxT("invalid popup-menu") );
3089 SetInvokingWindow( menu
, this );
3096 bool is_waiting
= TRUE
;
3098 gtk_signal_connect( GTK_OBJECT(menu
->m_menu
), "hide",
3099 GTK_SIGNAL_FUNC(gtk_pop_hide_callback
), (gpointer
)&is_waiting
);
3102 GTK_MENU(menu
->m_menu
),
3103 (GtkWidget
*) NULL
, // parent menu shell
3104 (GtkWidget
*) NULL
, // parent menu item
3105 (GtkMenuPositionFunc
) pop_pos_callback
,
3106 (gpointer
) this, // client data
3107 0, // button used to activate it
3108 gs_timeLastClick
// the time of activation
3113 while (gtk_events_pending())
3114 gtk_main_iteration();
3120 #if wxUSE_DRAG_AND_DROP
3122 void wxWindow::SetDropTarget( wxDropTarget
*dropTarget
)
3124 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3126 GtkWidget
*dnd_widget
= GetConnectWidget();
3128 if (m_dropTarget
) m_dropTarget
->UnregisterWidget( dnd_widget
);
3130 if (m_dropTarget
) delete m_dropTarget
;
3131 m_dropTarget
= dropTarget
;
3133 if (m_dropTarget
) m_dropTarget
->RegisterWidget( dnd_widget
);
3136 #endif // wxUSE_DRAG_AND_DROP
3138 GtkWidget
* wxWindow::GetConnectWidget()
3140 GtkWidget
*connect_widget
= m_widget
;
3141 if (m_wxwindow
) connect_widget
= m_wxwindow
;
3143 return connect_widget
;
3146 bool wxWindow::IsOwnGtkWindow( GdkWindow
*window
)
3149 return (window
== GTK_PIZZA(m_wxwindow
)->bin_window
);
3151 return (window
== m_widget
->window
);
3154 bool wxWindow::SetFont( const wxFont
&font
)
3156 wxCHECK_MSG( m_widget
!= NULL
, FALSE
, wxT("invalid window") );
3158 if (!wxWindowBase::SetFont(font
))
3163 wxColour sysbg
= wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
);
3164 if ( sysbg
== m_backgroundColour
)
3166 m_backgroundColour
= wxNullColour
;
3168 m_backgroundColour
= sysbg
;
3178 void wxWindow::CaptureMouse()
3180 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3182 wxCHECK_RET( g_captureWindow
== NULL
, wxT("CaptureMouse called twice") );
3184 GdkWindow
*window
= (GdkWindow
*) NULL
;
3186 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3188 window
= GetConnectWidget()->window
;
3190 if (!window
) return;
3192 gdk_pointer_grab( window
, FALSE
,
3194 (GDK_BUTTON_PRESS_MASK
|
3195 GDK_BUTTON_RELEASE_MASK
|
3196 GDK_POINTER_MOTION_HINT_MASK
|
3197 GDK_POINTER_MOTION_MASK
),
3199 m_cursor
.GetCursor(),
3200 (guint32
)GDK_CURRENT_TIME
);
3201 g_captureWindow
= this;
3204 void wxWindow::ReleaseMouse()
3206 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3208 wxCHECK_RET( g_captureWindow
, wxT("ReleaseMouse called twice") );
3210 GdkWindow
*window
= (GdkWindow
*) NULL
;
3212 window
= GTK_PIZZA(m_wxwindow
)->bin_window
;
3214 window
= GetConnectWidget()->window
;
3219 gdk_pointer_ungrab ( (guint32
)GDK_CURRENT_TIME
);
3220 g_captureWindow
= (wxWindow
*) NULL
;
3223 bool wxWindow::IsRetained() const
3228 void wxWindow::SetScrollbar( int orient
, int pos
, int thumbVisible
,
3229 int range
, bool refresh
)
3231 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3233 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
3235 m_hasScrolling
= TRUE
;
3237 if (orient
== wxHORIZONTAL
)
3239 float fpos
= (float)pos
;
3240 float frange
= (float)range
;
3241 float fthumb
= (float)thumbVisible
;
3242 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
3243 if (fpos
< 0.0) fpos
= 0.0;
3245 if ((fabs(frange
-m_hAdjust
->upper
) < 0.2) &&
3246 (fabs(fthumb
-m_hAdjust
->page_size
) < 0.2))
3248 SetScrollPos( orient
, pos
, refresh
);
3252 m_oldHorizontalPos
= fpos
;
3254 m_hAdjust
->lower
= 0.0;
3255 m_hAdjust
->upper
= frange
;
3256 m_hAdjust
->value
= fpos
;
3257 m_hAdjust
->step_increment
= 1.0;
3258 m_hAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
3259 m_hAdjust
->page_size
= fthumb
;
3263 float fpos
= (float)pos
;
3264 float frange
= (float)range
;
3265 float fthumb
= (float)thumbVisible
;
3266 if (fpos
> frange
-fthumb
) fpos
= frange
-fthumb
;
3267 if (fpos
< 0.0) fpos
= 0.0;
3269 if ((fabs(frange
-m_vAdjust
->upper
) < 0.2) &&
3270 (fabs(fthumb
-m_vAdjust
->page_size
) < 0.2))
3272 SetScrollPos( orient
, pos
, refresh
);
3276 m_oldVerticalPos
= fpos
;
3278 m_vAdjust
->lower
= 0.0;
3279 m_vAdjust
->upper
= frange
;
3280 m_vAdjust
->value
= fpos
;
3281 m_vAdjust
->step_increment
= 1.0;
3282 m_vAdjust
->page_increment
= (float)(wxMax(fthumb
,0));
3283 m_vAdjust
->page_size
= fthumb
;
3286 if (orient
== wxHORIZONTAL
)
3287 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
3289 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
3292 void wxWindow::SetScrollPos( int orient
, int pos
, bool WXUNUSED(refresh
) )
3294 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3296 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
3298 if (orient
== wxHORIZONTAL
)
3300 float fpos
= (float)pos
;
3301 if (fpos
> m_hAdjust
->upper
- m_hAdjust
->page_size
) fpos
= m_hAdjust
->upper
- m_hAdjust
->page_size
;
3302 if (fpos
< 0.0) fpos
= 0.0;
3303 m_oldHorizontalPos
= fpos
;
3305 if (fabs(fpos
-m_hAdjust
->value
) < 0.2) return;
3306 m_hAdjust
->value
= fpos
;
3310 float fpos
= (float)pos
;
3311 if (fpos
> m_vAdjust
->upper
- m_vAdjust
->page_size
) fpos
= m_vAdjust
->upper
- m_vAdjust
->page_size
;
3312 if (fpos
< 0.0) fpos
= 0.0;
3313 m_oldVerticalPos
= fpos
;
3315 if (fabs(fpos
-m_vAdjust
->value
) < 0.2) return;
3316 m_vAdjust
->value
= fpos
;
3323 if (m_wxwindow
->window
)
3325 if (orient
== wxHORIZONTAL
)
3326 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
3328 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
3335 int wxWindow::GetScrollThumb( int orient
) const
3337 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
3339 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
3341 if (orient
== wxHORIZONTAL
)
3342 return (int)(m_hAdjust
->page_size
+0.5);
3344 return (int)(m_vAdjust
->page_size
+0.5);
3347 int wxWindow::GetScrollPos( int orient
) const
3349 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
3351 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
3353 if (orient
== wxHORIZONTAL
)
3354 return (int)(m_hAdjust
->value
+0.5);
3356 return (int)(m_vAdjust
->value
+0.5);
3359 int wxWindow::GetScrollRange( int orient
) const
3361 wxCHECK_MSG( m_widget
!= NULL
, 0, wxT("invalid window") );
3363 wxCHECK_MSG( m_wxwindow
!= NULL
, 0, wxT("window needs client area for scrolling") );
3365 if (orient
== wxHORIZONTAL
)
3366 return (int)(m_hAdjust
->upper
+0.5);
3368 return (int)(m_vAdjust
->upper
+0.5);
3371 void wxWindow::ScrollWindow( int dx
, int dy
, const wxRect
* WXUNUSED(rect
) )
3373 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
3375 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
3378 printf( "ScrollWindow: %d %d\n", dx, dy );
3381 gtk_pizza_scroll( GTK_PIZZA(m_wxwindow
), -dx
, -dy
);
3386 m_scrollGC = gdk_gc_new( m_wxwindow->window );
3387 gdk_gc_set_exposures( m_scrollGC, TRUE );
3390 wxNode *node = m_children.First();
3393 wxWindow *child = (wxWindow*) node->Data();
3396 child->GetSize( &sx, &sy );
3397 child->SetSize( child->m_x + dx, child->m_y + dy, sx, sy, wxSIZE_ALLOW_MINUS_ONE );
3398 node = node->Next();
3403 GetClientSize( &cw, &ch );
3404 int w = cw - abs(dx);
3405 int h = ch - abs(dy);
3407 if ((h < 0) || (w < 0))
3415 if (dx < 0) s_x = -dx;
3416 if (dy < 0) s_y = -dy;
3419 if (dx > 0) d_x = dx;
3420 if (dy > 0) d_y = dy;
3422 gdk_window_copy_area( m_wxwindow->window, m_scrollGC, d_x, d_y,
3423 m_wxwindow->window, s_x, s_y, w, h );
3426 if (dx < 0) rect.x = cw+dx; else rect.x = 0;
3427 if (dy < 0) rect.y = ch+dy; else rect.y = 0;
3428 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
3429 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
3431 Refresh( TRUE, &rect );
3436 void wxWindow::SetScrolling(bool scroll
)
3438 m_isScrolling
= g_blockEventsOnScroll
= scroll
;