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