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 #ifdef __GNUG__
  19     #pragma implementation "toplevel.h"
  20 #endif
  21
  22 #ifdef __VMS
  23 #define XIconifyWindow XICONIFYWINDOW
  24 #endif
  25
  26 #include "wx/defs.h"
  27
  28 #include "wx/dialog.h"
  29 #include "wx/control.h"
  30 #include "wx/app.h"
  31 #include "wx/dcclient.h"
  32
  33 #include <glib.h>
  34 #include <gdk/gdk.h>
  35 #include <gtk/gtk.h>
  36 #include <gdk/gdkkeysyms.h>
  37 #include <gdk/gdkx.h>
  38
  39 #include "wx/gtk/win_gtk.h"
  40
  41 #include "wx/unix/utilsx11.h"
  42
  43 // ----------------------------------------------------------------------------
  44 // idle system
  45 // ----------------------------------------------------------------------------
  46
  47 extern void wxapp_install_idle_handler();
  48 extern bool g_isIdle;
  49
  50 // ----------------------------------------------------------------------------
  51 // data
  52 // ----------------------------------------------------------------------------
  53
  54 extern wxList         wxPendingDelete;
  55
  56 extern int            g_openDialogs;
  57 extern wxWindowGTK   *g_delayedFocus;
  58
  59 //-----------------------------------------------------------------------------
  60 // "focus" from m_window
  61 //-----------------------------------------------------------------------------
  62
  63 static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
  64 {
  65     if (g_isIdle)
  66         wxapp_install_idle_handler();
  67
  68     // This disables GTK's tab traversal
  69     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
  70     return TRUE;
  71 }
  72
  73 //-----------------------------------------------------------------------------
  74 // "size_allocate"
  75 //-----------------------------------------------------------------------------
  76
  77 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
  78 {
  79     if (g_isIdle)
  80         wxapp_install_idle_handler();
  81
  82     if (!win->m_hasVMT)
  83         return;
  84
  85     if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
  86     {
  87 /*
  88         wxPrintf( "OnSize from " );
  89         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
  90            wxPrintf( win->GetClassInfo()->GetClassName() );
  91         wxPrintf( " %d %d %d %d\n", (int)alloc->x,
  92                                 (int)alloc->y,
  93                                 (int)alloc->width,
  94                                 (int)alloc->height );
  95 */
  96
  97         win->m_width = alloc->width;
  98         win->m_height = alloc->height;
  99         win->m_queuedFullRedraw = TRUE;
 100         win->GtkUpdateSize();
 101     }
 102 }
 103
 104 //-----------------------------------------------------------------------------
 105 // "delete_event"
 106 //-----------------------------------------------------------------------------
 107
 108 static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win )
 109 {
 110     if (g_isIdle)
 111         wxapp_install_idle_handler();
 112
 113     if (win->IsEnabled() &&
 114         (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)))
 115         win->Close();
 116
 117     return TRUE;
 118 }
 119
 120
 121 //-----------------------------------------------------------------------------
 122 // "configure_event"
 123 //-----------------------------------------------------------------------------
 124
 125 static gint
 126 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win )
 127 {
 128     if (g_isIdle)
 129         wxapp_install_idle_handler();
 130
 131     if (!win->m_hasVMT || !win->IsShown())
 132         return FALSE;
 133
 134     int x = 0;
 135     int y = 0;
 136     gdk_window_get_root_origin( win->m_widget->window, &x, &y );
 137     win->m_x = x;
 138     win->m_y = y;
 139
 140     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
 141     mevent.SetEventObject( win );
 142     win->GetEventHandler()->ProcessEvent( mevent );
 143
 144     return FALSE;
 145 }
 146
 147 //-----------------------------------------------------------------------------
 148 // "realize" from m_widget
 149 //-----------------------------------------------------------------------------
 150
 151 // we cannot MWM hints and icons before the widget has been realized,
 152 // so we do this directly after realization
 153
 154 static void
 155 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
 156                              wxTopLevelWindowGTK *win )
 157 {
 158     if (g_isIdle)
 159         wxapp_install_idle_handler();
 160
 161     // All this is for Motif Window Manager "hints" and is supposed to be
 162     // recognized by other WM as well. Not tested.
 163     gdk_window_set_decorations(win->m_widget->window,
 164                                (GdkWMDecoration)win->m_gdkDecor);
 165     gdk_window_set_functions(win->m_widget->window,
 166                                (GdkWMFunction)win->m_gdkFunc);
 167
 168     // GTK's shrinking/growing policy
 169     if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
 170         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
 171     else
 172         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 173
 174     // reset the icon
 175     wxIconBundle iconsOld = win->GetIcons();
 176     if ( iconsOld.GetIcon(-1).Ok() )
 177     {
 178         win->SetIcon( wxNullIcon );
 179         win->SetIcons( iconsOld );
 180     }
 181 }
 182
 183 //-----------------------------------------------------------------------------
 184 // "map_event" from m_widget
 185 //-----------------------------------------------------------------------------
 186
 187 static void
 188 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
 189                         GdkEvent * WXUNUSED(event),
 190                         wxTopLevelWindow *win )
 191 {
 192     win->SetIconizeState(FALSE);
 193 }
 194
 195 //-----------------------------------------------------------------------------
 196 // "unmap_event" from m_widget
 197 //-----------------------------------------------------------------------------
 198
 199 static void
 200 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
 201                           GdkEvent * WXUNUSED(event),
 202                           wxTopLevelWindow *win )
 203 {
 204     win->SetIconizeState(TRUE);
 205 }
 206
 207 //-----------------------------------------------------------------------------
 208 // "expose_event" of m_client
 209 //-----------------------------------------------------------------------------
 210
 211 static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
 212 {
 213     GtkPizza *pizza = GTK_PIZZA(widget);
 214
 215     gtk_paint_flat_box (win->m_widget->style,
 216                         pizza->bin_window, GTK_STATE_NORMAL,
 217                         GTK_SHADOW_NONE,
 218                         &gdk_event->area,
 219                         win->m_widget,
 220                         (char *)"base",
 221                         0, 0, -1, -1);
 222
 223     return TRUE;
 224 }
 225
 226 //-----------------------------------------------------------------------------
 227 // "draw" of m_client
 228 //-----------------------------------------------------------------------------
 229
 230 #ifndef __WXGTK20__
 231
 232 static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
 233 {
 234     GtkPizza *pizza = GTK_PIZZA(widget);
 235
 236     gtk_paint_flat_box (win->m_widget->style,
 237                         pizza->bin_window, GTK_STATE_NORMAL,
 238                         GTK_SHADOW_NONE,
 239                         rect,
 240                         win->m_widget,
 241                         (char *)"base",
 242                         0, 0, -1, -1);
 243 }
 244
 245 #endif // GTK+ 1.x
 246
 247 // ----------------------------------------------------------------------------
 248 // wxTopLevelWindowGTK itself
 249 // ----------------------------------------------------------------------------
 250
 251 //-----------------------------------------------------------------------------
 252 // InsertChild for wxTopLevelWindowGTK
 253 //-----------------------------------------------------------------------------
 254
 255 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
 256  * C++ has no virtual methods in a constructor. We have to emulate a
 257  * virtual function here as wxWindows requires different ways to insert
 258  * a child in container classes. */
 259
 260 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
 261 {
 262     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 263
 264     if (!parent->m_insertInClientArea)
 265     {
 266         // these are outside the client area
 267         wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
 268         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
 269                          GTK_WIDGET(child->m_widget),
 270                          child->m_x,
 271                          child->m_y,
 272                          child->m_width,
 273                          child->m_height );
 274     }
 275     else
 276     {
 277         // these are inside the client area
 278         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 279                          GTK_WIDGET(child->m_widget),
 280                          child->m_x,
 281                          child->m_y,
 282                          child->m_width,
 283                          child->m_height );
 284     }
 285
 286     // resize on OnInternalIdle
 287     parent->GtkUpdateSize();
 288 }
 289
 290 // ----------------------------------------------------------------------------
 291 // wxTopLevelWindowGTK creation
 292 // ----------------------------------------------------------------------------
 293
 294 void wxTopLevelWindowGTK::Init()
 295 {
 296     m_sizeSet = FALSE;
 297     m_miniEdge = 0;
 298     m_miniTitle = 0;
 299     m_mainWidget = (GtkWidget*) NULL;
 300     m_insertInClientArea = TRUE;
 301     m_isFrame = TRUE;
 302     m_isIconized = FALSE;
 303     m_fsIsShowing = FALSE;
 304     m_themeEnabled = TRUE;
 305     m_gdkDecor = m_gdkFunc = 0;
 306 }
 307
 308 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 309                                   wxWindowID id,
 310                                   const wxString& title,
 311                                   const wxPoint& pos,
 312                                   const wxSize& sizeOrig,
 313                                   long style,
 314                                   const wxString &name )
 315 {
 316     // always create a frame of some reasonable, even if arbitrary, size (at
 317     // least for MSW compatibility)
 318     wxSize size = sizeOrig;
 319     if ( size.x == -1 || size.y == -1 )
 320     {
 321         wxSize sizeDpy = wxGetDisplaySize();
 322         if ( size.x == -1 )
 323             size.x = sizeDpy.x / 3;
 324         if ( size.y == -1 )
 325             size.y = sizeDpy.y / 5;
 326     }
 327
 328     wxTopLevelWindows.Append( this );
 329
 330     m_needParent = FALSE;
 331
 332     if (!PreCreation( parent, pos, size ) ||
 333         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 334     {
 335         wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
 336         return FALSE;
 337     }
 338
 339     m_title = title;
 340
 341     m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
 342
 343     GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
 344
 345     if (style & wxFRAME_TOOL_WINDOW)
 346         win_type = GTK_WINDOW_POPUP;
 347
 348     if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 349     {
 350         // there is no more GTK_WINDOW_DIALOG in 2.0
 351 #ifdef __WXGTK20__
 352         win_type = GTK_WINDOW_TOPLEVEL;
 353 #else
 354         win_type = GTK_WINDOW_DIALOG;
 355 #endif
 356     }
 357
 358     m_widget = gtk_window_new( win_type );
 359
 360     if (m_parent && (GTK_IS_WINDOW(m_parent->m_widget)) &&
 361         (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG))
 362     {
 363         gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
 364     }
 365
 366     if (!name.IsEmpty())
 367         gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
 368
 369     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 370     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 371
 372     gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
 373         GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
 374
 375     // m_mainWidget holds the toolbar, the menubar and the client area
 376     m_mainWidget = gtk_pizza_new();
 377     gtk_widget_show( m_mainWidget );
 378     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
 379     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 380
 381     // for m_mainWidget themes
 382     gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event",
 383                 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
 384 #ifndef __WXGTK20__
 385     gtk_signal_connect( GTK_OBJECT(m_mainWidget), "draw",
 386                 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
 387 #endif
 388
 389     // m_wxwindow only represents the client area without toolbar and menubar
 390     m_wxwindow = gtk_pizza_new();
 391     gtk_widget_show( m_wxwindow );
 392     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 393
 394     // we donm't allow the frame to get the focus as otherwise
 395     // the frame will grab it at arbitrary focus changes
 396     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 397
 398     if (m_parent) m_parent->AddChild( this );
 399
 400     // the user resized the frame by dragging etc.
 401     gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
 402         GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );
 403
 404     PostCreation();
 405
 406     if ((m_x != -1) || (m_y != -1))
 407         gtk_widget_set_uposition( m_widget, m_x, m_y );
 408
 409     gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 410
 411     //  we cannot set MWM hints and icons before the widget has
 412     //  been realized, so we do this directly after realization
 413     gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
 414                         GTK_SIGNAL_FUNC(gtk_frame_realized_callback), (gpointer) this );
 415
 416     // the only way to get the window size is to connect to this event
 417     gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
 418         GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
 419
 420     // map and unmap for iconized state
 421     gtk_signal_connect( GTK_OBJECT(m_widget), "map_event",
 422         GTK_SIGNAL_FUNC(gtk_frame_map_callback), (gpointer)this );
 423     gtk_signal_connect( GTK_OBJECT(m_widget), "unmap_event",
 424         GTK_SIGNAL_FUNC(gtk_frame_unmap_callback), (gpointer)this );
 425
 426     // the only way to get the window size is to connect to this event
 427     gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
 428         GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
 429
 430     // disable native tab traversal
 431     gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
 432         GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this );
 433
 434     // decorations
 435     if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
 436     {
 437         m_gdkDecor = 0;
 438         m_gdkFunc = 0;
 439     }
 440     else
 441     {
 442         m_gdkDecor = (long) GDK_DECOR_BORDER;
 443         m_gdkFunc = (long) GDK_FUNC_MOVE;
 444
 445         // All this is for Motif Window Manager "hints" and is supposed to be
 446         // recognized by other WMs as well.
 447         if ((style & wxCAPTION) != 0)
 448             m_gdkDecor |= GDK_DECOR_TITLE;
 449         if ((style & wxSYSTEM_MENU) != 0)
 450         {
 451             m_gdkFunc |= GDK_FUNC_CLOSE;
 452             m_gdkDecor |= GDK_DECOR_MENU;
 453         }
 454         if ((style & wxMINIMIZE_BOX) != 0)
 455         {
 456             m_gdkFunc |= GDK_FUNC_MINIMIZE;
 457             m_gdkDecor |= GDK_DECOR_MINIMIZE;
 458         }
 459         if ((style & wxMAXIMIZE_BOX) != 0)
 460         {
 461             m_gdkFunc |= GDK_FUNC_MAXIMIZE;
 462             m_gdkDecor |= GDK_DECOR_MAXIMIZE;
 463         }
 464         if ((style & wxRESIZE_BORDER) != 0)
 465         {
 466            m_gdkFunc |= GDK_FUNC_RESIZE;
 467            m_gdkDecor |= GDK_DECOR_RESIZEH;
 468         }
 469     }
 470
 471     return TRUE;
 472 }
 473
 474 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
 475 {
 476     m_isBeingDeleted = TRUE;
 477
 478     // it may also be GtkScrolledWindow in the case of an MDI child
 479     if (GTK_IS_WINDOW(m_widget))
 480     {
 481         gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
 482     }
 483
 484     wxTopLevelWindows.DeleteObject( this );
 485
 486     if (wxTheApp->GetTopWindow() == this)
 487         wxTheApp->SetTopWindow( (wxWindow*) NULL );
 488
 489     if ((wxTopLevelWindows.Number() == 0) &&
 490         (wxTheApp->GetExitOnFrameDelete()))
 491     {
 492         wxTheApp->ExitMainLoop();
 493     }
 494 }
 495
 496 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
 497 {
 498     if (show == m_fsIsShowing) return FALSE; // return what?
 499
 500     m_fsIsShowing = show;
 501
 502     if (show)
 503     {
 504         m_fsSaveGdkFunc = m_gdkFunc;
 505         m_fsSaveGdkDecor = m_gdkDecor;
 506         m_fsSaveFlag = style;
 507         GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
 508         GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
 509
 510         gtk_widget_hide( m_widget );
 511         gtk_widget_unrealize( m_widget );
 512
 513         m_gdkDecor = (long) GDK_DECOR_BORDER;
 514         m_gdkFunc = (long) GDK_FUNC_MOVE;
 515
 516         int x;
 517         int y;
 518         wxDisplaySize( &x, &y );
 519         SetSize( 0, 0, x, y );
 520
 521         gtk_widget_realize( m_widget );
 522         gtk_widget_show( m_widget );
 523     }
 524     else
 525     {
 526         gtk_widget_hide( m_widget );
 527         gtk_widget_unrealize( m_widget );
 528
 529         m_gdkFunc = m_fsSaveGdkFunc;
 530         m_gdkDecor = m_fsSaveGdkDecor;
 531
 532         SetSize( m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height );
 533
 534         gtk_widget_realize( m_widget );
 535         gtk_widget_show( m_widget );
 536     }
 537
 538     return TRUE;
 539 }
 540
 541 // ----------------------------------------------------------------------------
 542 // overridden wxWindow methods
 543 // ----------------------------------------------------------------------------
 544
 545 bool wxTopLevelWindowGTK::Show( bool show )
 546 {
 547     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 548
 549     if (show && !m_sizeSet)
 550     {
 551         /* by calling GtkOnSize here, we don't have to call
 552            either after showing the frame, which would entail
 553            much ugly flicker or from within the size_allocate
 554            handler, because GTK 1.1.X forbids that. */
 555
 556         GtkOnSize( m_x, m_y, m_width, m_height );
 557     }
 558
 559     return wxWindow::Show( show );
 560 }
 561
 562 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 563 {
 564     wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
 565 }
 566
 567 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 568 {
 569     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 570
 571     // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
 572     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 573
 574     // avoid recursions
 575     if (m_resizing)
 576         return;
 577     m_resizing = TRUE;
 578
 579     int old_x = m_x;
 580     int old_y = m_y;
 581
 582     int old_width = m_width;
 583     int old_height = m_height;
 584
 585     if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
 586     {
 587         if (x != -1) m_x = x;
 588         if (y != -1) m_y = y;
 589         if (width != -1) m_width = width;
 590         if (height != -1) m_height = height;
 591     }
 592     else
 593     {
 594         m_x = x;
 595         m_y = y;
 596         m_width = width;
 597         m_height = height;
 598     }
 599
 600 /*
 601     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
 602     {
 603         if (width == -1) m_width = 80;
 604     }
 605
 606     if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
 607     {
 608        if (height == -1) m_height = 26;
 609     }
 610 */
 611
 612     int minWidth = GetMinWidth(),
 613         minHeight = GetMinHeight(),
 614         maxWidth = GetMaxWidth(),
 615         maxHeight = GetMaxHeight();
 616
 617     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 618     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 619     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 620     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 621
 622     if ((m_x != -1) || (m_y != -1))
 623     {
 624         if ((m_x != old_x) || (m_y != old_y))
 625         {
 626             gtk_widget_set_uposition( m_widget, m_x, m_y );
 627         }
 628     }
 629
 630     if ((m_width != old_width) || (m_height != old_height))
 631     {
 632         if (m_widget->window)
 633             gdk_window_resize( m_widget->window, m_width, m_height );
 634         else
 635             gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 636
 637         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 638            done either directly before the frame is shown or in idle time
 639            so that different calls to SetSize() don't lead to flicker. */
 640         m_sizeSet = FALSE;
 641     }
 642
 643     m_resizing = FALSE;
 644 }
 645
 646 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
 647 {
 648     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 649
 650     wxWindow::DoGetClientSize( width, height );
 651     if (height)
 652     {
 653         // mini edge
 654         *height -= m_miniEdge*2 + m_miniTitle;
 655     }
 656     if (width)
 657     {
 658         *width -= m_miniEdge*2;
 659     }
 660 }
 661
 662 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
 663 {
 664     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 665
 666     DoSetSize(-1, -1,
 667               width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0);
 668 }
 669
 670 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 671                                      int width, int height )
 672 {
 673     // due to a bug in gtk, x,y are always 0
 674     // m_x = x;
 675     // m_y = y;
 676
 677     // avoid recursions
 678     if (m_resizing) return;
 679     m_resizing = TRUE;
 680
 681     if ( m_wxwindow == NULL ) return;
 682
 683     m_width = width;
 684     m_height = height;
 685
 686     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 687        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 688        set in wxFrame::Create so it is used to check what kind of frame we
 689        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 690        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 691        importantly) m_mainWidget */
 692
 693     int minWidth = GetMinWidth(),
 694         minHeight = GetMinHeight(),
 695         maxWidth = GetMaxWidth(),
 696         maxHeight = GetMaxHeight();
 697
 698     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 699     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 700     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 701     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 702
 703     if (m_mainWidget)
 704     {
 705         // set size hints
 706         gint flag = 0; // GDK_HINT_POS;
 707         if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
 708         if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
 709         GdkGeometry geom;
 710         geom.min_width = minWidth;
 711         geom.min_height = minHeight;
 712         geom.max_width = maxWidth;
 713         geom.max_height = maxHeight;
 714         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
 715                                        (GtkWidget*) NULL,
 716                                        &geom,
 717                                        (GdkWindowHints) flag );
 718
 719         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
 720          * menubar, the toolbar and the client area, which is represented by
 721          * m_wxwindow.
 722          * this hurts in the eye, but I don't want to call SetSize()
 723          * because I don't want to call any non-native functions here. */
 724
 725         int client_x = m_miniEdge;
 726         int client_y = m_miniEdge + m_miniTitle;
 727         int client_w = m_width - 2*m_miniEdge;
 728         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
 729         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 730                               m_wxwindow,
 731                               client_x, client_y, client_w, client_h );
 732     }
 733     else
 734     {
 735         // If there is no m_mainWidget between m_widget and m_wxwindow there
 736         // is no need to set the size or position of m_wxwindow.
 737     }
 738
 739     m_sizeSet = TRUE;
 740
 741     // send size event to frame
 742     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
 743     event.SetEventObject( this );
 744     GetEventHandler()->ProcessEvent( event );
 745
 746     m_resizing = FALSE;
 747 }
 748
 749 void wxTopLevelWindowGTK::OnInternalIdle()
 750 {
 751     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
 752     {
 753         GtkOnSize( m_x, m_y, m_width, m_height );
 754
 755         // we'll come back later
 756         if (g_isIdle)
 757             wxapp_install_idle_handler();
 758         return;
 759     }
 760
 761     // set the focus if not done yet and if we can already do it
 762     if ( GTK_WIDGET_REALIZED(m_wxwindow) )
 763     {
 764         if ( g_delayedFocus && wxGetTopLevelParent(g_delayedFocus) == this )
 765         {
 766             g_delayedFocus->SetFocus();
 767             g_delayedFocus = NULL;
 768         }
 769     }
 770
 771     wxWindow::OnInternalIdle();
 772 }
 773
 774 // ----------------------------------------------------------------------------
 775 // frame title/icon
 776 // ----------------------------------------------------------------------------
 777
 778 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
 779 {
 780     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 781
 782     m_title = title;
 783     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 784 }
 785
 786 void wxTopLevelWindowGTK::DoSetIcon( const wxIcon &icon )
 787 {
 788     if ( !icon.Ok() )
 789         return;
 790
 791     if (!m_widget->window)
 792         return;
 793
 794     wxMask *mask = icon.GetMask();
 795     GdkBitmap *bm = (GdkBitmap *) NULL;
 796     if (mask) bm = mask->GetBitmap();
 797
 798     gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
 799 }
 800
 801 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
 802 {
 803     SetIcons( wxIconBundle( icon ) );
 804 }
 805
 806 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
 807 {
 808     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 809     GdkWindow* window = m_widget->window;
 810
 811     wxTopLevelWindowBase::SetIcons( icons );
 812
 813     DoSetIcon( icons.GetIcon( -1 ) );
 814     if ( window )
 815     {
 816         wxSetIconsX11( (WXDisplay*)GDK_WINDOW_XDISPLAY( window ),
 817                        (WXWindow)GDK_WINDOW_XWINDOW( window ), icons );
 818     }
 819 }
 820
 821 // ----------------------------------------------------------------------------
 822 // frame state: maximized/iconized/normal
 823 // ----------------------------------------------------------------------------
 824
 825 void wxTopLevelWindowGTK::Maximize(bool WXUNUSED(maximize))
 826 {
 827     wxFAIL_MSG( _T("not implemented") );
 828 }
 829
 830 bool wxTopLevelWindowGTK::IsMaximized() const
 831 {
 832   //    wxFAIL_MSG( _T("not implemented") );
 833
 834     // This is an approximation
 835     return FALSE;
 836 }
 837
 838 void wxTopLevelWindowGTK::Restore()
 839 {
 840     wxFAIL_MSG( _T("not implemented") );
 841 }
 842
 843 void wxTopLevelWindowGTK::Iconize( bool iconize )
 844 {
 845    if (iconize)
 846    {
 847        GdkWindow *window = m_widget->window;
 848
 849        // you should do it later, for example from OnCreate() handler
 850        wxCHECK_RET( window, _T("frame not created yet - can't iconize") );
 851
 852        XIconifyWindow( GDK_WINDOW_XDISPLAY( window ),
 853                        GDK_WINDOW_XWINDOW( window ),
 854                        DefaultScreen( GDK_DISPLAY() ) );
 855    }
 856 }
 857
 858 bool wxTopLevelWindowGTK::IsIconized() const
 859 {
 860     return m_isIconized;
 861 }
 862
 863 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
 864 {
 865     if ( iconize != m_isIconized )
 866     {
 867         m_isIconized = iconize;
 868         (void)SendIconizeEvent(iconize);
 869     }
 870 }
 871