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