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


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