]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/toplevel.cpp
projects / wxWidgets.git / blob
? search:


9199f36516d5ef2f972e9ec1bfc65149b43523f4
[wxWidgets.git] / src / gtk / toplevel.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/toplevel.cpp
3 // Purpose:
4 // Author: Robert Roebling
5 // Copyright: (c) 1998 Robert Roebling
6 // Licence: wxWindows licence
7 /////////////////////////////////////////////////////////////////////////////
8
9 // For compilers that support precompilation, includes "wx.h".
10 #include "wx/wxprec.h"
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __VMS
21 #define XIconifyWindow XICONIFYWINDOW
22 #endif
23
24 #include "wx/toplevel.h"
25
26 #ifndef WX_PRECOMP
27 #include "wx/frame.h"
28 #include "wx/icon.h"
29 #include "wx/log.h"
30 #include "wx/app.h"
31 #endif
32
33 #include "wx/evtloop.h"
34 #include "wx/sysopt.h"
35
36 #include <gtk/gtk.h>
37 #ifdef GDK_WINDOWING_X11
38 #include <gdk/gdkx.h>
39 #include <X11/Xatom.h> // XA_CARDINAL
40 #include "wx/unix/utilsx11.h"
41 #endif
42
43 #include "wx/gtk/private.h"
44 #include "wx/gtk/private/gtk2-compat.h"
45 #include "wx/gtk/private/win_gtk.h"
46
47 #if wxUSE_LIBHILDON
48 #include <hildon-widgets/hildon-program.h>
49 #include <hildon-widgets/hildon-window.h>
50 #endif // wxUSE_LIBHILDON
51
52 #if wxUSE_LIBHILDON2
53 #include <hildon/hildon.h>
54 #endif // wxUSE_LIBHILDON2
55
56 // ----------------------------------------------------------------------------
57 // data
58 // ----------------------------------------------------------------------------
59
60 // this is incremented while a modal dialog is shown
61 int wxOpenModalDialogsCount = 0;
62
63 // the frame that is currently active (i.e. its child has focus). It is
64 // used to generate wxActivateEvents
65 static wxTopLevelWindowGTK *g_activeFrame = NULL;
66 static wxTopLevelWindowGTK *g_lastActiveFrame = NULL;
67
68 // if we detect that the app has got/lost the focus, we set this variable to
69 // either TRUE or FALSE and an activate event will be sent during the next
70 // OnIdle() call and it is reset to -1: this value means that we shouldn't
71 // send any activate events at all
72 static int g_sendActivateEvent = -1;
73
74 #ifdef GDK_WINDOWING_X11
75 // Whether _NET_REQUEST_FRAME_EXTENTS support is working
76 static enum {
77 RFE_STATUS_UNKNOWN, RFE_STATUS_WORKING, RFE_STATUS_BROKEN
78 } gs_requestFrameExtentsStatus;
79
80 static bool gs_decorCacheValid;
81 #endif
82
83 //-----------------------------------------------------------------------------
84 // RequestUserAttention related functions
85 //-----------------------------------------------------------------------------
86
87 #ifndef __WXGTK3__
88 static void wxgtk_window_set_urgency_hint (GtkWindow *win,
89 gboolean setting)
90 {
91 #if GTK_CHECK_VERSION(2,7,0)
92 if (gtk_check_version(2,7,0) == NULL)
93 gtk_window_set_urgency_hint(win, setting);
94 else
95 #endif
96 {
97 #ifdef GDK_WINDOWING_X11
98 GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(win));
99 wxCHECK_RET(window, "wxgtk_window_set_urgency_hint: GdkWindow not realized");
100
101 Display* dpy = GDK_WINDOW_XDISPLAY(window);
102 Window xid = GDK_WINDOW_XID(window);
103 XWMHints* wm_hints = XGetWMHints(dpy, xid);
104
105 if (!wm_hints)
106 wm_hints = XAllocWMHints();
107
108 if (setting)
109 wm_hints->flags |= XUrgencyHint;
110 else
111 wm_hints->flags &= ~XUrgencyHint;
112
113 XSetWMHints(dpy, xid, wm_hints);
114 XFree(wm_hints);
115 #endif // GDK_WINDOWING_X11
116 }
117 }
118 #define gtk_window_set_urgency_hint wxgtk_window_set_urgency_hint
119 #endif
120
121 extern "C" {
122 static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
123 {
124 gtk_window_set_urgency_hint(GTK_WINDOW(win->m_widget), false);
125
126 win->m_urgency_hint = -2;
127 return FALSE;
128 }
129 }
130
131 //-----------------------------------------------------------------------------
132 // "focus_in_event"
133 //-----------------------------------------------------------------------------
134
135 extern "C" {
136 static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
137 GdkEvent *WXUNUSED(event),
138 wxTopLevelWindowGTK *win )
139 {
140 switch ( g_sendActivateEvent )
141 {
142 case -1:
143 // we've got focus from outside, synthetize wxActivateEvent
144 g_sendActivateEvent = 1;
145 break;
146
147 case 0:
148 // another our window just lost focus, it was already ours before
149 // - don't send any wxActivateEvent
150 g_sendActivateEvent = -1;
151 break;
152 }
153
154 g_activeFrame = win;
155 g_lastActiveFrame = g_activeFrame;
156
157 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
158
159 // MR: wxRequestUserAttention related block
160 switch( win->m_urgency_hint )
161 {
162 default:
163 g_source_remove( win->m_urgency_hint );
164 // no break, fallthrough to remove hint too
165 case -1:
166 gtk_window_set_urgency_hint(GTK_WINDOW(widget), false);
167 win->m_urgency_hint = -2;
168 break;
169
170 case -2: break;
171 }
172
173 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
174 wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
175 event.SetEventObject(g_activeFrame);
176 g_activeFrame->HandleWindowEvent(event);
177
178 return FALSE;
179 }
180 }
181
182 //-----------------------------------------------------------------------------
183 // "focus_out_event"
184 //-----------------------------------------------------------------------------
185
186 extern "C" {
187 static
188 gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget),
189 GdkEventFocus *WXUNUSED(gdk_event),
190 wxTopLevelWindowGTK * WXUNUSED(win))
191 {
192 // if the focus goes out of our app altogether, OnIdle() will send
193 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
194 // g_sendActivateEvent to -1
195 g_sendActivateEvent = 0;
196
197 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
198
199 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
200
201 if (g_activeFrame)
202 {
203 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
204 wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
205 event.SetEventObject(g_activeFrame);
206 g_activeFrame->HandleWindowEvent(event);
207
208 g_activeFrame = NULL;
209 }
210
211 return FALSE;
212 }
213 }
214
215 // ----------------------------------------------------------------------------
216 // "key_press_event"
217 // ----------------------------------------------------------------------------
218
219 extern "C" {
220 static gboolean
221 wxgtk_tlw_key_press_event(GtkWidget *widget, GdkEventKey *event)
222 {
223 GtkWindow* const window = GTK_WINDOW(widget);
224
225 // By default GTK+ checks for the menu accelerators in this (top level)
226 // window first and then propagates the event to the currently focused
227 // child from where it bubbles up the window parent chain. In wxWidgets,
228 // however, we want the child window to have the event first but still
229 // handle it as an accelerator if it's not processed there, so we need to
230 // customize this by reversing the order of the steps done in the standard
231 // GTK+ gtk_window_key_press_event() handler.
232
233 if ( gtk_window_propagate_key_event(window, event) )
234 return TRUE;
235
236 if ( gtk_window_activate_key(window, event) )
237 return TRUE;
238
239 if (GTK_WIDGET_GET_CLASS(widget)->key_press_event(widget, event))
240 return TRUE;
241
242 return FALSE;
243 }
244 }
245
246 //-----------------------------------------------------------------------------
247 // "size_allocate" from m_wxwindow
248 //-----------------------------------------------------------------------------
249
250 extern "C" {
251 static void
252 size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win)
253 {
254 win->m_useCachedClientSize = true;
255 if (win->m_clientWidth != alloc->width ||
256 win->m_clientHeight != alloc->height)
257 {
258 win->m_clientWidth = alloc->width;
259 win->m_clientHeight = alloc->height;
260
261 GtkAllocation a;
262 gtk_widget_get_allocation(win->m_widget, &a);
263 wxSize size(a.width, a.height);
264 size.x += win->m_decorSize.left + win->m_decorSize.right;
265 size.y += win->m_decorSize.top + win->m_decorSize.bottom;
266 win->m_width = size.x;
267 win->m_height = size.y;
268
269 if (!win->IsIconized())
270 {
271 wxSizeEvent event(size, win->GetId());
272 event.SetEventObject(win);
273 win->HandleWindowEvent(event);
274 }
275 // else the window is currently unmapped, don't generate size events
276 }
277 }
278 }
279
280 //-----------------------------------------------------------------------------
281 // "delete_event"
282 //-----------------------------------------------------------------------------
283
284 extern "C" {
285 static gboolean
286 gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
287 GdkEvent *WXUNUSED(event),
288 wxTopLevelWindowGTK *win )
289 {
290 if (win->IsEnabled() &&
291 (wxOpenModalDialogsCount == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
292 win->IsGrabbed()))
293 win->Close();
294
295 return TRUE;
296 }
297 }
298
299 //-----------------------------------------------------------------------------
300 // "configure_event"
301 //-----------------------------------------------------------------------------
302
303 extern "C" {
304 static gboolean
305 gtk_frame_configure_callback( GtkWidget*,
306 GdkEventConfigure* gdk_event,
307 wxTopLevelWindowGTK *win )
308 {
309 win->GTKConfigureEvent(gdk_event->x, gdk_event->y);
310 return false;
311 }
312 }
313
314 void wxTopLevelWindowGTK::GTKConfigureEvent(int x, int y)
315 {
316 wxPoint point;
317 #ifdef GDK_WINDOWING_X11
318 if (gs_decorCacheValid)
319 {
320 const DecorSize& decorSize = GetCachedDecorSize();
321 point.x = x - decorSize.left;
322 point.y = y - decorSize.top;
323 }
324 else
325 #endif
326 {
327 gtk_window_get_position(GTK_WINDOW(m_widget), &point.x, &point.y);
328 }
329
330 if (m_x != point.x || m_y != point.y)
331 {
332 m_x = point.x;
333 m_y = point.y;
334 wxMoveEvent event(point, GetId());
335 event.SetEventObject(this);
336 HandleWindowEvent(event);
337 }
338 }
339
340 //-----------------------------------------------------------------------------
341 // "realize" from m_widget
342 //-----------------------------------------------------------------------------
343
344 // we cannot the WM hints and icons before the widget has been realized,
345 // so we do this directly after realization
346
347 void wxTopLevelWindowGTK::GTKHandleRealized()
348 {
349 wxNonOwnedWindow::GTKHandleRealized();
350
351 gdk_window_set_decorations(gtk_widget_get_window(m_widget),
352 (GdkWMDecoration)m_gdkDecor);
353 gdk_window_set_functions(gtk_widget_get_window(m_widget),
354 (GdkWMFunction)m_gdkFunc);
355
356 // GTK's shrinking/growing policy
357 if ( !(m_gdkFunc & GDK_FUNC_RESIZE) )
358 gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE);
359 #ifndef __WXGTK3__
360 else
361 gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1);
362 #endif
363
364 const wxIconBundle& icons = GetIcons();
365 if (icons.GetIconCount())
366 SetIcons(icons);
367
368 #ifdef __WXGTK3__
369 if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget)))
370 {
371 // Grip window can end up obscured, probably due to deferred show.
372 // Reset grip to ensure it is visible.
373 gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false);
374 gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true);
375 }
376 #endif
377 }
378
379 //-----------------------------------------------------------------------------
380 // "map_event" from m_widget
381 //-----------------------------------------------------------------------------
382
383 extern "C" {
384 static gboolean
385 gtk_frame_map_callback( GtkWidget*,
386 GdkEvent * WXUNUSED(event),
387 wxTopLevelWindow *win )
388 {
389 const bool wasIconized = win->IsIconized();
390 if (wasIconized)
391 {
392 // Because GetClientSize() returns (0,0) when IsIconized() is true,
393 // a size event must be generated, just in case GetClientSize() was
394 // called while iconized. This specifically happens when restoring a
395 // tlw that was "rolled up" with some WMs.
396 // Queue a resize rather than sending size event directly to allow
397 // children to be made visible first.
398 win->m_useCachedClientSize = false;
399 win->m_clientWidth = 0;
400 gtk_widget_queue_resize(win->m_wxwindow);
401 }
402 // it is possible for m_isShown to be false here, see bug #9909
403 if (win->wxWindowBase::Show(true))
404 {
405 wxShowEvent eventShow(win->GetId(), true);
406 eventShow.SetEventObject(win);
407 win->GetEventHandler()->ProcessEvent(eventShow);
408 }
409
410 // restore focus-on-map setting in case ShowWithoutActivating() was called
411 gtk_window_set_focus_on_map(GTK_WINDOW(win->m_widget), true);
412
413 return false;
414 }
415 }
416
417 //-----------------------------------------------------------------------------
418 // "window-state-event" from m_widget
419 //-----------------------------------------------------------------------------
420
421 extern "C" {
422 static gboolean
423 gtk_frame_window_state_callback( GtkWidget* WXUNUSED(widget),
424 GdkEventWindowState *event,
425 wxTopLevelWindow *win )
426 {
427 if (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED)
428 win->SetIconizeState((event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) != 0);
429
430 // if maximized bit changed and it is now set
431 if (event->changed_mask & event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED)
432 {
433 wxMaximizeEvent evt(win->GetId());
434 evt.SetEventObject(win);
435 win->HandleWindowEvent(evt);
436 }
437
438 if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
439 win->m_fsIsShowing = (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) != 0;
440
441 return false;
442 }
443 }
444
445 //-----------------------------------------------------------------------------
446
447 bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom)
448 {
449 #ifdef GDK_WINDOWING_X11
450 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
451 GdkDisplay* display = gdk_window_get_display(window);
452 Atom xproperty = gdk_x11_atom_to_xatom_for_display(display, property);
453 Atom type;
454 int format;
455 gulong nitems, bytes_after;
456 guchar* data;
457 Status status = XGetWindowProperty(
458 GDK_DISPLAY_XDISPLAY(display),
459 GDK_WINDOW_XID(window),
460 xproperty,
461 0, 4, false, XA_CARDINAL,
462 &type, &format, &nitems, &bytes_after, &data);
463 const bool success = status == Success && data && nitems == 4;
464 if (success)
465 {
466 long* p = (long*)data;
467 if (left) *left = int(p[0]);
468 if (right) *right = int(p[1]);
469 if (top) *top = int(p[2]);
470 if (bottom) *bottom = int(p[3]);
471 }
472 if (data)
473 XFree(data);
474 return success;
475 #else
476 return false;
477 #endif
478 }
479
480 #ifdef GDK_WINDOWING_X11
481 //-----------------------------------------------------------------------------
482 // "property_notify_event" from m_widget
483 //-----------------------------------------------------------------------------
484
485 extern "C" {
486 static gboolean property_notify_event(
487 GtkWidget*, GdkEventProperty* event, wxTopLevelWindowGTK* win)
488 {
489 // Watch for changes to _NET_FRAME_EXTENTS property
490 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
491 if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property)
492 {
493 if (win->m_netFrameExtentsTimerId)
494 {
495 // WM support for _NET_REQUEST_FRAME_EXTENTS is working
496 gs_requestFrameExtentsStatus = RFE_STATUS_WORKING;
497 g_source_remove(win->m_netFrameExtentsTimerId);
498 win->m_netFrameExtentsTimerId = 0;
499 }
500
501 wxTopLevelWindowGTK::DecorSize decorSize = win->m_decorSize;
502 gs_decorCacheValid = wxGetFrameExtents(event->window,
503 &decorSize.left, &decorSize.right, &decorSize.top, &decorSize.bottom);
504
505 win->GTKUpdateDecorSize(decorSize);
506 }
507 return false;
508 }
509 }
510
511 extern "C" {
512 static gboolean request_frame_extents_timeout(void* data)
513 {
514 // WM support for _NET_REQUEST_FRAME_EXTENTS is broken
515 gs_requestFrameExtentsStatus = RFE_STATUS_BROKEN;
516 gdk_threads_enter();
517 wxTopLevelWindowGTK* win = static_cast<wxTopLevelWindowGTK*>(data);
518 win->m_netFrameExtentsTimerId = 0;
519 wxTopLevelWindowGTK::DecorSize decorSize = win->m_decorSize;
520 wxGetFrameExtents(gtk_widget_get_window(win->m_widget),
521 &decorSize.left, &decorSize.right, &decorSize.top, &decorSize.bottom);
522 win->GTKUpdateDecorSize(decorSize);
523 gdk_threads_leave();
524 return false;
525 }
526 }
527 #endif // GDK_WINDOWING_X11
528
529 // ----------------------------------------------------------------------------
530 // wxTopLevelWindowGTK creation
531 // ----------------------------------------------------------------------------
532
533 void wxTopLevelWindowGTK::Init()
534 {
535 m_mainWidget = NULL;
536 m_isIconized = false;
537 m_fsIsShowing = false;
538 m_themeEnabled = true;
539 m_gdkDecor =
540 m_gdkFunc = 0;
541 m_grabbed = false;
542 m_deferShow = true;
543 m_deferShowAllowed = true;
544 m_updateDecorSize = true;
545 m_netFrameExtentsTimerId = 0;
546 m_incWidth = m_incHeight = 0;
547 memset(&m_decorSize, 0, sizeof(m_decorSize));
548
549 m_urgency_hint = -2;
550 }
551
552 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
553 wxWindowID id,
554 const wxString& title,
555 const wxPoint& pos,
556 const wxSize& sizeOrig,
557 long style,
558 const wxString &name )
559 {
560 // always create a frame of some reasonable, even if arbitrary, size (at
561 // least for MSW compatibility)
562 wxSize size = sizeOrig;
563 size.x = WidthDefault(size.x);
564 size.y = HeightDefault(size.y);
565
566 wxTopLevelWindows.Append( this );
567
568 if (!PreCreation( parent, pos, size ) ||
569 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
570 {
571 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
572 return false;
573 }
574
575 m_title = title;
576
577 // NB: m_widget may be !=NULL if it was created by derived class' Create,
578 // e.g. in wxTaskBarIconAreaGTK
579 if (m_widget == NULL)
580 {
581 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
582 // we must create HildonWindow and not a normal GtkWindow as the latter
583 // doesn't look correctly in Maemo environment and it must also be
584 // registered with the main program object
585 m_widget = hildon_window_new();
586 hildon_program_add_window(wxTheApp->GetHildonProgram(),
587 HILDON_WINDOW(m_widget));
588 #else // !wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
589 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
590 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
591 {
592 // Tell WM that this is a dialog window and make it center
593 // on parent by default (this is what GtkDialog ctor does):
594 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
595 GDK_WINDOW_TYPE_HINT_DIALOG);
596 gtk_window_set_position(GTK_WINDOW(m_widget),
597 GTK_WIN_POS_CENTER_ON_PARENT);
598 }
599 else
600 {
601 if (style & wxFRAME_TOOL_WINDOW)
602 {
603 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
604 GDK_WINDOW_TYPE_HINT_UTILITY);
605
606 // On some WMs, like KDE, a TOOL_WINDOW will still show
607 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
608 // For consistency between WMs and with Windows, we
609 // should set the NO_TASKBAR flag which will apply
610 // the set_skip_taskbar_hint if it is available,
611 // ensuring no taskbar entry will appear.
612 style |= wxFRAME_NO_TASKBAR;
613 }
614 }
615 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
616
617 g_object_ref(m_widget);
618 }
619
620 wxWindow *topParent = wxGetTopLevelParent(m_parent);
621 if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
622 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
623 (style & wxFRAME_FLOAT_ON_PARENT)))
624 {
625 gtk_window_set_transient_for( GTK_WINDOW(m_widget),
626 GTK_WINDOW(topParent->m_widget) );
627 }
628
629 if (style & wxFRAME_NO_TASKBAR)
630 {
631 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
632 }
633
634 if (style & wxSTAY_ON_TOP)
635 {
636 gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
637 }
638 if (style & wxMAXIMIZE)
639 gtk_window_maximize(GTK_WINDOW(m_widget));
640
641 #if 0
642 if (!name.empty())
643 gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
644 #endif
645
646 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
647 gtk_widget_set_can_focus(m_widget, false);
648
649 g_signal_connect (m_widget, "delete_event",
650 G_CALLBACK (gtk_frame_delete_callback), this);
651
652 // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
653 m_mainWidget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
654 gtk_widget_show( m_mainWidget );
655 gtk_widget_set_can_focus(m_mainWidget, false);
656 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
657
658 // m_wxwindow is the client area
659 m_wxwindow = wxPizza::New();
660 gtk_widget_show( m_wxwindow );
661 gtk_box_pack_start(GTK_BOX(m_mainWidget), m_wxwindow, true, true, 0);
662
663 // we donm't allow the frame to get the focus as otherwise
664 // the frame will grab it at arbitrary focus changes
665 gtk_widget_set_can_focus(m_wxwindow, false);
666
667 if (m_parent) m_parent->AddChild( this );
668
669 g_signal_connect(m_wxwindow, "size_allocate",
670 G_CALLBACK(size_allocate), this);
671
672 PostCreation();
673
674 #ifndef __WXGTK3__
675 if ((m_x != -1) || (m_y != -1))
676 gtk_widget_set_uposition( m_widget, m_x, m_y );
677 #endif
678
679 // for some reported size corrections
680 g_signal_connect (m_widget, "map_event",
681 G_CALLBACK (gtk_frame_map_callback), this);
682
683 // for iconized state
684 g_signal_connect (m_widget, "window_state_event",
685 G_CALLBACK (gtk_frame_window_state_callback), this);
686
687
688 // for wxMoveEvent
689 g_signal_connect (m_widget, "configure_event",
690 G_CALLBACK (gtk_frame_configure_callback), this);
691
692 // activation
693 g_signal_connect_after (m_widget, "focus_in_event",
694 G_CALLBACK (gtk_frame_focus_in_callback), this);
695 g_signal_connect_after (m_widget, "focus_out_event",
696 G_CALLBACK (gtk_frame_focus_out_callback), this);
697
698 // We need to customize the default GTK+ logic for key processing to make
699 // it conforming to wxWidgets event processing order.
700 g_signal_connect (m_widget, "key_press_event",
701 G_CALLBACK (wxgtk_tlw_key_press_event), NULL);
702
703 #ifdef GDK_WINDOWING_X11
704 #ifdef __WXGTK3__
705 if (GDK_IS_X11_SCREEN(gtk_window_get_screen(GTK_WINDOW(m_widget))))
706 #endif
707 {
708 gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK);
709 g_signal_connect(m_widget, "property_notify_event",
710 G_CALLBACK(property_notify_event), this);
711 }
712 #endif // GDK_WINDOWING_X11
713
714 // translate wx decorations styles into Motif WM hints (they are recognized
715 // by other WMs as well)
716
717 // always enable moving the window as we have no separate flag for enabling
718 // it
719 m_gdkFunc = GDK_FUNC_MOVE;
720
721 if ( style & wxCLOSE_BOX )
722 m_gdkFunc |= GDK_FUNC_CLOSE;
723
724 if ( style & wxMINIMIZE_BOX )
725 m_gdkFunc |= GDK_FUNC_MINIMIZE;
726
727 if ( style & wxMAXIMIZE_BOX )
728 m_gdkFunc |= GDK_FUNC_MAXIMIZE;
729
730 if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) )
731 {
732 m_gdkDecor = 0;
733 }
734 else // have border
735 {
736 m_gdkDecor = GDK_DECOR_BORDER;
737
738 if ( style & wxCAPTION )
739 m_gdkDecor |= GDK_DECOR_TITLE;
740
741 if ( style & wxSYSTEM_MENU )
742 m_gdkDecor |= GDK_DECOR_MENU;
743
744 if ( style & wxMINIMIZE_BOX )
745 m_gdkDecor |= GDK_DECOR_MINIMIZE;
746
747 if ( style & wxMAXIMIZE_BOX )
748 m_gdkDecor |= GDK_DECOR_MAXIMIZE;
749
750 if ( style & wxRESIZE_BORDER )
751 {
752 m_gdkFunc |= GDK_FUNC_RESIZE;
753 m_gdkDecor |= GDK_DECOR_RESIZEH;
754 }
755 }
756
757 // GTK sometimes chooses very small size if max size hint is not explicitly set
758 DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight);
759
760 m_decorSize = GetCachedDecorSize();
761 int w, h;
762 GTKDoGetSize(&w, &h);
763 gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h);
764
765 return true;
766 }
767
768 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
769 {
770 if ( m_netFrameExtentsTimerId )
771 {
772 // Don't let the timer callback fire as the window pointer passed to it
773 // will become invalid very soon.
774 g_source_remove(m_netFrameExtentsTimerId);
775 }
776
777 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
778 // it can also be a (standard) dialog
779 if ( HILDON_IS_WINDOW(m_widget) )
780 {
781 hildon_program_remove_window(wxTheApp->GetHildonProgram(),
782 HILDON_WINDOW(m_widget));
783 }
784 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2
785
786 if (m_grabbed)
787 {
788 wxFAIL_MSG(wxT("Window still grabbed"));
789 RemoveGrab();
790 }
791
792 SendDestroyEvent();
793
794 // it may also be GtkScrolledWindow in the case of an MDI child
795 if (GTK_IS_WINDOW(m_widget))
796 {
797 gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
798 }
799
800 if (g_activeFrame == this)
801 g_activeFrame = NULL;
802 if (g_lastActiveFrame == this)
803 g_lastActiveFrame = NULL;
804 }
805
806 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
807 {
808 if (enable)
809 m_gdkFunc |= GDK_FUNC_CLOSE;
810 else
811 m_gdkFunc &= ~GDK_FUNC_CLOSE;
812
813 GdkWindow* window = gtk_widget_get_window(m_widget);
814 if (window)
815 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
816
817 return true;
818 }
819
820 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long)
821 {
822 if (show == m_fsIsShowing)
823 return false; // return what?
824
825 m_fsIsShowing = show;
826
827 #ifdef GDK_WINDOWING_X11
828 Display* xdpy = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(m_widget));
829 Window xroot = GDK_WINDOW_XID(gtk_widget_get_root_window(m_widget));
830 wxX11FullScreenMethod method = wxGetFullScreenMethodX11(xdpy, (WXWindow)xroot);
831
832 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
833 // to switch to fullscreen, which is not always available. We must
834 // check if WM supports the spec and use legacy methods if it
835 // doesn't.
836 if ( method == wxX11_FS_WMSPEC )
837 #endif // GDK_WINDOWING_X11
838 {
839 if (show)
840 gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
841 else
842 gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
843 }
844 #ifdef GDK_WINDOWING_X11
845 else
846 {
847 GdkWindow* window = gtk_widget_get_window(m_widget);
848 Window xid = GDK_WINDOW_XID(window);
849
850 if (show)
851 {
852 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
853 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
854
855 GdkScreen* screen = gtk_widget_get_screen(m_widget);
856 const int screen_width = gdk_screen_get_width(screen);
857 const int screen_height = gdk_screen_get_height(screen);
858
859 gint client_x, client_y, root_x, root_y;
860 gint width, height;
861
862 m_fsSaveGdkFunc = m_gdkFunc;
863 m_fsSaveGdkDecor = m_gdkDecor;
864 m_gdkFunc = m_gdkDecor = 0;
865 gdk_window_set_decorations(window, (GdkWMDecoration)0);
866 gdk_window_set_functions(window, (GdkWMFunction)0);
867
868 gdk_window_get_origin(window, &root_x, &root_y);
869 gdk_window_get_geometry(window, &client_x, &client_y, &width, &height);
870
871 gdk_window_move_resize(
872 window, -client_x, -client_y, screen_width + 1, screen_height + 1);
873
874 wxSetFullScreenStateX11(xdpy,
875 (WXWindow)xroot,
876 (WXWindow)xid,
877 show, &m_fsSaveFrame, method);
878 }
879 else // hide
880 {
881 m_gdkFunc = m_fsSaveGdkFunc;
882 m_gdkDecor = m_fsSaveGdkDecor;
883 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
884 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
885
886 wxSetFullScreenStateX11(xdpy,
887 (WXWindow)xroot,
888 (WXWindow)xid,
889 show, &m_fsSaveFrame, method);
890
891 SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
892 m_fsSaveFrame.width, m_fsSaveFrame.height);
893 }
894 }
895 #endif // GDK_WINDOWING_X11
896
897 // documented behaviour is to show the window if it's still hidden when
898 // showing it full screen
899 if (show)
900 Show();
901
902 return true;
903 }
904
905 // ----------------------------------------------------------------------------
906 // overridden wxWindow methods
907 // ----------------------------------------------------------------------------
908
909 void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect) )
910 {
911 wxCHECK_RET( m_widget, wxT("invalid frame") );
912
913 gtk_widget_queue_draw( m_widget );
914
915 GdkWindow* window = NULL;
916 if (m_wxwindow)
917 window = gtk_widget_get_window(m_wxwindow);
918 if (window)
919 gdk_window_invalidate_rect(window, NULL, true);
920 }
921
922 bool wxTopLevelWindowGTK::Show( bool show )
923 {
924 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
925
926 #ifdef GDK_WINDOWING_X11
927 bool deferShow = show && !m_isShown && m_deferShow;
928 if (deferShow)
929 {
930 deferShow = m_deferShowAllowed &&
931 gs_requestFrameExtentsStatus != RFE_STATUS_BROKEN &&
932 !gtk_widget_get_realized(m_widget) &&
933 g_signal_handler_find(m_widget,
934 GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
935 g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET),
936 0, NULL, NULL, this);
937 if (deferShow)
938 {
939 GdkScreen* screen = gtk_widget_get_screen(m_widget);
940 GdkAtom atom = gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false);
941 deferShow = gdk_x11_screen_supports_net_wm_hint(screen, atom) != 0;
942
943 // If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes
944 // to m_decorSize, it breaks saving/restoring window size with
945 // GetSize()/SetSize() because it makes window bigger between each
946 // restore and save.
947 m_updateDecorSize = deferShow;
948 }
949
950 m_deferShow = deferShow;
951 }
952 if (deferShow)
953 {
954 // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
955 // calling gtk_widget_show() until _NET_FRAME_EXTENTS property
956 // notification is received, so correct frame extents are known.
957 // This allows resizing m_widget to keep the overall size in sync with
958 // what wxWidgets expects it to be without an obvious change in the
959 // window size immediately after it becomes visible.
960
961 // Realize m_widget, so m_widget->window can be used. Realizing normally
962 // causes the widget tree to be size_allocated, which generates size
963 // events in the wrong order. However, the size_allocates will not be
964 // done if the allocation is not the default (1,1).
965 GtkAllocation alloc;
966 gtk_widget_get_allocation(m_widget, &alloc);
967 const int alloc_width = alloc.width;
968 if (alloc_width == 1)
969 {
970 alloc.width = 2;
971 gtk_widget_set_allocation(m_widget, &alloc);
972 }
973 gtk_widget_realize(m_widget);
974 if (alloc_width == 1)
975 {
976 alloc.width = 1;
977 gtk_widget_set_allocation(m_widget, &alloc);
978 }
979
980 // send _NET_REQUEST_FRAME_EXTENTS
981 XClientMessageEvent xevent;
982 memset(&xevent, 0, sizeof(xevent));
983 xevent.type = ClientMessage;
984 GdkWindow* window = gtk_widget_get_window(m_widget);
985 xevent.window = GDK_WINDOW_XID(window);
986 xevent.message_type = gdk_x11_atom_to_xatom_for_display(
987 gdk_window_get_display(window),
988 gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
989 xevent.format = 32;
990 Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window));
991 XSendEvent(display, DefaultRootWindow(display), false,
992 SubstructureNotifyMask | SubstructureRedirectMask,
993 (XEvent*)&xevent);
994
995 if (gs_requestFrameExtentsStatus == RFE_STATUS_UNKNOWN)
996 {
997 // if WM does not respond to request within 1 second,
998 // we assume support for _NET_REQUEST_FRAME_EXTENTS is not working
999 m_netFrameExtentsTimerId =
1000 g_timeout_add(1000, request_frame_extents_timeout, this);
1001 }
1002
1003 // defer calling gtk_widget_show()
1004 m_isShown = true;
1005 return true;
1006 }
1007 #endif // GDK_WINDOWING_X11
1008
1009 if (show && !gtk_widget_get_realized(m_widget))
1010 {
1011 // size_allocate signals occur in reverse order (bottom to top).
1012 // Things work better if the initial wxSizeEvents are sent (from the
1013 // top down), before the initial size_allocate signals occur.
1014 wxSizeEvent event(GetSize(), GetId());
1015 event.SetEventObject(this);
1016 HandleWindowEvent(event);
1017 }
1018
1019 bool change = base_type::Show(show);
1020
1021 if (change && !show)
1022 {
1023 // make sure window has a non-default position, so when it is shown
1024 // again, it won't be repositioned by WM as if it were a new window
1025 // Note that this must be done _after_ the window is hidden.
1026 gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
1027 }
1028
1029 return change;
1030 }
1031
1032 void wxTopLevelWindowGTK::ShowWithoutActivating()
1033 {
1034 if (!m_isShown)
1035 {
1036 gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false);
1037 Show(true);
1038 }
1039 }
1040
1041 void wxTopLevelWindowGTK::Raise()
1042 {
1043 gtk_window_present( GTK_WINDOW( m_widget ) );
1044 }
1045
1046 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
1047 {
1048 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
1049 }
1050
1051 // ----------------------------------------------------------------------------
1052 // window geometry
1053 // ----------------------------------------------------------------------------
1054
1055 void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const
1056 {
1057 wxSize size(m_width, m_height);
1058 size.x -= m_decorSize.left + m_decorSize.right;
1059 size.y -= m_decorSize.top + m_decorSize.bottom;
1060 if (size.x < 0) size.x = 0;
1061 if (size.y < 0) size.y = 0;
1062 #if wxUSE_LIBHILDON2
1063 if (width) {
1064 if (size.x == 720)
1065 *width = 696;
1066 else
1067 *width = size.x;
1068 }
1069 if (height) {
1070 if (size.y == 420)
1071 *height = 396;
1072 else if (size.y == 270)
1073 *height = 246;
1074 else
1075 *height = size.y;
1076 }
1077 #else // wxUSE_LIBHILDON2
1078 if (width) *width = size.x;
1079 if (height) *height = size.y;
1080 #endif // wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON2
1081 }
1082
1083 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
1084 {
1085 wxCHECK_RET( m_widget, wxT("invalid frame") );
1086
1087 // deal with the position first
1088 int old_x = m_x;
1089 int old_y = m_y;
1090
1091 if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1092 {
1093 // -1 means "use existing" unless the flag above is specified
1094 if ( x != -1 )
1095 m_x = x;
1096 if ( y != -1 )
1097 m_y = y;
1098 }
1099 else // wxSIZE_ALLOW_MINUS_ONE
1100 {
1101 m_x = x;
1102 m_y = y;
1103 }
1104
1105 if ( m_x != old_x || m_y != old_y )
1106 {
1107 gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
1108 wxMoveEvent event(wxPoint(m_x, m_y), GetId());
1109 event.SetEventObject(this);
1110 HandleWindowEvent(event);
1111 }
1112
1113 const wxSize oldSize(m_width, m_height);
1114 if (width >= 0)
1115 m_width = width;
1116 if (height >= 0)
1117 m_height = height;
1118 ConstrainSize();
1119 if (m_width < 1) m_width = 1;
1120 if (m_height < 1) m_height = 1;
1121 if (m_width != oldSize.x || m_height != oldSize.y)
1122 {
1123 m_deferShowAllowed = true;
1124 m_useCachedClientSize = false;
1125
1126 int w, h;
1127 GTKDoGetSize(&w, &h);
1128 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
1129
1130 DoGetClientSize(&m_clientWidth, &m_clientHeight);
1131 wxSizeEvent event(GetSize(), GetId());
1132 event.SetEventObject(this);
1133 HandleWindowEvent(event);
1134 }
1135 }
1136
1137 void wxTopLevelWindowGTK::DoSetClientSize(int width, int height)
1138 {
1139 base_type::DoSetClientSize(width, height);
1140
1141 // Since client size is being explicitly set, don't change it later
1142 // Has to be done after calling base because it calls SetSize,
1143 // which sets this true
1144 m_deferShowAllowed = false;
1145 }
1146
1147 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
1148 {
1149 wxASSERT_MSG(m_widget, wxT("invalid frame"));
1150
1151 if ( IsIconized() )
1152 {
1153 // for consistency with wxMSW, client area is supposed to be empty for
1154 // the iconized windows
1155 if ( width )
1156 *width = 0;
1157 if ( height )
1158 *height = 0;
1159 }
1160 else if (m_useCachedClientSize)
1161 base_type::DoGetClientSize(width, height);
1162 else
1163 {
1164 GTKDoGetSize(width, height);
1165 }
1166 }
1167
1168 void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
1169 int maxW, int maxH,
1170 int incW, int incH )
1171 {
1172 base_type::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
1173 m_incWidth = incW;
1174 m_incHeight = incH;
1175
1176 const wxSize minSize = GetMinSize();
1177 const wxSize maxSize = GetMaxSize();
1178 GdkGeometry hints;
1179 // always set both min and max hints, otherwise GTK will
1180 // make assumptions we don't want about the unset values
1181 int hints_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
1182 hints.min_width = 1;
1183 hints.min_height = 1;
1184 hints.max_width = INT_MAX;
1185 hints.max_height = INT_MAX;
1186 const int decorSize_x = m_decorSize.left + m_decorSize.right;
1187 const int decorSize_y = m_decorSize.top + m_decorSize.bottom;
1188 if (minSize.x > decorSize_x)
1189 hints.min_width = minSize.x - decorSize_x;
1190 if (minSize.y > decorSize_y)
1191 hints.min_height = minSize.y - decorSize_y;
1192 if (maxSize.x > 0)
1193 {
1194 hints.max_width = maxSize.x - decorSize_x;
1195 if (hints.max_width < hints.min_width)
1196 hints.max_width = hints.min_width;
1197 }
1198 if (maxSize.y > 0)
1199 {
1200 hints.max_height = maxSize.y - decorSize_y;
1201 if (hints.max_height < hints.min_height)
1202 hints.max_height = hints.min_height;
1203 }
1204 if (incW > 0 || incH > 0)
1205 {
1206 hints_mask |= GDK_HINT_RESIZE_INC;
1207 hints.width_inc = incW > 0 ? incW : 1;
1208 hints.height_inc = incH > 0 ? incH : 1;
1209 }
1210 gtk_window_set_geometry_hints(
1211 (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
1212 }
1213
1214 #ifdef GDK_WINDOWING_X11
1215 void wxTopLevelWindowGTK::GTKUpdateDecorSize(const DecorSize& decorSize)
1216 {
1217 if (!IsMaximized() && !IsFullScreen())
1218 GetCachedDecorSize() = decorSize;
1219 if (m_updateDecorSize && memcmp(&m_decorSize, &decorSize, sizeof(DecorSize)))
1220 {
1221 m_useCachedClientSize = false;
1222 const wxSize diff(
1223 decorSize.left - m_decorSize.left + decorSize.right - m_decorSize.right,
1224 decorSize.top - m_decorSize.top + decorSize.bottom - m_decorSize.bottom);
1225 m_decorSize = decorSize;
1226 bool resized = false;
1227 if (m_minWidth > 0 || m_minHeight > 0 || m_maxWidth > 0 || m_maxHeight > 0)
1228 {
1229 // update size hints, they depend on m_decorSize
1230 DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight);
1231 }
1232 if (m_deferShow)
1233 {
1234 // keep overall size unchanged by shrinking m_widget
1235 int w, h;
1236 GTKDoGetSize(&w, &h);
1237 // but not if size would be less than minimum, it won't take effect
1238 if (w >= m_minWidth - (decorSize.left + decorSize.right) &&
1239 h >= m_minHeight - (decorSize.top + decorSize.bottom))
1240 {
1241 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
1242 resized = true;
1243 }
1244 }
1245 if (!resized)
1246 {
1247 // adjust overall size to match change in frame extents
1248 m_width += diff.x;
1249 m_height += diff.y;
1250 if (m_width < 1) m_width = 1;
1251 if (m_height < 1) m_height = 1;
1252 m_clientWidth = 0;
1253 gtk_widget_queue_resize(m_wxwindow);
1254 }
1255 }
1256 if (m_deferShow)
1257 {
1258 // gtk_widget_show() was deferred, do it now
1259 m_deferShow = false;
1260 DoGetClientSize(&m_clientWidth, &m_clientHeight);
1261 wxSizeEvent sizeEvent(GetSize(), GetId());
1262 sizeEvent.SetEventObject(this);
1263 HandleWindowEvent(sizeEvent);
1264
1265 gtk_widget_show(m_widget);
1266
1267 wxShowEvent showEvent(GetId(), true);
1268 showEvent.SetEventObject(this);
1269 HandleWindowEvent(showEvent);
1270 }
1271 }
1272 #endif // GDK_WINDOWING_X11
1273
1274 wxTopLevelWindowGTK::DecorSize& wxTopLevelWindowGTK::GetCachedDecorSize()
1275 {
1276 static DecorSize size[8];
1277
1278 int index = 0;
1279 // title bar
1280 if (m_gdkDecor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE))
1281 index = 1;
1282 // border
1283 if (m_gdkDecor & GDK_DECOR_BORDER)
1284 index |= 2;
1285 // utility window decor can be different
1286 if (m_windowStyle & wxFRAME_TOOL_WINDOW)
1287 index |= 4;
1288 return size[index];
1289 }
1290
1291 void wxTopLevelWindowGTK::OnInternalIdle()
1292 {
1293 wxTopLevelWindowBase::OnInternalIdle();
1294
1295 // Synthetize activate events.
1296 if ( g_sendActivateEvent != -1 )
1297 {
1298 bool activate = g_sendActivateEvent != 0;
1299
1300 // if (!activate) wxPrintf( wxT("de") );
1301 // wxPrintf( wxT("activate\n") );
1302
1303 // do it only once
1304 g_sendActivateEvent = -1;
1305
1306 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1307 }
1308 }
1309
1310 // ----------------------------------------------------------------------------
1311 // frame title/icon
1312 // ----------------------------------------------------------------------------
1313
1314 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1315 {
1316 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1317
1318 if ( title == m_title )
1319 return;
1320
1321 m_title = title;
1322
1323 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1324 }
1325
1326 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1327 {
1328 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1329
1330 base_type::SetIcons(icons);
1331
1332 // Setting icons before window is realized can cause a GTK assertion if
1333 // another TLW is realized before this one, and it has this one as it's
1334 // transient parent. The life demo exibits this problem.
1335 if (gtk_widget_get_realized(m_widget))
1336 {
1337 GList* list = NULL;
1338 for (size_t i = icons.GetIconCount(); i--;)
1339 list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf());
1340 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1341 g_list_free(list);
1342 }
1343 }
1344
1345 // ----------------------------------------------------------------------------
1346 // frame state: maximized/iconized/normal
1347 // ----------------------------------------------------------------------------
1348
1349 void wxTopLevelWindowGTK::Maximize(bool maximize)
1350 {
1351 if (maximize)
1352 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1353 else
1354 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1355 }
1356
1357 bool wxTopLevelWindowGTK::IsMaximized() const
1358 {
1359 GdkWindow* window = NULL;
1360 if (m_widget)
1361 window = gtk_widget_get_window(m_widget);
1362 return window && (gdk_window_get_state(window) & GDK_WINDOW_STATE_MAXIMIZED);
1363 }
1364
1365 void wxTopLevelWindowGTK::Restore()
1366 {
1367 // "Present" seems similar enough to "restore"
1368 gtk_window_present( GTK_WINDOW( m_widget ) );
1369 }
1370
1371 void wxTopLevelWindowGTK::Iconize( bool iconize )
1372 {
1373 if (iconize)
1374 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1375 else
1376 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1377 }
1378
1379 bool wxTopLevelWindowGTK::IsIconized() const
1380 {
1381 return m_isIconized;
1382 }
1383
1384 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1385 {
1386 if ( iconize != m_isIconized )
1387 {
1388 m_isIconized = iconize;
1389 (void)SendIconizeEvent(iconize);
1390 }
1391 }
1392
1393 void wxTopLevelWindowGTK::AddGrab()
1394 {
1395 if (!m_grabbed)
1396 {
1397 m_grabbed = true;
1398 gtk_grab_add( m_widget );
1399 wxGUIEventLoop().Run();
1400 gtk_grab_remove( m_widget );
1401 }
1402 }
1403
1404 void wxTopLevelWindowGTK::RemoveGrab()
1405 {
1406 if (m_grabbed)
1407 {
1408 gtk_main_quit();
1409 m_grabbed = false;
1410 }
1411 }
1412
1413 bool wxTopLevelWindowGTK::IsActive()
1414 {
1415 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1416 }
1417
1418 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1419 {
1420 bool new_hint_value = false;
1421
1422 // FIXME: This is a workaround to focus handling problem
1423 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle
1424 // hasn't yet been processed, and the internal focus system is not up to date yet.
1425 // YieldFor(wxEVT_CATEGORY_UI) ensures the processing of it (hopefully it
1426 // won't have side effects) - MR
1427 wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI);
1428
1429 if(m_urgency_hint >= 0)
1430 g_source_remove(m_urgency_hint);
1431
1432 m_urgency_hint = -2;
1433
1434 if( gtk_widget_get_realized(m_widget) && !IsActive() )
1435 {
1436 new_hint_value = true;
1437
1438 if (flags & wxUSER_ATTENTION_INFO)
1439 {
1440 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1441 } else {
1442 m_urgency_hint = -1;
1443 }
1444 }
1445
1446 gtk_window_set_urgency_hint(GTK_WINDOW(m_widget), new_hint_value);
1447 }
1448
1449 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1450 {
1451 // Store which styles were changed
1452 long styleChanges = style ^ m_windowStyle;
1453
1454 // Process wxWindow styles. This also updates the internal variable
1455 // Therefore m_windowStyle bits carry now the _new_ style values
1456 wxWindow::SetWindowStyleFlag(style);
1457
1458 // just return for now if widget does not exist yet
1459 if (!m_widget)
1460 return;
1461
1462 if ( styleChanges & wxSTAY_ON_TOP )
1463 {
1464 gtk_window_set_keep_above(GTK_WINDOW(m_widget),
1465 m_windowStyle & wxSTAY_ON_TOP);
1466 }
1467
1468 if ( styleChanges & wxFRAME_NO_TASKBAR )
1469 {
1470 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget),
1471 m_windowStyle & wxFRAME_NO_TASKBAR);
1472 }
1473 }
1474
1475 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1476 {
1477 GdkWindow* window = NULL;
1478 if (m_widget)
1479 window = gtk_widget_get_window(m_widget);
1480 if (window == NULL)
1481 return false;
1482
1483 #ifdef GDK_WINDOWING_X11
1484 Display* dpy = GDK_WINDOW_XDISPLAY(window);
1485 Window win = GDK_WINDOW_XID(window);
1486
1487 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1488 if (alpha == 0xff)
1489 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1490 else
1491 {
1492 long opacity = alpha * 0x1010101L;
1493 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1494 XA_CARDINAL, 32, PropModeReplace,
1495 (unsigned char *) &opacity, 1L);
1496 }
1497 XSync(dpy, False);
1498 return true;
1499 #else // !GDK_WINDOWING_X11
1500 return false;
1501 #endif // GDK_WINDOWING_X11 / !GDK_WINDOWING_X11
1502 }
1503
1504 bool wxTopLevelWindowGTK::CanSetTransparent()
1505 {
1506 // allow to override automatic detection as it's far from perfect
1507 const wxString SYSOPT_TRANSPARENT = "gtk.tlw.can-set-transparent";
1508 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
1509 {
1510 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
1511 }
1512
1513 #ifdef __WXGTK3__
1514 return gtk_widget_is_composited(m_widget) != 0;
1515 #else
1516 #if GTK_CHECK_VERSION(2,10,0)
1517 if (!gtk_check_version(2,10,0))
1518 {
1519 return gtk_widget_is_composited(m_widget) != 0;
1520 }
1521 else
1522 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1523 {
1524 return false;
1525 }
1526 #endif // !__WXGTK3__
1527
1528 #if 0 // Don't be optimistic here for the sake of wxAUI
1529 int opcode, event, error;
1530 // Check for the existence of a RGBA visual instead?
1531 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1532 "Composite", &opcode, &event, &error);
1533 #endif
1534 }
wxWidgets (Impactor)