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


c394556271ce76c34581194049bd27111f097bed
[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/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
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 #ifndef __WXGTK3__
84 static 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
117 extern "C" {
118 static 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
131 extern "C" {
132 static 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
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 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
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 // "delete_event"
245 //-----------------------------------------------------------------------------
246
247 extern "C" {
248 static gboolean
249 gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
250 GdkEvent *WXUNUSED(event),
251 wxTopLevelWindowGTK *win )
252 {
253 if (win->IsEnabled() &&
254 (wxOpenModalDialogsCount == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
255 win->IsGrabbed()))
256 win->Close();
257
258 return TRUE;
259 }
260 }
261
262 //-----------------------------------------------------------------------------
263 // "configure_event"
264 //-----------------------------------------------------------------------------
265
266 extern "C" {
267 static gboolean
268 gtk_frame_configure_callback( GtkWidget* widget,
269 GdkEventConfigure *WXUNUSED(event),
270 wxTopLevelWindowGTK *win )
271 {
272 if (!win->m_hasVMT || !win->IsShown())
273 return FALSE;
274
275 wxPoint point;
276 gtk_window_get_position((GtkWindow*)widget, &point.x, &point.y);
277
278 win->m_x = point.x;
279 win->m_y = point.y;
280 wxMoveEvent mevent(point, win->GetId());
281 mevent.SetEventObject( win );
282 win->HandleWindowEvent( mevent );
283
284 return FALSE;
285 }
286 }
287
288 //-----------------------------------------------------------------------------
289 // "realize" from m_widget
290 //-----------------------------------------------------------------------------
291
292 // we cannot the WM hints and icons before the widget has been realized,
293 // so we do this directly after realization
294
295 void wxTopLevelWindowGTK::GTKHandleRealized()
296 {
297 wxNonOwnedWindow::GTKHandleRealized();
298
299 gdk_window_set_decorations(gtk_widget_get_window(m_widget),
300 (GdkWMDecoration)m_gdkDecor);
301 gdk_window_set_functions(gtk_widget_get_window(m_widget),
302 (GdkWMFunction)m_gdkFunc);
303
304 // GTK's shrinking/growing policy
305 if ( !(m_gdkFunc & GDK_FUNC_RESIZE) )
306 gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE);
307 #ifndef __WXGTK3__
308 else
309 gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1);
310 #endif
311
312 const wxIconBundle& icons = GetIcons();
313 if (icons.GetIconCount())
314 SetIcons(icons);
315
316 #ifdef __WXGTK3__
317 if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget)))
318 {
319 // Grip window can end up obscured, probably due to deferred show.
320 // Reset grip to ensure it is visible.
321 gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false);
322 gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true);
323 }
324 #endif
325 }
326
327 //-----------------------------------------------------------------------------
328 // "map_event" from m_widget
329 //-----------------------------------------------------------------------------
330
331 extern "C" {
332 static gboolean
333 gtk_frame_map_callback( GtkWidget*,
334 GdkEvent * WXUNUSED(event),
335 wxTopLevelWindow *win )
336 {
337 const bool wasIconized = win->IsIconized();
338 if (wasIconized)
339 {
340 // Because GetClientSize() returns (0,0) when IsIconized() is true,
341 // a size event must be generated, just in case GetClientSize() was
342 // called while iconized. This specifically happens when restoring a
343 // tlw that was "rolled up" with some WMs.
344 // Queue a resize rather than sending size event directly to allow
345 // children to be made visible first.
346 win->m_oldClientWidth = 0;
347 gtk_widget_queue_resize(win->m_wxwindow);
348 }
349 // it is possible for m_isShown to be false here, see bug #9909
350 if (win->wxWindowBase::Show(true))
351 {
352 wxShowEvent eventShow(win->GetId(), true);
353 eventShow.SetEventObject(win);
354 win->GetEventHandler()->ProcessEvent(eventShow);
355 }
356
357 #if GTK_CHECK_VERSION(2,6,0)
358 #ifndef __WXGTK3__
359 if (!gtk_check_version(2,6,0))
360 #endif
361 {
362 // restore focus-on-map setting in case ShowWithoutActivating() was called
363 gtk_window_set_focus_on_map(GTK_WINDOW(win->m_widget), true);
364 }
365 #endif // GTK+ 2.6+
366
367 return false;
368 }
369 }
370
371 //-----------------------------------------------------------------------------
372 // "window-state-event" from m_widget
373 //-----------------------------------------------------------------------------
374
375 extern "C" {
376 static gboolean
377 gtk_frame_window_state_callback( GtkWidget* WXUNUSED(widget),
378 GdkEventWindowState *event,
379 wxTopLevelWindow *win )
380 {
381 if (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED)
382 win->SetIconizeState((event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) != 0);
383
384 // if maximized bit changed and it is now set
385 if (event->changed_mask & event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED)
386 {
387 wxMaximizeEvent event(win->GetId());
388 event.SetEventObject(win);
389 win->HandleWindowEvent(event);
390 }
391
392 return false;
393 }
394 }
395
396 //-----------------------------------------------------------------------------
397
398 bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom)
399 {
400 #ifdef GDK_WINDOWING_X11
401 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
402 GdkDisplay* display = gdk_window_get_display(window);
403 Atom xproperty = gdk_x11_atom_to_xatom_for_display(display, property);
404 Atom type;
405 int format;
406 gulong nitems, bytes_after;
407 guchar* data;
408 Status status = XGetWindowProperty(
409 GDK_DISPLAY_XDISPLAY(display),
410 GDK_WINDOW_XID(window),
411 xproperty,
412 0, 4, false, XA_CARDINAL,
413 &type, &format, &nitems, &bytes_after, &data);
414 const bool success = status == Success && data && nitems == 4;
415 if (success)
416 {
417 long* p = (long*)data;
418 if (left) *left = int(p[0]);
419 if (right) *right = int(p[1]);
420 if (top) *top = int(p[2]);
421 if (bottom) *bottom = int(p[3]);
422 }
423 if (data)
424 XFree(data);
425 return success;
426 #else
427 return false;
428 #endif
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 m_incWidth = m_incHeight = 0;
498
499 m_urgency_hint = -2;
500 }
501
502 bool 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_vbox_new(false, 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_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
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_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK);
649 g_signal_connect(m_widget, "property_notify_event",
650 G_CALLBACK(property_notify_event), this);
651
652 // translate wx decorations styles into Motif WM hints (they are recognized
653 // by other WMs as well)
654
655 // always enable moving the window as we have no separate flag for enabling
656 // it
657 m_gdkFunc = GDK_FUNC_MOVE;
658
659 if ( style & wxCLOSE_BOX )
660 m_gdkFunc |= GDK_FUNC_CLOSE;
661
662 if ( style & wxMINIMIZE_BOX )
663 m_gdkFunc |= GDK_FUNC_MINIMIZE;
664
665 if ( style & wxMAXIMIZE_BOX )
666 m_gdkFunc |= GDK_FUNC_MAXIMIZE;
667
668 if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) )
669 {
670 m_gdkDecor = 0;
671 }
672 else // have border
673 {
674 m_gdkDecor = GDK_DECOR_BORDER;
675
676 if ( style & wxCAPTION )
677 m_gdkDecor |= GDK_DECOR_TITLE;
678
679 if ( style & wxSYSTEM_MENU )
680 m_gdkDecor |= GDK_DECOR_MENU;
681
682 if ( style & wxMINIMIZE_BOX )
683 m_gdkDecor |= GDK_DECOR_MINIMIZE;
684
685 if ( style & wxMAXIMIZE_BOX )
686 m_gdkDecor |= GDK_DECOR_MAXIMIZE;
687
688 if ( style & wxRESIZE_BORDER )
689 {
690 m_gdkFunc |= GDK_FUNC_RESIZE;
691 m_gdkDecor |= GDK_DECOR_RESIZEH;
692 }
693 }
694
695 // GTK sometimes chooses very small size if max size hint is not explicitly set
696 DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight);
697
698 m_decorSize = GetCachedDecorSize();
699 int w, h;
700 GTKDoGetSize(&w, &h);
701 gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h);
702
703 return true;
704 }
705
706 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
707 {
708 if ( m_netFrameExtentsTimerId )
709 {
710 // Don't let the timer callback fire as the window pointer passed to it
711 // will become invalid very soon.
712 g_source_remove(m_netFrameExtentsTimerId);
713 }
714
715 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
716 // it can also be a (standard) dialog
717 if ( HILDON_IS_WINDOW(m_widget) )
718 {
719 hildon_program_remove_window(wxTheApp->GetHildonProgram(),
720 HILDON_WINDOW(m_widget));
721 }
722 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2
723
724 if (m_grabbed)
725 {
726 wxFAIL_MSG(wxT("Window still grabbed"));
727 RemoveGrab();
728 }
729
730 SendDestroyEvent();
731
732 // it may also be GtkScrolledWindow in the case of an MDI child
733 if (GTK_IS_WINDOW(m_widget))
734 {
735 gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
736 }
737
738 if (g_activeFrame == this)
739 g_activeFrame = NULL;
740 if (g_lastActiveFrame == this)
741 g_lastActiveFrame = NULL;
742 }
743
744 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
745 {
746 if (enable)
747 m_gdkFunc |= GDK_FUNC_CLOSE;
748 else
749 m_gdkFunc &= ~GDK_FUNC_CLOSE;
750
751 GdkWindow* window = gtk_widget_get_window(m_widget);
752 if (window)
753 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
754
755 return true;
756 }
757
758 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long)
759 {
760 if (show == m_fsIsShowing)
761 return false; // return what?
762
763 m_fsIsShowing = show;
764
765 #ifdef GDK_WINDOWING_X11
766 Display* xdpy = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(m_widget));
767 Window xroot = GDK_WINDOW_XID(gtk_widget_get_root_window(m_widget));
768 wxX11FullScreenMethod method = wxGetFullScreenMethodX11(xdpy, (WXWindow)xroot);
769
770 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
771 // to switch to fullscreen, which is not always available. We must
772 // check if WM supports the spec and use legacy methods if it
773 // doesn't.
774 if ( method == wxX11_FS_WMSPEC )
775 #endif // GDK_WINDOWING_X11
776 {
777 if (show)
778 gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
779 else
780 gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
781 }
782 #ifdef GDK_WINDOWING_X11
783 else
784 {
785 GdkWindow* window = gtk_widget_get_window(m_widget);
786 Window xid = GDK_WINDOW_XID(window);
787
788 if (show)
789 {
790 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
791 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
792
793 GdkScreen* screen = gtk_widget_get_screen(m_widget);
794 const int screen_width = gdk_screen_get_width(screen);
795 const int screen_height = gdk_screen_get_height(screen);
796
797 gint client_x, client_y, root_x, root_y;
798 gint width, height;
799
800 m_fsSaveGdkFunc = m_gdkFunc;
801 m_fsSaveGdkDecor = m_gdkDecor;
802 m_gdkFunc = m_gdkDecor = 0;
803 gdk_window_set_decorations(window, (GdkWMDecoration)0);
804 gdk_window_set_functions(window, (GdkWMFunction)0);
805
806 gdk_window_get_origin(window, &root_x, &root_y);
807 gdk_window_get_geometry(window, &client_x, &client_y, &width, &height);
808
809 gdk_window_move_resize(
810 window, -client_x, -client_y, screen_width + 1, screen_height + 1);
811
812 wxSetFullScreenStateX11(xdpy,
813 (WXWindow)xroot,
814 (WXWindow)xid,
815 show, &m_fsSaveFrame, method);
816 }
817 else // hide
818 {
819 m_gdkFunc = m_fsSaveGdkFunc;
820 m_gdkDecor = m_fsSaveGdkDecor;
821 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
822 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
823
824 wxSetFullScreenStateX11(xdpy,
825 (WXWindow)xroot,
826 (WXWindow)xid,
827 show, &m_fsSaveFrame, method);
828
829 SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
830 m_fsSaveFrame.width, m_fsSaveFrame.height);
831 }
832 }
833 #endif // GDK_WINDOWING_X11
834
835 // documented behaviour is to show the window if it's still hidden when
836 // showing it full screen
837 if (show)
838 Show();
839
840 return true;
841 }
842
843 // ----------------------------------------------------------------------------
844 // overridden wxWindow methods
845 // ----------------------------------------------------------------------------
846
847 void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect) )
848 {
849 wxCHECK_RET( m_widget, wxT("invalid frame") );
850
851 gtk_widget_queue_draw( m_widget );
852
853 GdkWindow* window = NULL;
854 if (m_wxwindow)
855 window = gtk_widget_get_window(m_wxwindow);
856 if (window)
857 gdk_window_invalidate_rect(window, NULL, true);
858 }
859
860 bool wxTopLevelWindowGTK::Show( bool show )
861 {
862 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
863
864 bool deferShow = show && !m_isShown && m_deferShow;
865 if (deferShow)
866 {
867 deferShow = gs_requestFrameExtentsStatus != 2 &&
868 m_deferShowAllowed && !gtk_widget_get_realized(m_widget);
869 if (deferShow)
870 {
871 deferShow = g_signal_handler_find(m_widget,
872 GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
873 g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET),
874 0, NULL, NULL, this) != 0;
875 }
876 GdkScreen* screen = NULL;
877 if (deferShow)
878 {
879 #ifdef GDK_WINDOWING_X11
880 screen = gtk_widget_get_screen(m_widget);
881 GdkAtom atom = gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false);
882 deferShow = gdk_x11_screen_supports_net_wm_hint(screen, atom) != 0;
883 #else
884 deferShow = false;
885 #endif
886 // If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes
887 // to m_decorSize, it breaks saving/restoring window size with
888 // GetSize()/SetSize() because it makes window bigger between each
889 // restore and save.
890 m_updateDecorSize = deferShow;
891 }
892
893 m_deferShow = deferShow;
894 }
895 if (deferShow)
896 {
897 // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
898 // calling gtk_widget_show() until _NET_FRAME_EXTENTS property
899 // notification is received, so correct frame extents are known.
900 // This allows resizing m_widget to keep the overall size in sync with
901 // what wxWidgets expects it to be without an obvious change in the
902 // window size immediately after it becomes visible.
903
904 // Realize m_widget, so m_widget->window can be used. Realizing normally
905 // causes the widget tree to be size_allocated, which generates size
906 // events in the wrong order. However, the size_allocates will not be
907 // done if the allocation is not the default (1,1).
908 GtkAllocation alloc;
909 gtk_widget_get_allocation(m_widget, &alloc);
910 const int alloc_width = alloc.width;
911 if (alloc_width == 1)
912 {
913 alloc.width = 2;
914 gtk_widget_set_allocation(m_widget, &alloc);
915 }
916 gtk_widget_realize(m_widget);
917 if (alloc_width == 1)
918 {
919 alloc.width = 1;
920 gtk_widget_set_allocation(m_widget, &alloc);
921 }
922
923 #ifdef GDK_WINDOWING_X11
924 // send _NET_REQUEST_FRAME_EXTENTS
925 XClientMessageEvent xevent;
926 memset(&xevent, 0, sizeof(xevent));
927 xevent.type = ClientMessage;
928 GdkWindow* window = gtk_widget_get_window(m_widget);
929 xevent.window = GDK_WINDOW_XID(window);
930 xevent.message_type = gdk_x11_atom_to_xatom_for_display(
931 gdk_window_get_display(window),
932 gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
933 xevent.format = 32;
934 Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window));
935 XSendEvent(display, DefaultRootWindow(display), false,
936 SubstructureNotifyMask | SubstructureRedirectMask,
937 (XEvent*)&xevent);
938 #endif // GDK_WINDOWING_X11
939
940 if (gs_requestFrameExtentsStatus == 0)
941 {
942 // if WM does not respond to request within 1 second,
943 // we assume support for _NET_REQUEST_FRAME_EXTENTS is not working
944 m_netFrameExtentsTimerId =
945 g_timeout_add(1000, request_frame_extents_timeout, this);
946 }
947
948 // defer calling gtk_widget_show()
949 m_isShown = true;
950 return true;
951 }
952
953 if (show && !gtk_widget_get_realized(m_widget))
954 {
955 // size_allocate signals occur in reverse order (bottom to top).
956 // Things work better if the initial wxSizeEvents are sent (from the
957 // top down), before the initial size_allocate signals occur.
958 wxSizeEvent event(GetSize(), GetId());
959 event.SetEventObject(this);
960 HandleWindowEvent(event);
961 }
962
963 bool change = base_type::Show(show);
964
965 if (change && !show)
966 {
967 // make sure window has a non-default position, so when it is shown
968 // again, it won't be repositioned by WM as if it were a new window
969 // Note that this must be done _after_ the window is hidden.
970 gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
971 }
972
973 return change;
974 }
975
976 void wxTopLevelWindowGTK::ShowWithoutActivating()
977 {
978 if (!m_isShown)
979 {
980 #if GTK_CHECK_VERSION(2,6,0)
981 #ifndef __WXGTK3__
982 if (!gtk_check_version(2,6,0))
983 #endif
984 gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false);
985 #endif // GTK+ 2.6+
986
987 Show(true);
988 }
989 }
990
991 void wxTopLevelWindowGTK::Raise()
992 {
993 gtk_window_present( GTK_WINDOW( m_widget ) );
994 }
995
996 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
997 {
998 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
999 }
1000
1001 // ----------------------------------------------------------------------------
1002 // window geometry
1003 // ----------------------------------------------------------------------------
1004
1005 void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const
1006 {
1007 wxSize size(m_width, m_height);
1008 size -= m_decorSize;
1009 if (size.x < 0) size.x = 0;
1010 if (size.y < 0) size.y = 0;
1011 #if wxUSE_LIBHILDON2
1012 if (width) {
1013 if (size.x == 720)
1014 *width = 696;
1015 else
1016 *width = size.x;
1017 }
1018 if (height) {
1019 if (size.y == 420)
1020 *height = 396;
1021 else if (size.y == 270)
1022 *height = 246;
1023 else
1024 *height = size.y;
1025 }
1026 #else // wxUSE_LIBHILDON2
1027 if (width) *width = size.x;
1028 if (height) *height = size.y;
1029 #endif // wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON2
1030 }
1031
1032 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
1033 {
1034 wxCHECK_RET( m_widget, wxT("invalid frame") );
1035
1036 m_deferShowAllowed = true;
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 int w, h;
1072 GTKDoGetSize(&w, &h);
1073 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
1074
1075 GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
1076 wxSizeEvent event(GetSize(), GetId());
1077 event.SetEventObject(this);
1078 HandleWindowEvent(event);
1079 }
1080 }
1081
1082 void wxTopLevelWindowGTK::DoSetClientSize(int width, int height)
1083 {
1084 base_type::DoSetClientSize(width, height);
1085
1086 // Since client size is being explicitly set, don't change it later
1087 // Has to be done after calling base because it calls SetSize,
1088 // which sets this true
1089 m_deferShowAllowed = false;
1090 }
1091
1092 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
1093 {
1094 wxASSERT_MSG(m_widget, wxT("invalid frame"));
1095
1096 if ( IsIconized() )
1097 {
1098 // for consistency with wxMSW, client area is supposed to be empty for
1099 // the iconized windows
1100 if ( width )
1101 *width = 0;
1102 if ( height )
1103 *height = 0;
1104 }
1105 else
1106 {
1107 GTKDoGetSize(width, height);
1108 }
1109 }
1110
1111 void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
1112 int maxW, int maxH,
1113 int incW, int incH )
1114 {
1115 base_type::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
1116 m_incWidth = incW;
1117 m_incHeight = incH;
1118
1119 const wxSize minSize = GetMinSize();
1120 const wxSize maxSize = GetMaxSize();
1121 GdkGeometry hints;
1122 // always set both min and max hints, otherwise GTK will
1123 // make assumptions we don't want about the unset values
1124 int hints_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
1125 hints.min_width = 1;
1126 hints.min_height = 1;
1127 hints.max_width = INT_MAX;
1128 hints.max_height = INT_MAX;
1129 if (minSize.x > m_decorSize.x)
1130 hints.min_width = minSize.x - m_decorSize.x;
1131 if (minSize.y > m_decorSize.y)
1132 hints.min_height = minSize.y - m_decorSize.y;
1133 if (maxSize.x > 0)
1134 {
1135 hints.max_width = maxSize.x - m_decorSize.x;
1136 if (hints.max_width < hints.min_width)
1137 hints.max_width = hints.min_width;
1138 }
1139 if (maxSize.y > 0)
1140 {
1141 hints.max_height = maxSize.y - m_decorSize.y;
1142 if (hints.max_height < hints.min_height)
1143 hints.max_height = hints.min_height;
1144 }
1145 if (incW > 0 || incH > 0)
1146 {
1147 hints_mask |= GDK_HINT_RESIZE_INC;
1148 hints.width_inc = incW > 0 ? incW : 1;
1149 hints.height_inc = incH > 0 ? incH : 1;
1150 }
1151 gtk_window_set_geometry_hints(
1152 (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
1153 }
1154
1155 void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize)
1156 {
1157 if (!IsMaximized() && !IsFullScreen())
1158 GetCachedDecorSize() = decorSize;
1159 if (m_updateDecorSize && m_decorSize != decorSize)
1160 {
1161 const wxSize diff = decorSize - m_decorSize;
1162 m_decorSize = decorSize;
1163 bool resized = false;
1164 if (m_minWidth > 0 || m_minHeight > 0 || m_maxWidth > 0 || m_maxHeight > 0)
1165 {
1166 // update size hints, they depend on m_decorSize
1167 DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight);
1168 }
1169 if (m_deferShow)
1170 {
1171 // keep overall size unchanged by shrinking m_widget
1172 int w, h;
1173 GTKDoGetSize(&w, &h);
1174 // but not if size would be less than minimum, it won't take effect
1175 if (w >= m_minWidth - decorSize.x && h >= m_minHeight - decorSize.y )
1176 {
1177 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
1178 resized = true;
1179 }
1180 }
1181 if (!resized)
1182 {
1183 // adjust overall size to match change in frame extents
1184 m_width += diff.x;
1185 m_height += diff.y;
1186 if (m_width < 1) m_width = 1;
1187 if (m_height < 1) m_height = 1;
1188 m_oldClientWidth = 0;
1189 gtk_widget_queue_resize(m_wxwindow);
1190 }
1191 }
1192 if (m_deferShow)
1193 {
1194 // gtk_widget_show() was deferred, do it now
1195 m_deferShow = false;
1196 GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
1197 wxSizeEvent sizeEvent(GetSize(), GetId());
1198 sizeEvent.SetEventObject(this);
1199 HandleWindowEvent(sizeEvent);
1200
1201 gtk_widget_show(m_widget);
1202
1203 wxShowEvent showEvent(GetId(), true);
1204 showEvent.SetEventObject(this);
1205 HandleWindowEvent(showEvent);
1206 }
1207 }
1208
1209 wxSize& wxTopLevelWindowGTK::GetCachedDecorSize()
1210 {
1211 static wxSize size[8];
1212
1213 int index = 0;
1214 // title bar
1215 if (m_gdkDecor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE))
1216 index = 1;
1217 // border
1218 if (m_gdkDecor & GDK_DECOR_BORDER)
1219 index |= 2;
1220 // utility window decor can be different
1221 if (m_windowStyle & wxFRAME_TOOL_WINDOW)
1222 index |= 4;
1223 return size[index];
1224 }
1225
1226 void wxTopLevelWindowGTK::OnInternalIdle()
1227 {
1228 wxTopLevelWindowBase::OnInternalIdle();
1229
1230 // Synthetize activate events.
1231 if ( g_sendActivateEvent != -1 )
1232 {
1233 bool activate = g_sendActivateEvent != 0;
1234
1235 // if (!activate) wxPrintf( wxT("de") );
1236 // wxPrintf( wxT("activate\n") );
1237
1238 // do it only once
1239 g_sendActivateEvent = -1;
1240
1241 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1242 }
1243 }
1244
1245 // ----------------------------------------------------------------------------
1246 // frame title/icon
1247 // ----------------------------------------------------------------------------
1248
1249 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1250 {
1251 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1252
1253 if ( title == m_title )
1254 return;
1255
1256 m_title = title;
1257
1258 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1259 }
1260
1261 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1262 {
1263 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1264
1265 base_type::SetIcons(icons);
1266
1267 // Setting icons before window is realized can cause a GTK assertion if
1268 // another TLW is realized before this one, and it has this one as it's
1269 // transient parent. The life demo exibits this problem.
1270 if (gtk_widget_get_realized(m_widget))
1271 {
1272 GList* list = NULL;
1273 for (size_t i = icons.GetIconCount(); i--;)
1274 list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf());
1275 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1276 g_list_free(list);
1277 }
1278 }
1279
1280 // ----------------------------------------------------------------------------
1281 // frame state: maximized/iconized/normal
1282 // ----------------------------------------------------------------------------
1283
1284 void wxTopLevelWindowGTK::Maximize(bool maximize)
1285 {
1286 if (maximize)
1287 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1288 else
1289 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1290 }
1291
1292 bool wxTopLevelWindowGTK::IsMaximized() const
1293 {
1294 GdkWindow* window = NULL;
1295 if (m_widget)
1296 window = gtk_widget_get_window(m_widget);
1297 return window && (gdk_window_get_state(window) & GDK_WINDOW_STATE_MAXIMIZED);
1298 }
1299
1300 void wxTopLevelWindowGTK::Restore()
1301 {
1302 // "Present" seems similar enough to "restore"
1303 gtk_window_present( GTK_WINDOW( m_widget ) );
1304 }
1305
1306 void wxTopLevelWindowGTK::Iconize( bool iconize )
1307 {
1308 if (iconize)
1309 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1310 else
1311 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1312 }
1313
1314 bool wxTopLevelWindowGTK::IsIconized() const
1315 {
1316 return m_isIconized;
1317 }
1318
1319 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1320 {
1321 if ( iconize != m_isIconized )
1322 {
1323 m_isIconized = iconize;
1324 (void)SendIconizeEvent(iconize);
1325 }
1326 }
1327
1328 void wxTopLevelWindowGTK::AddGrab()
1329 {
1330 if (!m_grabbed)
1331 {
1332 m_grabbed = true;
1333 gtk_grab_add( m_widget );
1334 wxGUIEventLoop().Run();
1335 gtk_grab_remove( m_widget );
1336 }
1337 }
1338
1339 void wxTopLevelWindowGTK::RemoveGrab()
1340 {
1341 if (m_grabbed)
1342 {
1343 gtk_main_quit();
1344 m_grabbed = false;
1345 }
1346 }
1347
1348 bool wxTopLevelWindowGTK::IsActive()
1349 {
1350 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1351 }
1352
1353 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1354 {
1355 bool new_hint_value = false;
1356
1357 // FIXME: This is a workaround to focus handling problem
1358 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle
1359 // hasn't yet been processed, and the internal focus system is not up to date yet.
1360 // YieldFor(wxEVT_CATEGORY_UI) ensures the processing of it (hopefully it
1361 // won't have side effects) - MR
1362 wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI);
1363
1364 if(m_urgency_hint >= 0)
1365 g_source_remove(m_urgency_hint);
1366
1367 m_urgency_hint = -2;
1368
1369 if( gtk_widget_get_realized(m_widget) && !IsActive() )
1370 {
1371 new_hint_value = true;
1372
1373 if (flags & wxUSER_ATTENTION_INFO)
1374 {
1375 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1376 } else {
1377 m_urgency_hint = -1;
1378 }
1379 }
1380
1381 gtk_window_set_urgency_hint(GTK_WINDOW(m_widget), new_hint_value);
1382 }
1383
1384 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1385 {
1386 // Store which styles were changed
1387 long styleChanges = style ^ m_windowStyle;
1388
1389 // Process wxWindow styles. This also updates the internal variable
1390 // Therefore m_windowStyle bits carry now the _new_ style values
1391 wxWindow::SetWindowStyleFlag(style);
1392
1393 // just return for now if widget does not exist yet
1394 if (!m_widget)
1395 return;
1396
1397 if ( styleChanges & wxSTAY_ON_TOP )
1398 {
1399 gtk_window_set_keep_above(GTK_WINDOW(m_widget),
1400 m_windowStyle & wxSTAY_ON_TOP);
1401 }
1402
1403 if ( styleChanges & wxFRAME_NO_TASKBAR )
1404 {
1405 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget),
1406 m_windowStyle & wxFRAME_NO_TASKBAR);
1407 }
1408 }
1409
1410 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1411 {
1412 GdkWindow* window = NULL;
1413 if (m_widget)
1414 window = gtk_widget_get_window(m_widget);
1415 if (window == NULL)
1416 return false;
1417
1418 #ifdef GDK_WINDOWING_X11
1419 Display* dpy = GDK_WINDOW_XDISPLAY(window);
1420 Window win = GDK_WINDOW_XID(window);
1421
1422 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1423 if (alpha == 0xff)
1424 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1425 else
1426 {
1427 long opacity = alpha * 0x1010101L;
1428 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1429 XA_CARDINAL, 32, PropModeReplace,
1430 (unsigned char *) &opacity, 1L);
1431 }
1432 XSync(dpy, False);
1433 return true;
1434 #else // !GDK_WINDOWING_X11
1435 return false;
1436 #endif // GDK_WINDOWING_X11 / !GDK_WINDOWING_X11
1437 }
1438
1439 bool wxTopLevelWindowGTK::CanSetTransparent()
1440 {
1441 // allow to override automatic detection as it's far from perfect
1442 const wxString SYSOPT_TRANSPARENT = "gtk.tlw.can-set-transparent";
1443 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
1444 {
1445 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
1446 }
1447
1448 #ifdef __WXGTK3__
1449 return gtk_widget_is_composited(m_widget) != 0;
1450 #else
1451 #if GTK_CHECK_VERSION(2,10,0)
1452 if (!gtk_check_version(2,10,0))
1453 {
1454 return gtk_widget_is_composited(m_widget) != 0;
1455 }
1456 else
1457 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1458 {
1459 return false;
1460 }
1461 #endif // !__WXGTK3__
1462
1463 #if 0 // Don't be optimistic here for the sake of wxAUI
1464 int opcode, event, error;
1465 // Check for the existence of a RGBA visual instead?
1466 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1467 "Composite", &opcode, &event, &error);
1468 #endif
1469 }
wxWidgets (Impactor)