src/gtk/toplevel.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        toplevel.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // ============================================================================
  11 // declarations
  12 // ============================================================================
  13
  14 // ----------------------------------------------------------------------------
  15 // headers
  16 // ----------------------------------------------------------------------------
  17
  18 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  19     #pragma implementation "toplevel.h"
  20 #endif
  21
  22 // For compilers that support precompilation, includes "wx.h".
  23 #include "wx/wxprec.h"
  24
  25 #ifdef __VMS
  26 #define XIconifyWindow XICONIFYWINDOW
  27 #endif
  28
  29 #include "wx/defs.h"
  30
  31 #include "wx/log.h"
  32 #include "wx/dialog.h"
  33 #include "wx/control.h"
  34 #include "wx/app.h"
  35 #include "wx/dcclient.h"
  36 #include "wx/gtk/private.h"
  37 #include "wx/timer.h"
  38 #include "wx/settings.h"
  39
  40 #include <glib.h>
  41 #include <gdk/gdk.h>
  42 #include <gtk/gtk.h>
  43 #include <gdk/gdkkeysyms.h>
  44 #include <gdk/gdkx.h>
  45
  46 #include "wx/gtk/win_gtk.h"
  47
  48 #include "wx/unix/utilsx11.h"
  49
  50 // XA_CARDINAL
  51 #include <X11/Xatom.h>
  52
  53 // ----------------------------------------------------------------------------
  54 // idle system
  55 // ----------------------------------------------------------------------------
  56
  57 extern void wxapp_install_idle_handler();
  58 extern bool g_isIdle;
  59
  60 // ----------------------------------------------------------------------------
  61 // data
  62 // ----------------------------------------------------------------------------
  63
  64 extern wxList           wxPendingDelete;
  65
  66 extern int              g_openDialogs;
  67 extern wxWindowGTK     *g_delayedFocus;
  68
  69 // the frame that is currently active (i.e. its child has focus). It is
  70 // used to generate wxActivateEvents
  71 static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;
  72 static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL;
  73
  74 // if we detect that the app has got/lost the focus, we set this variable to
  75 // either TRUE or FALSE and an activate event will be sent during the next
  76 // OnIdle() call and it is reset to -1: this value means that we shouldn't
  77 // send any activate events at all
  78 static int              g_sendActivateEvent = -1;
  79
  80 //-----------------------------------------------------------------------------
  81 // "focus_in_event"
  82 //-----------------------------------------------------------------------------
  83
  84 static gint gtk_frame_focus_in_callback( GtkWidget *widget,
  85                                          GdkEvent *WXUNUSED(event),
  86                                          wxTopLevelWindowGTK *win )
  87 {
  88     if (g_isIdle)
  89         wxapp_install_idle_handler();
  90
  91     switch ( g_sendActivateEvent )
  92     {
  93         case -1:
  94             // we've got focus from outside, synthetize wxActivateEvent
  95             g_sendActivateEvent = 1;
  96             break;
  97
  98         case 0:
  99             // another our window just lost focus, it was already ours before
 100             // - don't send any wxActivateEvent
 101             g_sendActivateEvent = -1;
 102             break;
 103     }
 104
 105     g_activeFrame = win;
 106     g_lastActiveFrame = g_activeFrame;
 107
 108     // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
 109
 110     wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
 111     wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId());
 112     event.SetEventObject(g_activeFrame);
 113     g_activeFrame->GetEventHandler()->ProcessEvent(event);
 114
 115     return FALSE;
 116 }
 117
 118 //-----------------------------------------------------------------------------
 119 // "focus_out_event"
 120 //-----------------------------------------------------------------------------
 121
 122 static gint gtk_frame_focus_out_callback( GtkWidget *widget,
 123                                           GdkEventFocus *WXUNUSED(gdk_event),
 124                                           wxTopLevelWindowGTK *win )
 125 {
 126     if (g_isIdle)
 127         wxapp_install_idle_handler();
 128
 129     // if the focus goes out of our app alltogether, OnIdle() will send
 130     // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
 131     // g_sendActivateEvent to -1
 132     g_sendActivateEvent = 0;
 133
 134     // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
 135
 136     // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
 137
 138     if (g_activeFrame)
 139     {
 140         wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
 141         wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId());
 142         event.SetEventObject(g_activeFrame);
 143         g_activeFrame->GetEventHandler()->ProcessEvent(event);
 144
 145         g_activeFrame = NULL;
 146     }
 147
 148     return FALSE;
 149 }
 150
 151 //-----------------------------------------------------------------------------
 152 // "focus" from m_window
 153 //-----------------------------------------------------------------------------
 154
 155 static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
 156 {
 157     if (g_isIdle)
 158         wxapp_install_idle_handler();
 159
 160     // This disables GTK's tab traversal
 161     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
 162     return TRUE;
 163 }
 164
 165 //-----------------------------------------------------------------------------
 166 // "size_allocate"
 167 //-----------------------------------------------------------------------------
 168
 169 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
 170 {
 171     if (g_isIdle)
 172         wxapp_install_idle_handler();
 173
 174     if (!win->m_hasVMT)
 175         return;
 176
 177     if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
 178     {
 179 /*
 180         wxPrintf( "OnSize from " );
 181         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 182            wxPrintf( win->GetClassInfo()->GetClassName() );
 183         wxPrintf( " %d %d %d %d\n", (int)alloc->x,
 184                                 (int)alloc->y,
 185                                 (int)alloc->width,
 186                                 (int)alloc->height );
 187 */
 188
 189         win->m_width = alloc->width;
 190         win->m_height = alloc->height;
 191         win->GtkUpdateSize();
 192     }
 193 }
 194
 195 //-----------------------------------------------------------------------------
 196 // "delete_event"
 197 //-----------------------------------------------------------------------------
 198
 199 static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win )
 200 {
 201     if (g_isIdle)
 202         wxapp_install_idle_handler();
 203
 204     if (win->IsEnabled() &&
 205         (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
 206          win->IsGrabbed()))
 207         win->Close();
 208
 209     return TRUE;
 210 }
 211
 212
 213 //-----------------------------------------------------------------------------
 214 // "configure_event"
 215 //-----------------------------------------------------------------------------
 216
 217 static gint
 218 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win )
 219 {
 220     if (g_isIdle)
 221         wxapp_install_idle_handler();
 222
 223     if (!win->m_hasVMT || !win->IsShown())
 224         return FALSE;
 225
 226     int x = 0;
 227     int y = 0;
 228     gdk_window_get_root_origin( win->m_widget->window, &x, &y );
 229     win->m_x = x;
 230     win->m_y = y;
 231
 232     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
 233     mevent.SetEventObject( win );
 234     win->GetEventHandler()->ProcessEvent( mevent );
 235
 236     return FALSE;
 237 }
 238
 239 //-----------------------------------------------------------------------------
 240 // "realize" from m_widget
 241 //-----------------------------------------------------------------------------
 242
 243 // we cannot MWM hints and icons before the widget has been realized,
 244 // so we do this directly after realization
 245
 246 static void
 247 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
 248                              wxTopLevelWindowGTK *win )
 249 {
 250     if (g_isIdle)
 251         wxapp_install_idle_handler();
 252
 253     // All this is for Motif Window Manager "hints" and is supposed to be
 254     // recognized by other WM as well. Not tested.
 255     gdk_window_set_decorations(win->m_widget->window,
 256                                (GdkWMDecoration)win->m_gdkDecor);
 257     gdk_window_set_functions(win->m_widget->window,
 258                                (GdkWMFunction)win->m_gdkFunc);
 259
 260     // GTK's shrinking/growing policy
 261     if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
 262         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
 263     else
 264         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 265
 266     // reset the icon
 267     wxIconBundle iconsOld = win->GetIcons();
 268     if ( iconsOld.GetIcon(-1).Ok() )
 269     {
 270         win->SetIcon( wxNullIcon );
 271         win->SetIcons( iconsOld );
 272     }
 273 }
 274
 275 //-----------------------------------------------------------------------------
 276 // "map_event" from m_widget
 277 //-----------------------------------------------------------------------------
 278
 279 static void
 280 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
 281                         GdkEvent * WXUNUSED(event),
 282                         wxTopLevelWindow *win )
 283 {
 284     win->SetIconizeState(FALSE);
 285 }
 286
 287 //-----------------------------------------------------------------------------
 288 // "unmap_event" from m_widget
 289 //-----------------------------------------------------------------------------
 290
 291 static void
 292 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
 293                           GdkEvent * WXUNUSED(event),
 294                           wxTopLevelWindow *win )
 295 {
 296     win->SetIconizeState(TRUE);
 297 }
 298
 299 //-----------------------------------------------------------------------------
 300 // "expose_event" of m_client
 301 //-----------------------------------------------------------------------------
 302
 303 static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
 304 {
 305     GtkPizza *pizza = GTK_PIZZA(widget);
 306
 307     gtk_paint_flat_box (win->m_widget->style,
 308                         pizza->bin_window, GTK_STATE_NORMAL,
 309                         GTK_SHADOW_NONE,
 310                         &gdk_event->area,
 311                         win->m_widget,
 312                         (char *)"base",
 313                         0, 0, -1, -1);
 314
 315     return FALSE;
 316 }
 317
 318 //-----------------------------------------------------------------------------
 319 // "draw" of m_client
 320 //-----------------------------------------------------------------------------
 321
 322 #ifndef __WXGTK20__
 323
 324 static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
 325 {
 326     GtkPizza *pizza = GTK_PIZZA(widget);
 327
 328     gtk_paint_flat_box (win->m_widget->style,
 329                         pizza->bin_window, GTK_STATE_NORMAL,
 330                         GTK_SHADOW_NONE,
 331                         rect,
 332                         win->m_widget,
 333                         (char *)"base",
 334                         0, 0, -1, -1);
 335 }
 336
 337 #endif // GTK+ 1.x
 338
 339 // ----------------------------------------------------------------------------
 340 // wxTopLevelWindowGTK itself
 341 // ----------------------------------------------------------------------------
 342
 343 //-----------------------------------------------------------------------------
 344 // InsertChild for wxTopLevelWindowGTK
 345 //-----------------------------------------------------------------------------
 346
 347 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
 348  * C++ has no virtual methods in a constructor. We have to emulate a
 349  * virtual function here as wxWidgets requires different ways to insert
 350  * a child in container classes. */
 351
 352 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
 353 {
 354     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 355
 356     if (!parent->m_insertInClientArea)
 357     {
 358         // these are outside the client area
 359         wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
 360         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
 361                          GTK_WIDGET(child->m_widget),
 362                          child->m_x,
 363                          child->m_y,
 364                          child->m_width,
 365                          child->m_height );
 366     }
 367     else
 368     {
 369         // these are inside the client area
 370         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 371                          GTK_WIDGET(child->m_widget),
 372                          child->m_x,
 373                          child->m_y,
 374                          child->m_width,
 375                          child->m_height );
 376     }
 377
 378     // resize on OnInternalIdle
 379     parent->GtkUpdateSize();
 380 }
 381
 382 // ----------------------------------------------------------------------------
 383 // wxTopLevelWindowGTK creation
 384 // ----------------------------------------------------------------------------
 385
 386 void wxTopLevelWindowGTK::Init()
 387 {
 388     m_sizeSet = FALSE;
 389     m_miniEdge = 0;
 390     m_miniTitle = 0;
 391     m_mainWidget = (GtkWidget*) NULL;
 392     m_insertInClientArea = TRUE;
 393     m_isIconized = FALSE;
 394     m_fsIsShowing = FALSE;
 395     m_themeEnabled = TRUE;
 396     m_gdkDecor = m_gdkFunc = 0;
 397     m_grabbed = FALSE;
 398 }
 399
 400 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 401                                   wxWindowID id,
 402                                   const wxString& title,
 403                                   const wxPoint& pos,
 404                                   const wxSize& sizeOrig,
 405                                   long style,
 406                                   const wxString &name )
 407 {
 408     // always create a frame of some reasonable, even if arbitrary, size (at
 409     // least for MSW compatibility)
 410     wxSize size = sizeOrig;
 411     size.x = WidthDefault(size.x);
 412     size.y = HeightDefault(size.y);
 413
 414     wxTopLevelWindows.Append( this );
 415
 416     m_needParent = FALSE;
 417
 418     if (!PreCreation( parent, pos, size ) ||
 419         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 420     {
 421         wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
 422         return FALSE;
 423     }
 424
 425     m_title = title;
 426
 427     m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
 428
 429     // NB: m_widget may be !=NULL if it was created by derived class' Create,
 430     //     e.g. in wxTaskBarIconAreaGTK
 431     if (m_widget == NULL)
 432     {
 433         if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 434         {
 435 #ifdef __WXGTK20__
 436             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 437             // Tell WM that this is a dialog window and make it center
 438             // on parent by default (this is what GtkDialog ctor does):
 439             gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 440                                      GDK_WINDOW_TYPE_HINT_DIALOG);
 441             gtk_window_set_position(GTK_WINDOW(m_widget),
 442                                     GTK_WIN_POS_CENTER_ON_PARENT);
 443 #else
 444             m_widget = gtk_window_new(GTK_WINDOW_DIALOG);
 445 #endif
 446         }
 447         else
 448         {
 449             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 450 #ifdef __WXGTK20__
 451             if (style & wxFRAME_TOOL_WINDOW)
 452                 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 453                                          GDK_WINDOW_TYPE_HINT_UTILITY);
 454 #endif
 455
 456         }
 457     }
 458
 459     wxWindow *topParent = wxGetTopLevelParent(m_parent);
 460     if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
 461                       (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
 462                      (style & wxFRAME_FLOAT_ON_PARENT)))
 463     {
 464         gtk_window_set_transient_for( GTK_WINDOW(m_widget),
 465                                       GTK_WINDOW(topParent->m_widget) );
 466     }
 467
 468 #if GTK_CHECK_VERSION(2,2,0)
 469     if (style & wxFRAME_NO_TASKBAR)
 470     {
 471         gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
 472     }
 473 #endif
 474
 475     if (!name.IsEmpty())
 476         gtk_window_set_wmclass( GTK_WINDOW(m_widget), wxGTK_CONV( name ), wxGTK_CONV( name ) );
 477
 478     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
 479     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 480
 481     gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
 482         GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
 483
 484     // m_mainWidget holds the toolbar, the menubar and the client area
 485     m_mainWidget = gtk_pizza_new();
 486     gtk_widget_show( m_mainWidget );
 487     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
 488     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 489
 490     if (m_miniEdge == 0) // wxMiniFrame has its own version.
 491     {
 492        // For m_mainWidget themes
 493        gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event",
 494                 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
 495 #ifndef __WXGTK20__
 496        gtk_signal_connect( GTK_OBJECT(m_mainWidget), "draw",
 497                 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
 498 #endif
 499     }
 500
 501     // m_wxwindow only represents the client area without toolbar and menubar
 502     m_wxwindow = gtk_pizza_new();
 503     gtk_widget_show( m_wxwindow );
 504     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 505
 506     // we donm't allow the frame to get the focus as otherwise
 507     // the frame will grab it at arbitrary focus changes
 508     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 509
 510     if (m_parent) m_parent->AddChild( this );
 511
 512     // the user resized the frame by dragging etc.
 513     gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
 514         GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );
 515
 516     PostCreation();
 517
 518     if ((m_x != -1) || (m_y != -1))
 519         gtk_widget_set_uposition( m_widget, m_x, m_y );
 520
 521     gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 522
 523     //  we cannot set MWM hints and icons before the widget has
 524     //  been realized, so we do this directly after realization
 525     gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
 526                         GTK_SIGNAL_FUNC(gtk_frame_realized_callback), (gpointer) this );
 527
 528     // the only way to get the window size is to connect to this event
 529     gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
 530         GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
 531
 532     // map and unmap for iconized state
 533     gtk_signal_connect( GTK_OBJECT(m_widget), "map_event",
 534         GTK_SIGNAL_FUNC(gtk_frame_map_callback), (gpointer)this );
 535     gtk_signal_connect( GTK_OBJECT(m_widget), "unmap_event",
 536         GTK_SIGNAL_FUNC(gtk_frame_unmap_callback), (gpointer)this );
 537
 538     // the only way to get the window size is to connect to this event
 539     gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
 540         GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
 541
 542     // disable native tab traversal
 543     gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
 544         GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this );
 545
 546     // activation
 547     gtk_signal_connect( GTK_OBJECT(m_widget), "focus_in_event",
 548         GTK_SIGNAL_FUNC(gtk_frame_focus_in_callback), (gpointer)this );
 549     gtk_signal_connect( GTK_OBJECT(m_widget), "focus_out_event",
 550         GTK_SIGNAL_FUNC(gtk_frame_focus_out_callback), (gpointer)this );
 551
 552     // decorations
 553     if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
 554     {
 555         m_gdkDecor = 0;
 556         m_gdkFunc = 0;
 557     }
 558     else
 559     {
 560         m_gdkDecor = (long) GDK_DECOR_BORDER;
 561         m_gdkFunc = (long) GDK_FUNC_MOVE;
 562
 563         // All this is for Motif Window Manager "hints" and is supposed to be
 564         // recognized by other WMs as well.
 565         if ((style & wxCAPTION) != 0)
 566         {
 567             m_gdkDecor |= GDK_DECOR_TITLE;
 568         }
 569         if ((style & wxCLOSE_BOX) != 0)
 570         {
 571             m_gdkFunc |= GDK_FUNC_CLOSE;
 572         }
 573         if ((style & wxSYSTEM_MENU) != 0)
 574         {
 575             m_gdkDecor |= GDK_DECOR_MENU;
 576         }
 577         if ((style & wxMINIMIZE_BOX) != 0)
 578         {
 579             m_gdkFunc |= GDK_FUNC_MINIMIZE;
 580             m_gdkDecor |= GDK_DECOR_MINIMIZE;
 581         }
 582         if ((style & wxMAXIMIZE_BOX) != 0)
 583         {
 584             m_gdkFunc |= GDK_FUNC_MAXIMIZE;
 585             m_gdkDecor |= GDK_DECOR_MAXIMIZE;
 586         }
 587         if ((style & wxRESIZE_BORDER) != 0)
 588         {
 589            m_gdkFunc |= GDK_FUNC_RESIZE;
 590            m_gdkDecor |= GDK_DECOR_RESIZEH;
 591         }
 592     }
 593
 594     return TRUE;
 595 }
 596
 597 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
 598 {
 599     if (m_grabbed)
 600     {
 601         wxASSERT_MSG( FALSE, _T("Window still grabbed"));
 602         RemoveGrab();
 603     }
 604
 605     m_isBeingDeleted = TRUE;
 606
 607     // it may also be GtkScrolledWindow in the case of an MDI child
 608     if (GTK_IS_WINDOW(m_widget))
 609     {
 610         gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
 611     }
 612
 613     if (g_activeFrame == this)
 614         g_activeFrame = NULL;
 615     if (g_lastActiveFrame == this)
 616         g_lastActiveFrame = NULL;
 617 }
 618
 619
 620
 621 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
 622 {
 623     if (show == m_fsIsShowing) return FALSE; // return what?
 624
 625     m_fsIsShowing = show;
 626
 627     GdkWindow *window = m_widget->window;
 628     wxX11FullScreenMethod method =
 629         wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
 630                                  (WXWindow)GDK_ROOT_WINDOW());
 631
 632     if (show)
 633     {
 634         m_fsSaveFlag = style;
 635         GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
 636         GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
 637
 638         int screen_width,screen_height;
 639         wxDisplaySize( &screen_width, &screen_height );
 640
 641                 gint client_x, client_y, root_x, root_y;
 642                 gint width, height;
 643
 644         if (method != wxX11_FS_WMSPEC)
 645         {
 646             // don't do it always, Metacity hates it
 647             m_fsSaveGdkFunc = m_gdkFunc;
 648             m_fsSaveGdkDecor = m_gdkDecor;
 649             m_gdkFunc = m_gdkDecor = 0;
 650             gdk_window_set_decorations(window, (GdkWMDecoration)0);
 651             gdk_window_set_functions(window, (GdkWMFunction)0);
 652         }
 653
 654                 gdk_window_get_origin (m_widget->window, &root_x, &root_y);
 655                 gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
 656                                          &width, &height, NULL);
 657
 658                 gdk_window_move_resize (m_widget->window, -client_x, -client_y,
 659                                         screen_width + 1, screen_height + 1);
 660
 661         wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
 662                                 (WXWindow)GDK_ROOT_WINDOW(),
 663                                 (WXWindow)GDK_WINDOW_XWINDOW(window),
 664                                 show, &m_fsSaveFrame, method);
 665     }
 666     else
 667     {
 668         if (method != wxX11_FS_WMSPEC)
 669         {
 670             // don't do it always, Metacity hates it
 671             m_gdkFunc = m_fsSaveGdkFunc;
 672             m_gdkDecor = m_fsSaveGdkDecor;
 673             gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
 674             gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
 675         }
 676
 677         wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
 678                                 (WXWindow)GDK_ROOT_WINDOW(),
 679                                 (WXWindow)GDK_WINDOW_XWINDOW(window),
 680                                 show, &m_fsSaveFrame, method);
 681
 682         SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
 683                 m_fsSaveFrame.width, m_fsSaveFrame.height);
 684     }
 685
 686
 687     return TRUE;
 688 }
 689
 690 // ----------------------------------------------------------------------------
 691 // overridden wxWindow methods
 692 // ----------------------------------------------------------------------------
 693
 694 bool wxTopLevelWindowGTK::Show( bool show )
 695 {
 696     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 697
 698     if (show && !m_sizeSet)
 699     {
 700         /* by calling GtkOnSize here, we don't have to call
 701            either after showing the frame, which would entail
 702            much ugly flicker or from within the size_allocate
 703            handler, because GTK 1.1.X forbids that. */
 704
 705         GtkOnSize( m_x, m_y, m_width, m_height );
 706     }
 707
 708     return wxWindow::Show( show );
 709 }
 710
 711 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 712 {
 713     wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
 714 }
 715
 716 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 717 {
 718     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 719
 720     // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
 721     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 722
 723     // avoid recursions
 724     if (m_resizing)
 725         return;
 726     m_resizing = TRUE;
 727
 728     int old_x = m_x;
 729     int old_y = m_y;
 730
 731     int old_width = m_width;
 732     int old_height = m_height;
 733
 734     if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
 735     {
 736         if (x != -1) m_x = x;
 737         if (y != -1) m_y = y;
 738     }
 739     else
 740     {
 741         m_x = x;
 742         m_y = y;
 743     }
 744     if (width != -1) m_width = width;
 745     if (height != -1) m_height = height;
 746
 747 /*
 748     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
 749     {
 750         if (width == -1) m_width = 80;
 751     }
 752
 753     if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
 754     {
 755        if (height == -1) m_height = 26;
 756     }
 757 */
 758
 759     int minWidth = GetMinWidth(),
 760         minHeight = GetMinHeight(),
 761         maxWidth = GetMaxWidth(),
 762         maxHeight = GetMaxHeight();
 763
 764 #ifdef __WXGPE__
 765     // GPE's window manager doesn't like size hints
 766     // at all, esp. when the user has to use the
 767     // virtual keyboard.
 768     minWidth = -1;
 769     minHeight = -1;
 770     maxWidth = -1;
 771     maxHeight = -1;
 772 #endif
 773
 774     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 775     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 776     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 777     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 778
 779     if ((m_x != -1) || (m_y != -1))
 780     {
 781         if ((m_x != old_x) || (m_y != old_y))
 782         {
 783             gtk_widget_set_uposition( m_widget, m_x, m_y );
 784         }
 785     }
 786
 787     if ((m_width != old_width) || (m_height != old_height))
 788     {
 789         if (m_widget->window)
 790             gdk_window_resize( m_widget->window, m_width, m_height );
 791         else
 792             gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 793
 794         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 795            done either directly before the frame is shown or in idle time
 796            so that different calls to SetSize() don't lead to flicker. */
 797         m_sizeSet = FALSE;
 798     }
 799
 800     m_resizing = FALSE;
 801 }
 802
 803 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
 804 {
 805     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 806
 807     wxWindow::DoGetClientSize( width, height );
 808     if (height)
 809     {
 810         // mini edge
 811         *height -= m_miniEdge*2 + m_miniTitle;
 812     }
 813     if (width)
 814     {
 815         *width -= m_miniEdge*2;
 816     }
 817 }
 818
 819 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
 820 {
 821     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 822
 823     DoSetSize(-1, -1,
 824               width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0);
 825 }
 826
 827 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 828                                      int width, int height )
 829 {
 830     // due to a bug in gtk, x,y are always 0
 831     // m_x = x;
 832     // m_y = y;
 833
 834     // avoid recursions
 835     if (m_resizing) return;
 836     m_resizing = TRUE;
 837
 838     if ( m_wxwindow == NULL ) return;
 839
 840     m_width = width;
 841     m_height = height;
 842
 843     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 844        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 845        set in wxFrame::Create so it is used to check what kind of frame we
 846        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 847        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 848        importantly) m_mainWidget */
 849
 850     int minWidth = GetMinWidth(),
 851         minHeight = GetMinHeight(),
 852         maxWidth = GetMaxWidth(),
 853         maxHeight = GetMaxHeight();
 854
 855 #ifdef __WXGPE__
 856     // GPE's window manager doesn't like size hints
 857     // at all, esp. when the user has to use the
 858     // virtual keyboard.
 859     minWidth = -1;
 860     minHeight = -1;
 861     maxWidth = -1;
 862     maxHeight = -1;
 863 #endif
 864
 865     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 866     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 867     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 868     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 869
 870     if (m_mainWidget)
 871     {
 872         // set size hints
 873         gint            flag = 0; // GDK_HINT_POS;
 874         GdkGeometry     geom;
 875
 876         if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
 877         if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
 878
 879         geom.min_width = minWidth;
 880         geom.min_height = minHeight;
 881
 882             // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
 883             // maxHeight or maxWidth is set, we must set them both, else the
 884             // remaining -1 will be taken literally.
 885
 886             // I'm certain this also happens elsewhere, and is the probable
 887             // cause of other such things as:
 888             // Gtk-WARNING **: gtk_widget_size_allocate():
 889             //       attempt to allocate widget with width 65535 and height 600
 890             // but I don't have time to track them all now..
 891             //
 892             // Really we need to encapulate all this height/width business and
 893             // stop any old method from ripping at the members directly and
 894             // scattering -1's without regard for who might resolve them later.
 895
 896         geom.max_width = ( maxHeight == -1 ) ? maxWidth
 897                          : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
 898                            : maxWidth ;
 899
 900         geom.max_height = ( maxWidth == -1 ) ? maxHeight    // ( == -1 here )
 901                           : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
 902                             : maxHeight ;
 903
 904         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
 905                                        (GtkWidget*) NULL,
 906                                        &geom,
 907                                        (GdkWindowHints) flag );
 908
 909         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
 910          * menubar, the toolbar and the client area, which is represented by
 911          * m_wxwindow.
 912          * this hurts in the eye, but I don't want to call SetSize()
 913          * because I don't want to call any non-native functions here. */
 914
 915         int client_x = m_miniEdge;
 916         int client_y = m_miniEdge + m_miniTitle;
 917         int client_w = m_width - 2*m_miniEdge;
 918         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
 919
 920         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 921                               m_wxwindow,
 922                               client_x, client_y, client_w, client_h );
 923     }
 924     else
 925     {
 926         // If there is no m_mainWidget between m_widget and m_wxwindow there
 927         // is no need to set the size or position of m_wxwindow.
 928     }
 929
 930     m_sizeSet = TRUE;
 931
 932     // send size event to frame
 933     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
 934     event.SetEventObject( this );
 935     GetEventHandler()->ProcessEvent( event );
 936
 937     m_resizing = FALSE;
 938 }
 939
 940 void wxTopLevelWindowGTK::OnInternalIdle()
 941 {
 942     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
 943     {
 944         GtkOnSize( m_x, m_y, m_width, m_height );
 945
 946         // we'll come back later
 947         if (g_isIdle)
 948             wxapp_install_idle_handler();
 949         return;
 950     }
 951
 952     // set the focus if not done yet and if we can already do it
 953     if ( GTK_WIDGET_REALIZED(m_wxwindow) )
 954     {
 955         if ( g_delayedFocus &&
 956              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
 957         {
 958             wxLogTrace(_T("focus"),
 959                        _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
 960                        g_delayedFocus->GetClassInfo()->GetClassName(),
 961                        g_delayedFocus->GetLabel().c_str());
 962
 963             g_delayedFocus->SetFocus();
 964             g_delayedFocus = NULL;
 965         }
 966     }
 967
 968     wxWindow::OnInternalIdle();
 969
 970     // Synthetize activate events.
 971     if ( g_sendActivateEvent != -1 )
 972     {
 973         bool activate = g_sendActivateEvent != 0;
 974
 975         // if (!activate) wxPrintf( wxT("de") );
 976         // wxPrintf( wxT("activate\n") );
 977
 978         // do it only once
 979         g_sendActivateEvent = -1;
 980
 981         wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
 982     }
 983 }
 984
 985 // ----------------------------------------------------------------------------
 986 // frame title/icon
 987 // ----------------------------------------------------------------------------
 988
 989 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
 990 {
 991     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 992
 993     m_title = title;
 994     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
 995 }
 996
 997 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
 998 {
 999     SetIcons( wxIconBundle( icon ) );
1000 }
1001
1002 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1003 {
1004     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1005
1006     wxTopLevelWindowBase::SetIcons( icons );
1007
1008 #ifdef __WXGTK20__
1009     GList *list = NULL;
1010     size_t max = icons.m_icons.GetCount();
1011
1012     for (size_t i = 0; i < max; i++)
1013     {
1014         if (icons.m_icons[i].Ok())
1015         {
1016             list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
1017         }
1018     }
1019     gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1020     g_list_free(list);
1021
1022 #else // !__WXGTK20__
1023     GdkWindow* window = m_widget->window;
1024     if (!window)
1025         return;
1026
1027     wxIcon icon = icons.GetIcon(-1);
1028     if (icon.Ok())
1029     {
1030         wxMask *mask = icon.GetMask();
1031         GdkBitmap *bm = (GdkBitmap *) NULL;
1032         if (mask) bm = mask->GetBitmap();
1033
1034         gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
1035     }
1036
1037     wxSetIconsX11( (WXDisplay*)GDK_WINDOW_XDISPLAY( window ),
1038                    (WXWindow)GDK_WINDOW_XWINDOW( window ), icons );
1039 #endif // !__WXGTK20__
1040 }
1041
1042 // ----------------------------------------------------------------------------
1043 // frame state: maximized/iconized/normal
1044 // ----------------------------------------------------------------------------
1045
1046 void wxTopLevelWindowGTK::Maximize(bool maximize)
1047 {
1048 #ifdef __WXGTK20__
1049     if (maximize)
1050         gtk_window_maximize( GTK_WINDOW( m_widget ) );
1051     else
1052         gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1053 #else
1054     wxFAIL_MSG( _T("not implemented") );
1055 #endif
1056 }
1057
1058 bool wxTopLevelWindowGTK::IsMaximized() const
1059 {
1060 #ifdef __WXGTK20__
1061     if(!m_widget->window)
1062         return false;
1063
1064     return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1065 #else
1066   //    wxFAIL_MSG( _T("not implemented") );
1067
1068     // This is an approximation
1069     return FALSE;
1070 #endif
1071 }
1072
1073 void wxTopLevelWindowGTK::Restore()
1074 {
1075 #ifdef __WXGTK20__
1076     // "Present" seems similar enough to "restore"
1077     gtk_window_present( GTK_WINDOW( m_widget ) );
1078 #else
1079     wxFAIL_MSG( _T("not implemented") );
1080 #endif
1081 }
1082
1083 void wxTopLevelWindowGTK::Iconize( bool iconize )
1084 {
1085 #ifdef __WXGTK20__
1086     if (iconize)
1087         gtk_window_iconify( GTK_WINDOW( m_widget ) );
1088     else
1089         gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1090 #else
1091    if (iconize)
1092    {
1093        GdkWindow *window = m_widget->window;
1094
1095        // you should do it later, for example from OnCreate() handler
1096        wxCHECK_RET( window, _T("frame not created yet - can't iconize") );
1097
1098        XIconifyWindow( GDK_WINDOW_XDISPLAY( window ),
1099                        GDK_WINDOW_XWINDOW( window ),
1100                        DefaultScreen( GDK_DISPLAY() ) );
1101    }
1102 #endif
1103 }
1104
1105 bool wxTopLevelWindowGTK::IsIconized() const
1106 {
1107     return m_isIconized;
1108 }
1109
1110 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1111 {
1112     if ( iconize != m_isIconized )
1113     {
1114         m_isIconized = iconize;
1115         (void)SendIconizeEvent(iconize);
1116     }
1117 }
1118
1119 void wxTopLevelWindowGTK::AddGrab()
1120 {
1121     if (!m_grabbed)
1122     {
1123         m_grabbed = TRUE;
1124         gtk_grab_add( m_widget );
1125         gtk_main();
1126         gtk_grab_remove( m_widget );
1127     }
1128 }
1129
1130 void wxTopLevelWindowGTK::RemoveGrab()
1131 {
1132     if (m_grabbed)
1133     {
1134         gtk_main_quit();
1135         m_grabbed = FALSE;
1136     }
1137 }
1138
1139
1140 // helper
1141 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1142 {
1143     if (window)
1144     {
1145         if (region.IsEmpty())
1146         {
1147             gdk_window_shape_combine_mask(window, NULL, 0, 0);
1148         }
1149         else
1150         {
1151 #ifdef __WXGTK20__
1152         gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1153 #else
1154         wxBitmap bmp = region.ConvertToBitmap();
1155         bmp.SetMask(new wxMask(bmp, *wxBLACK));
1156         GdkBitmap* mask = bmp.GetMask()->GetBitmap();
1157         gdk_window_shape_combine_mask(window, mask, 0, 0);
1158 #endif
1159         return TRUE;
1160         }
1161     }
1162     return FALSE;
1163 }
1164
1165
1166 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1167 {
1168     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
1169                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1170
1171     GdkWindow *window = NULL;
1172     if (m_wxwindow)
1173     {
1174         window = GTK_PIZZA(m_wxwindow)->bin_window;
1175         do_shape_combine_region(window, region);
1176     }
1177     window = m_widget->window;
1178     return do_shape_combine_region(window, region);
1179 }
1180
1181 bool wxTopLevelWindowGTK::IsActive()
1182 {
1183     return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1184 }
1185