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