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