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