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


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