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
  39 #include <glib.h>
  40 #include <gdk/gdk.h>
  41 #include <gtk/gtk.h>
  42 #include <gdk/gdkkeysyms.h>
  43 #include <gdk/gdkx.h>
  44
  45 #include "wx/gtk/win_gtk.h"
  46
  47 #include "wx/unix/utilsx11.h"
  48
  49 // XA_CARDINAL
  50 #include <X11/Xatom.h>
  51
  52 // ----------------------------------------------------------------------------
  53 // idle system
  54 // ----------------------------------------------------------------------------
  55
  56 extern void wxapp_install_idle_handler();
  57 extern bool g_isIdle;
  58
  59 // ----------------------------------------------------------------------------
  60 // data
  61 // ----------------------------------------------------------------------------
  62
  63 extern wxList         wxPendingDelete;
  64
  65 extern int            g_openDialogs;
  66 extern wxWindowGTK   *g_delayedFocus;
  67
  68 //-----------------------------------------------------------------------------
  69 // "focus" from m_window
  70 //-----------------------------------------------------------------------------
  71
  72 static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
  73 {
  74     if (g_isIdle)
  75         wxapp_install_idle_handler();
  76
  77     // This disables GTK's tab traversal
  78     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
  79     return TRUE;
  80 }
  81
  82 //-----------------------------------------------------------------------------
  83 // "size_allocate"
  84 //-----------------------------------------------------------------------------
  85
  86 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
  87 {
  88     if (g_isIdle)
  89         wxapp_install_idle_handler();
  90
  91     if (!win->m_hasVMT)
  92         return;
  93
  94     if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
  95     {
  96 /*
  97         wxPrintf( "OnSize from " );
  98         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
  99            wxPrintf( win->GetClassInfo()->GetClassName() );
 100         wxPrintf( " %d %d %d %d\n", (int)alloc->x,
 101                                 (int)alloc->y,
 102                                 (int)alloc->width,
 103                                 (int)alloc->height );
 104 */
 105
 106         win->m_width = alloc->width;
 107         win->m_height = alloc->height;
 108         win->m_queuedFullRedraw = TRUE;
 109         win->GtkUpdateSize();
 110     }
 111 }
 112
 113 //-----------------------------------------------------------------------------
 114 // "delete_event"
 115 //-----------------------------------------------------------------------------
 116
 117 static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win )
 118 {
 119     if (g_isIdle)
 120         wxapp_install_idle_handler();
 121
 122     if (win->IsEnabled() &&
 123         (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
 124          win->IsGrabbed()))
 125         win->Close();
 126
 127     return TRUE;
 128 }
 129
 130
 131 //-----------------------------------------------------------------------------
 132 // "configure_event"
 133 //-----------------------------------------------------------------------------
 134
 135 static gint
 136 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win )
 137 {
 138     if (g_isIdle)
 139         wxapp_install_idle_handler();
 140
 141     if (!win->m_hasVMT || !win->IsShown())
 142         return FALSE;
 143
 144     int x = 0;
 145     int y = 0;
 146     gdk_window_get_root_origin( win->m_widget->window, &x, &y );
 147     win->m_x = x;
 148     win->m_y = y;
 149
 150     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
 151     mevent.SetEventObject( win );
 152     win->GetEventHandler()->ProcessEvent( mevent );
 153
 154     return FALSE;
 155 }
 156
 157 //-----------------------------------------------------------------------------
 158 // "realize" from m_widget
 159 //-----------------------------------------------------------------------------
 160
 161 // we cannot MWM hints and icons before the widget has been realized,
 162 // so we do this directly after realization
 163
 164 static void
 165 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
 166                              wxTopLevelWindowGTK *win )
 167 {
 168     if (g_isIdle)
 169         wxapp_install_idle_handler();
 170
 171     // All this is for Motif Window Manager "hints" and is supposed to be
 172     // recognized by other WM as well. Not tested.
 173     gdk_window_set_decorations(win->m_widget->window,
 174                                (GdkWMDecoration)win->m_gdkDecor);
 175     gdk_window_set_functions(win->m_widget->window,
 176                                (GdkWMFunction)win->m_gdkFunc);
 177
 178     // GTK's shrinking/growing policy
 179     if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
 180         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
 181     else
 182         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 183
 184     // reset the icon
 185     wxIconBundle iconsOld = win->GetIcons();
 186     if ( iconsOld.GetIcon(-1).Ok() )
 187     {
 188         win->SetIcon( wxNullIcon );
 189         win->SetIcons( iconsOld );
 190     }
 191 }
 192
 193 //-----------------------------------------------------------------------------
 194 // "map_event" from m_widget
 195 //-----------------------------------------------------------------------------
 196
 197 static void
 198 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
 199                         GdkEvent * WXUNUSED(event),
 200                         wxTopLevelWindow *win )
 201 {
 202     win->SetIconizeState(FALSE);
 203 }
 204
 205 //-----------------------------------------------------------------------------
 206 // "unmap_event" from m_widget
 207 //-----------------------------------------------------------------------------
 208
 209 static void
 210 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
 211                           GdkEvent * WXUNUSED(event),
 212                           wxTopLevelWindow *win )
 213 {
 214     win->SetIconizeState(TRUE);
 215 }
 216
 217 //-----------------------------------------------------------------------------
 218 // "expose_event" of m_client
 219 //-----------------------------------------------------------------------------
 220
 221 static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
 222 {
 223     GtkPizza *pizza = GTK_PIZZA(widget);
 224
 225     gtk_paint_flat_box (win->m_widget->style,
 226                         pizza->bin_window, GTK_STATE_NORMAL,
 227                         GTK_SHADOW_NONE,
 228                         &gdk_event->area,
 229                         win->m_widget,
 230                         (char *)"base",
 231                         0, 0, -1, -1);
 232
 233     return FALSE;
 234 }
 235
 236 //-----------------------------------------------------------------------------
 237 // "draw" of m_client
 238 //-----------------------------------------------------------------------------
 239
 240 #ifndef __WXGTK20__
 241
 242 static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
 243 {
 244     GtkPizza *pizza = GTK_PIZZA(widget);
 245
 246     gtk_paint_flat_box (win->m_widget->style,
 247                         pizza->bin_window, GTK_STATE_NORMAL,
 248                         GTK_SHADOW_NONE,
 249                         rect,
 250                         win->m_widget,
 251                         (char *)"base",
 252                         0, 0, -1, -1);
 253 }
 254
 255 #endif // GTK+ 1.x
 256
 257 // ----------------------------------------------------------------------------
 258 // wxTopLevelWindowGTK itself
 259 // ----------------------------------------------------------------------------
 260
 261 //-----------------------------------------------------------------------------
 262 // InsertChild for wxTopLevelWindowGTK
 263 //-----------------------------------------------------------------------------
 264
 265 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
 266  * C++ has no virtual methods in a constructor. We have to emulate a
 267  * virtual function here as wxWindows requires different ways to insert
 268  * a child in container classes. */
 269
 270 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
 271 {
 272     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 273
 274     if (!parent->m_insertInClientArea)
 275     {
 276         // these are outside the client area
 277         wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
 278         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
 279                          GTK_WIDGET(child->m_widget),
 280                          child->m_x,
 281                          child->m_y,
 282                          child->m_width,
 283                          child->m_height );
 284     }
 285     else
 286     {
 287         // these are inside the client area
 288         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 289                          GTK_WIDGET(child->m_widget),
 290                          child->m_x,
 291                          child->m_y,
 292                          child->m_width,
 293                          child->m_height );
 294     }
 295
 296     // resize on OnInternalIdle
 297     parent->GtkUpdateSize();
 298 }
 299
 300 // ----------------------------------------------------------------------------
 301 // wxTopLevelWindowGTK creation
 302 // ----------------------------------------------------------------------------
 303
 304 void wxTopLevelWindowGTK::Init()
 305 {
 306     m_sizeSet = FALSE;
 307     m_miniEdge = 0;
 308     m_miniTitle = 0;
 309     m_mainWidget = (GtkWidget*) NULL;
 310     m_insertInClientArea = TRUE;
 311     m_isIconized = FALSE;
 312     m_fsIsShowing = FALSE;
 313     m_themeEnabled = TRUE;
 314     m_gdkDecor = m_gdkFunc = 0;
 315     m_grabbed = FALSE;
 316 }
 317
 318 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 319                                   wxWindowID id,
 320                                   const wxString& title,
 321                                   const wxPoint& pos,
 322                                   const wxSize& sizeOrig,
 323                                   long style,
 324                                   const wxString &name )
 325 {
 326     // always create a frame of some reasonable, even if arbitrary, size (at
 327     // least for MSW compatibility)
 328     wxSize size = sizeOrig;
 329     if ( size.x == -1 || size.y == -1 )
 330     {
 331         wxSize sizeDpy = wxGetDisplaySize();
 332         if ( size.x == -1 )
 333             size.x = sizeDpy.x / 3;
 334         if ( size.y == -1 )
 335             size.y = sizeDpy.y / 5;
 336     }
 337
 338     wxTopLevelWindows.Append( this );
 339
 340     m_needParent = FALSE;
 341
 342     if (!PreCreation( parent, pos, size ) ||
 343         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 344     {
 345         wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
 346         return FALSE;
 347     }
 348
 349     m_title = title;
 350
 351     m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
 352
 353     GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
 354
 355     if (style & wxFRAME_TOOL_WINDOW)
 356         win_type = GTK_WINDOW_POPUP;
 357
 358     if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 359     {
 360         // there is no more GTK_WINDOW_DIALOG in 2.0
 361 #ifdef __WXGTK20__
 362         win_type = GTK_WINDOW_TOPLEVEL;
 363 #else
 364         win_type = GTK_WINDOW_DIALOG;
 365 #endif
 366     }
 367
 368     m_widget = gtk_window_new( win_type );
 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     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 656     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 657     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 658     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 659
 660     if ((m_x != -1) || (m_y != -1))
 661     {
 662         if ((m_x != old_x) || (m_y != old_y))
 663         {
 664             gtk_widget_set_uposition( m_widget, m_x, m_y );
 665         }
 666     }
 667
 668     if ((m_width != old_width) || (m_height != old_height))
 669     {
 670         if (m_widget->window)
 671             gdk_window_resize( m_widget->window, m_width, m_height );
 672         else
 673             gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 674
 675         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 676            done either directly before the frame is shown or in idle time
 677            so that different calls to SetSize() don't lead to flicker. */
 678         m_sizeSet = FALSE;
 679     }
 680
 681     m_resizing = FALSE;
 682 }
 683
 684 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
 685 {
 686     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 687
 688     wxWindow::DoGetClientSize( width, height );
 689     if (height)
 690     {
 691         // mini edge
 692         *height -= m_miniEdge*2 + m_miniTitle;
 693     }
 694     if (width)
 695     {
 696         *width -= m_miniEdge*2;
 697     }
 698 }
 699
 700 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
 701 {
 702     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 703
 704     DoSetSize(-1, -1,
 705               width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0);
 706 }
 707
 708 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 709                                      int width, int height )
 710 {
 711     // due to a bug in gtk, x,y are always 0
 712     // m_x = x;
 713     // m_y = y;
 714
 715     // avoid recursions
 716     if (m_resizing) return;
 717     m_resizing = TRUE;
 718
 719     if ( m_wxwindow == NULL ) return;
 720
 721     m_width = width;
 722     m_height = height;
 723
 724     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 725        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 726        set in wxFrame::Create so it is used to check what kind of frame we
 727        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 728        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 729        importantly) m_mainWidget */
 730
 731     int minWidth = GetMinWidth(),
 732         minHeight = GetMinHeight(),
 733         maxWidth = GetMaxWidth(),
 734         maxHeight = GetMaxHeight();
 735
 736     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 737     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 738     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 739     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 740
 741     if (m_mainWidget)
 742     {
 743         // set size hints
 744         gint            flag = 0; // GDK_HINT_POS;
 745         GdkGeometry     geom;
 746
 747         if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
 748         if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
 749
 750         geom.min_width = minWidth;
 751         geom.min_height = minHeight;
 752
 753             // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
 754             // maxHeight or maxWidth is set, we must set them both, else the
 755             // remaining -1 will be taken literally.
 756
 757             // I'm certain this also happens elsewhere, and is the probable
 758             // cause of other such things as:
 759             // Gtk-WARNING **: gtk_widget_size_allocate():
 760             //       attempt to allocate widget with width 65535 and height 600
 761             // but I don't have time to track them all now..
 762             //
 763             // Really we need to encapulate all this height/width business and
 764             // stop any old method from ripping at the members directly and
 765             // scattering -1's without regard for who might resolve them later.
 766
 767         geom.max_width = ( maxHeight == -1 ) ? maxWidth
 768                          : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
 769                            : maxWidth ;
 770
 771         geom.max_height = ( maxWidth == -1 ) ? maxHeight    // ( == -1 here )
 772                           : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
 773                             : maxHeight ;
 774
 775         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
 776                                        (GtkWidget*) NULL,
 777                                        &geom,
 778                                        (GdkWindowHints) flag );
 779
 780         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
 781          * menubar, the toolbar and the client area, which is represented by
 782          * m_wxwindow.
 783          * this hurts in the eye, but I don't want to call SetSize()
 784          * because I don't want to call any non-native functions here. */
 785
 786         int client_x = m_miniEdge;
 787         int client_y = m_miniEdge + m_miniTitle;
 788         int client_w = m_width - 2*m_miniEdge;
 789         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
 790
 791         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 792                               m_wxwindow,
 793                               client_x, client_y, client_w, client_h );
 794     }
 795     else
 796     {
 797         // If there is no m_mainWidget between m_widget and m_wxwindow there
 798         // is no need to set the size or position of m_wxwindow.
 799     }
 800
 801     m_sizeSet = TRUE;
 802
 803     // send size event to frame
 804     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
 805     event.SetEventObject( this );
 806     GetEventHandler()->ProcessEvent( event );
 807
 808     m_resizing = FALSE;
 809 }
 810
 811 void wxTopLevelWindowGTK::OnInternalIdle()
 812 {
 813     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
 814     {
 815         GtkOnSize( m_x, m_y, m_width, m_height );
 816
 817         // we'll come back later
 818         if (g_isIdle)
 819             wxapp_install_idle_handler();
 820         return;
 821     }
 822
 823     // set the focus if not done yet and if we can already do it
 824     if ( GTK_WIDGET_REALIZED(m_wxwindow) )
 825     {
 826         if ( g_delayedFocus &&
 827              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
 828         {
 829             wxLogTrace(_T("focus"),
 830                        _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
 831                        g_delayedFocus->GetClassInfo()->GetClassName(),
 832                        g_delayedFocus->GetLabel().c_str());
 833
 834             g_delayedFocus->SetFocus();
 835             g_delayedFocus = NULL;
 836         }
 837     }
 838
 839     wxWindow::OnInternalIdle();
 840 }
 841
 842 // ----------------------------------------------------------------------------
 843 // frame title/icon
 844 // ----------------------------------------------------------------------------
 845
 846 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
 847 {
 848     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 849
 850     m_title = title;
 851     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
 852 }
 853
 854 void wxTopLevelWindowGTK::DoSetIcon( const wxIcon &icon )
 855 {
 856     if ( !icon.Ok() )
 857         return;
 858
 859     if (!m_widget->window)
 860         return;
 861
 862     wxMask *mask = icon.GetMask();
 863     GdkBitmap *bm = (GdkBitmap *) NULL;
 864     if (mask) bm = mask->GetBitmap();
 865
 866     gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
 867 }
 868
 869 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
 870 {
 871     SetIcons( wxIconBundle( icon ) );
 872 }
 873
 874 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
 875 {
 876     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 877     GdkWindow* window = m_widget->window;
 878
 879     wxTopLevelWindowBase::SetIcons( icons );
 880
 881     DoSetIcon( icons.GetIcon( -1 ) );
 882     if ( window )
 883     {
 884         wxSetIconsX11( (WXDisplay*)GDK_WINDOW_XDISPLAY( window ),
 885                        (WXWindow)GDK_WINDOW_XWINDOW( window ), icons );
 886     }
 887 }
 888
 889 // ----------------------------------------------------------------------------
 890 // frame state: maximized/iconized/normal
 891 // ----------------------------------------------------------------------------
 892
 893 void wxTopLevelWindowGTK::Maximize(bool maximize)
 894 {
 895 #ifdef __WXGTK20__
 896     if (maximize)
 897         gtk_window_maximize( GTK_WINDOW( m_widget ) );
 898     else
 899         gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
 900 #else
 901     wxFAIL_MSG( _T("not implemented") );
 902 #endif
 903 }
 904
 905 bool wxTopLevelWindowGTK::IsMaximized() const
 906 {
 907   //    wxFAIL_MSG( _T("not implemented") );
 908
 909     // This is an approximation
 910     return FALSE;
 911 }
 912
 913 void wxTopLevelWindowGTK::Restore()
 914 {
 915 #ifdef __GTK20__
 916     // "Present" seems similar enough to "restore"
 917     gtk_window_present( GTK_WINDOW( m_widget ) );
 918 #else
 919     wxFAIL_MSG( _T("not implemented") );
 920 #endif
 921 }
 922
 923 void wxTopLevelWindowGTK::Iconize( bool iconize )
 924 {
 925 #ifdef __WXGTK20__
 926     if (iconize)
 927         gtk_window_iconify( GTK_WINDOW( m_widget ) );
 928     else
 929         gtk_window_deiconify( GTK_WINDOW( m_widget ) );
 930 #else
 931    if (iconize)
 932    {
 933        GdkWindow *window = m_widget->window;
 934
 935        // you should do it later, for example from OnCreate() handler
 936        wxCHECK_RET( window, _T("frame not created yet - can't iconize") );
 937
 938        XIconifyWindow( GDK_WINDOW_XDISPLAY( window ),
 939                        GDK_WINDOW_XWINDOW( window ),
 940                        DefaultScreen( GDK_DISPLAY() ) );
 941    }
 942 #endif
 943 }
 944
 945 bool wxTopLevelWindowGTK::IsIconized() const
 946 {
 947     return m_isIconized;
 948 }
 949
 950 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
 951 {
 952     if ( iconize != m_isIconized )
 953     {
 954         m_isIconized = iconize;
 955         (void)SendIconizeEvent(iconize);
 956     }
 957 }
 958
 959 void wxTopLevelWindowGTK::AddGrab()
 960 {
 961     if (!m_grabbed)
 962     {
 963         m_grabbed = TRUE;
 964         gtk_grab_add( m_widget );
 965         gtk_main();
 966         gtk_grab_remove( m_widget );
 967     }
 968 }
 969
 970 void wxTopLevelWindowGTK::RemoveGrab()
 971 {
 972     if (m_grabbed)
 973     {
 974         gtk_main_quit();
 975         m_grabbed = FALSE;
 976     }
 977 }
 978
 979
 980 // helper
 981 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
 982 {
 983     if (window)
 984     {
 985         if (region.IsEmpty())
 986         {
 987             gdk_window_shape_combine_mask(window, NULL, 0, 0);
 988         }
 989         else
 990         {
 991 #ifdef __WXGTK20__
 992         gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
 993 #else
 994         wxBitmap bmp = region.ConvertToBitmap();
 995         bmp.SetMask(new wxMask(bmp, *wxBLACK));
 996         GdkBitmap* mask = bmp.GetMask()->GetBitmap();
 997         gdk_window_shape_combine_mask(window, mask, 0, 0);
 998 #endif
 999         return TRUE;
1000         }
1001     }
1002     return FALSE;
1003 }
1004
1005
1006 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1007 {
1008     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
1009                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1010
1011     GdkWindow *window = NULL;
1012     if (m_wxwindow)
1013     {
1014         window = GTK_PIZZA(m_wxwindow)->bin_window;
1015         do_shape_combine_region(window, region);
1016     }
1017     window = m_widget->window;
1018     return do_shape_combine_region(window, region);
1019 }
1020
1021 // vi:sts=4:sw=4:et