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


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