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


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