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


a0d2574eb5d5a863a3df4ec4f7257c2ac64b657b
[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 if ((m_x != -1) || (m_y != -1))
912 {
913 if ((m_x != old_x) || (m_y != old_y))
914 {
915 gtk_widget_set_uposition( m_widget, m_x, m_y );
916 }
917 }
918
919 if ((m_width != old_width) || (m_height != old_height))
920 {
921 if (m_widget->window)
922 gdk_window_resize( m_widget->window, m_width, m_height );
923 else
924 gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
925
926 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
927 done either directly before the frame is shown or in idle time
928 so that different calls to SetSize() don't lead to flicker. */
929 m_sizeSet = false;
930 }
931
932 m_resizing = false;
933 }
934
935 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
936 {
937 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
938
939 if (height)
940 {
941 *height = m_height - 2 * m_miniEdge - m_miniTitle;
942 if (*height < 0)
943 *height = 0;
944 }
945 if (width)
946 {
947 *width = m_width - 2 * m_miniEdge;
948 if (*width < 0)
949 *width = 0;
950 }
951 }
952
953 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
954 {
955 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
956
957 DoSetSize(-1, -1,
958 width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0);
959 }
960
961 void wxTopLevelWindowGTK::SetMinSize(const wxSize& minSize)
962 {
963 SetSizeHints( minSize.x, minSize.y, GetMaxWidth(), GetMaxHeight() );
964 }
965
966 void wxTopLevelWindowGTK::SetMaxSize(const wxSize& maxSize)
967 {
968 SetSizeHints( GetMinWidth(), GetMinHeight(), maxSize.x, maxSize.y );
969 }
970
971 void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
972 int maxW, int maxH,
973 int incW, int incH )
974 {
975 wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
976
977 if (m_widget)
978 {
979 int minWidth = GetMinWidth(),
980 minHeight = GetMinHeight(),
981 maxWidth = GetMaxWidth(),
982 maxHeight = GetMaxHeight();
983
984 // set size hints
985 gint flag = 0; // GDK_HINT_POS;
986 GdkGeometry geom;
987
988 if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
989 if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
990
991 geom.min_width = minWidth;
992 geom.min_height = minHeight;
993
994 // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
995 // maxHeight or maxWidth is set, we must set them both, else the
996 // remaining -1 will be taken literally.
997
998 // I'm certain this also happens elsewhere, and is the probable
999 // cause of other such things as:
1000 // Gtk-WARNING **: gtk_widget_size_allocate():
1001 // attempt to allocate widget with width 65535 and height 600
1002 // but I don't have time to track them all now..
1003 //
1004 // Really we need to encapulate all this height/width business and
1005 // stop any old method from ripping at the members directly and
1006 // scattering -1's without regard for who might resolve them later.
1007
1008 geom.max_width = ( maxHeight == -1 ) ? maxWidth
1009 : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
1010 : maxWidth ;
1011
1012 geom.max_height = ( maxWidth == -1 ) ? maxHeight // ( == -1 here )
1013 : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
1014 : maxHeight ;
1015
1016 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
1017 (GtkWidget*) NULL,
1018 &geom,
1019 (GdkWindowHints) flag );
1020 }
1021 }
1022
1023
1024 void wxTopLevelWindowGTK::GtkOnSize()
1025 {
1026 // avoid recursions
1027 if (m_resizing) return;
1028 m_resizing = true;
1029
1030 if ( m_wxwindow == NULL ) return;
1031
1032 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
1033 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
1034 set in wxFrame::Create so it is used to check what kind of frame we
1035 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
1036 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
1037 importantly) m_mainWidget */
1038
1039 int minWidth = GetMinWidth(),
1040 minHeight = GetMinHeight(),
1041 maxWidth = GetMaxWidth(),
1042 maxHeight = GetMaxHeight();
1043
1044 #ifdef __WXGPE__
1045 // GPE's window manager doesn't like size hints
1046 // at all, esp. when the user has to use the
1047 // virtual keyboard.
1048 minWidth = -1;
1049 minHeight = -1;
1050 maxWidth = -1;
1051 maxHeight = -1;
1052 #endif
1053
1054 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
1055 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
1056 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
1057 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
1058
1059 if (m_mainWidget)
1060 {
1061 // m_mainWidget holds the menubar, the toolbar and the client area,
1062 // which is represented by m_wxwindow.
1063 int client_x = m_miniEdge;
1064 int client_y = m_miniEdge + m_miniTitle;
1065 int client_w = m_width - 2*m_miniEdge;
1066 int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1067 if (client_w < 0)
1068 client_w = 0;
1069 if (client_h < 0)
1070 client_h = 0;
1071
1072 // Let the parent perform the resize
1073 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1074 m_wxwindow,
1075 client_x, client_y, client_w, client_h );
1076 }
1077 else
1078 {
1079 // If there is no m_mainWidget between m_widget and m_wxwindow there
1080 // is no need to set the size or position of m_wxwindow.
1081 }
1082
1083 m_sizeSet = true;
1084
1085 // send size event to frame
1086 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1087 event.SetEventObject( this );
1088 GetEventHandler()->ProcessEvent( event );
1089
1090 m_resizing = false;
1091 }
1092
1093 void wxTopLevelWindowGTK::OnInternalIdle()
1094 {
1095 if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1096 {
1097 GtkOnSize();
1098
1099 // we'll come back later
1100 if (g_isIdle)
1101 wxapp_install_idle_handler();
1102 return;
1103 }
1104
1105 // set the focus if not done yet and if we can already do it
1106 if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1107 {
1108 if ( g_delayedFocus &&
1109 wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1110 {
1111 wxLogTrace(_T("focus"),
1112 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1113 g_delayedFocus->GetClassInfo()->GetClassName(),
1114 g_delayedFocus->GetLabel().c_str());
1115
1116 g_delayedFocus->SetFocus();
1117 g_delayedFocus = NULL;
1118 }
1119 }
1120
1121 wxWindow::OnInternalIdle();
1122
1123 // Synthetize activate events.
1124 if ( g_sendActivateEvent != -1 )
1125 {
1126 bool activate = g_sendActivateEvent != 0;
1127
1128 // if (!activate) wxPrintf( wxT("de") );
1129 // wxPrintf( wxT("activate\n") );
1130
1131 // do it only once
1132 g_sendActivateEvent = -1;
1133
1134 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1135 }
1136 }
1137
1138 // ----------------------------------------------------------------------------
1139 // frame title/icon
1140 // ----------------------------------------------------------------------------
1141
1142 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1143 {
1144 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1145
1146 if ( title == m_title )
1147 return;
1148
1149 m_title = title;
1150
1151 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1152 }
1153
1154 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
1155 {
1156 SetIcons( wxIconBundle( icon ) );
1157 }
1158
1159 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1160 {
1161 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1162
1163 wxTopLevelWindowBase::SetIcons( icons );
1164
1165 GList *list = NULL;
1166 size_t max = icons.m_icons.GetCount();
1167
1168 for (size_t i = 0; i < max; i++)
1169 {
1170 if (icons.m_icons[i].Ok())
1171 {
1172 list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
1173 }
1174 }
1175 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1176 g_list_free(list);
1177 }
1178
1179 // ----------------------------------------------------------------------------
1180 // frame state: maximized/iconized/normal
1181 // ----------------------------------------------------------------------------
1182
1183 void wxTopLevelWindowGTK::Maximize(bool maximize)
1184 {
1185 if (maximize)
1186 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1187 else
1188 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1189 }
1190
1191 bool wxTopLevelWindowGTK::IsMaximized() const
1192 {
1193 if(!m_widget->window)
1194 return false;
1195
1196 return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1197 }
1198
1199 void wxTopLevelWindowGTK::Restore()
1200 {
1201 // "Present" seems similar enough to "restore"
1202 gtk_window_present( GTK_WINDOW( m_widget ) );
1203 }
1204
1205 void wxTopLevelWindowGTK::Iconize( bool iconize )
1206 {
1207 if (iconize)
1208 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1209 else
1210 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1211 }
1212
1213 bool wxTopLevelWindowGTK::IsIconized() const
1214 {
1215 return m_isIconized;
1216 }
1217
1218 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1219 {
1220 if ( iconize != m_isIconized )
1221 {
1222 m_isIconized = iconize;
1223 (void)SendIconizeEvent(iconize);
1224 }
1225 }
1226
1227 void wxTopLevelWindowGTK::AddGrab()
1228 {
1229 if (!m_grabbed)
1230 {
1231 m_grabbed = true;
1232 gtk_grab_add( m_widget );
1233 wxEventLoop().Run();
1234 gtk_grab_remove( m_widget );
1235 }
1236 }
1237
1238 void wxTopLevelWindowGTK::RemoveGrab()
1239 {
1240 if (m_grabbed)
1241 {
1242 gtk_main_quit();
1243 m_grabbed = false;
1244 }
1245 }
1246
1247
1248 // helper
1249 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1250 {
1251 if (window)
1252 {
1253 if (region.IsEmpty())
1254 {
1255 gdk_window_shape_combine_mask(window, NULL, 0, 0);
1256 }
1257 else
1258 {
1259 gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1260 return true;
1261 }
1262 }
1263 return false;
1264 }
1265
1266
1267 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1268 {
1269 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1270 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1271
1272 GdkWindow *window = NULL;
1273 if (m_wxwindow)
1274 {
1275 window = GTK_PIZZA(m_wxwindow)->bin_window;
1276 do_shape_combine_region(window, region);
1277 }
1278 window = m_widget->window;
1279 return do_shape_combine_region(window, region);
1280 }
1281
1282 bool wxTopLevelWindowGTK::IsActive()
1283 {
1284 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1285 }
1286
1287 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1288 {
1289 bool new_hint_value = false;
1290
1291 // FIXME: This is a workaround to focus handling problem
1292 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1293 // yet been processed, and the internal focus system is not up to date yet.
1294 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1295 ::wxYieldIfNeeded();
1296
1297 if(m_urgency_hint >= 0)
1298 g_source_remove(m_urgency_hint);
1299
1300 m_urgency_hint = -2;
1301
1302 if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1303 {
1304 new_hint_value = true;
1305
1306 if (flags & wxUSER_ATTENTION_INFO)
1307 {
1308 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1309 } else {
1310 m_urgency_hint = -1;
1311 }
1312 }
1313
1314 #if GTK_CHECK_VERSION(2,7,0)
1315 if(!gtk_check_version(2,7,0))
1316 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1317 else
1318 #endif
1319 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1320 }
1321
1322 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1323 {
1324 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1325 // Store which styles were changed
1326 long styleChanges = style ^ m_windowStyle;
1327 #endif
1328
1329 // Process wxWindow styles. This also updates the internal variable
1330 // Therefore m_windowStyle bits carry now the _new_ style values
1331 wxWindow::SetWindowStyleFlag(style);
1332
1333 // just return for now if widget does not exist yet
1334 if (!m_widget)
1335 return;
1336
1337 #ifdef __WXGTK24__
1338 if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1339 gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1340 #endif // GTK+ 2.4
1341 #if GTK_CHECK_VERSION(2,2,0)
1342 if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1343 {
1344 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1345 }
1346 #endif // GTK+ 2.2
1347 }
1348
1349 #include <X11/Xlib.h>
1350
1351 /* Get the X Window between child and the root window.
1352 This should usually be the WM managed XID */
1353 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1354 {
1355 Window root, parent;
1356 Window* children;
1357 unsigned int nchildren;
1358
1359 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1360 XFree(children);
1361
1362 while (parent != root) {
1363 child = parent;
1364 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1365 XFree(children);
1366 }
1367
1368 return child;
1369 }
1370
1371 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1372 {
1373 if (!m_widget || !m_widget->window)
1374 return false;
1375
1376 Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1377 // We need to get the X Window that has the root window as the immediate parent
1378 // and m_widget->window as a child. This should be the X Window that the WM manages and
1379 // from which the opacity property is checked from.
1380 Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1381
1382 unsigned int opacity = alpha * 0x1010101;
1383
1384 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1385 if (alpha == 0xff)
1386 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1387 else
1388 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1389 XA_CARDINAL, 32, PropModeReplace,
1390 (unsigned char *) &opacity, 1L);
1391 XSync(dpy, False);
1392 return true;
1393 }
1394
1395 bool wxTopLevelWindowGTK::CanSetTransparent()
1396 {
1397 #if GTK_CHECK_VERSION(2,10,0)
1398 if (!gtk_check_version(2,10,0))
1399 {
1400 if (gtk_widget_is_composited (m_widget))
1401 return true;
1402 }
1403 else
1404 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1405 {
1406 return false;
1407 }
1408
1409 #if 0 // Don't be optimistic here for the sake of wxAUI
1410 int opcode, event, error;
1411 // Check for the existence of a RGBA visual instead?
1412 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1413 "Composite", &opcode, &event, &error);
1414 #endif
1415 }
wxWidgets (Impactor)