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


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