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