src/gtk1/frame.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        frame.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 "frame.h"
  20 #endif
  21
  22 #include "wx/frame.h"
  23 #include "wx/dialog.h"
  24 #include "wx/control.h"
  25 #include "wx/app.h"
  26 #include "wx/menu.h"
  27 #if wxUSE_TOOLBAR
  28     #include "wx/toolbar.h"
  29 #endif
  30 #if wxUSE_STATUSBAR
  31     #include "wx/statusbr.h"
  32 #endif
  33 #include "wx/dcclient.h"
  34
  35 #include <glib.h>
  36 #include <gdk/gdk.h>
  37 #include <gtk/gtk.h>
  38 #include <gdk/gdkkeysyms.h>
  39 #include <gdk/gdkx.h>
  40
  41 #include "wx/gtk/win_gtk.h"
  42
  43 // ----------------------------------------------------------------------------
  44 // constants
  45 // ----------------------------------------------------------------------------
  46
  47 const int wxMENU_HEIGHT    = 27;
  48 const int wxSTATUS_HEIGHT  = 25;
  49 const int wxPLACE_HOLDER   = 0;
  50
  51 // ----------------------------------------------------------------------------
  52 // idle system
  53 // ----------------------------------------------------------------------------
  54
  55 extern void wxapp_install_idle_handler();
  56 extern bool g_isIdle;
  57 extern int g_openDialogs;
  58
  59 // ----------------------------------------------------------------------------
  60 // event tables
  61 // ----------------------------------------------------------------------------
  62
  63 IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
  64
  65 // ----------------------------------------------------------------------------
  66 // data
  67 // ----------------------------------------------------------------------------
  68
  69 extern wxList wxPendingDelete;
  70
  71 // ----------------------------------------------------------------------------
  72 // debug
  73 // ----------------------------------------------------------------------------
  74
  75 #ifdef __WXDEBUG__
  76
  77 extern void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window );
  78
  79 #endif
  80
  81 // ============================================================================
  82 // implementation
  83 // ============================================================================
  84
  85 // ----------------------------------------------------------------------------
  86 // GTK callbacks
  87 // ----------------------------------------------------------------------------
  88
  89 //-----------------------------------------------------------------------------
  90 // "focus" from m_window
  91 //-----------------------------------------------------------------------------
  92
  93 static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
  94 {
  95     if (g_isIdle)
  96         wxapp_install_idle_handler();
  97
  98     // This disables GTK's tab traversal
  99     gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
 100     return TRUE;
 101 }
 102
 103 //-----------------------------------------------------------------------------
 104 // "size_allocate"
 105 //-----------------------------------------------------------------------------
 106
 107 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxFrame *win )
 108 {
 109     if (g_isIdle)
 110         wxapp_install_idle_handler();
 111
 112     if (!win->m_hasVMT)
 113         return;
 114
 115     if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
 116     {
 117 /*
 118         wxPrintf( "OnSize from " );
 119         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 120            wxPrintf( win->GetClassInfo()->GetClassName() );
 121         wxPrintf( " %d %d %d %d\n", (int)alloc->x,
 122                                 (int)alloc->y,
 123                                 (int)alloc->width,
 124                                 (int)alloc->height );
 125 */
 126
 127         win->m_width = alloc->width;
 128         win->m_height = alloc->height;
 129         win->UpdateSize();
 130     }
 131 }
 132
 133 //-----------------------------------------------------------------------------
 134 // "delete_event"
 135 //-----------------------------------------------------------------------------
 136
 137 static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxFrame *win )
 138 {
 139     if (g_isIdle)
 140         wxapp_install_idle_handler();
 141
 142     if (g_openDialogs == 0)
 143         win->Close();
 144
 145     return TRUE;
 146 }
 147
 148 //-----------------------------------------------------------------------------
 149 // "child_attached" of menu bar
 150 //-----------------------------------------------------------------------------
 151
 152 static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
 153 {
 154     if (!win->m_hasVMT) return;
 155
 156     win->m_menuBarDetached = FALSE;
 157     win->UpdateSize();
 158 }
 159
 160 //-----------------------------------------------------------------------------
 161 // "child_detached" of menu bar
 162 //-----------------------------------------------------------------------------
 163
 164 static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
 165 {
 166     if (!win->m_hasVMT) return;
 167
 168     win->m_menuBarDetached = TRUE;
 169     win->UpdateSize();
 170 }
 171
 172 #if wxUSE_TOOLBAR
 173 //-----------------------------------------------------------------------------
 174 // "child_attached" of tool bar
 175 //-----------------------------------------------------------------------------
 176
 177 static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
 178 {
 179     if (!win->m_hasVMT) return;
 180
 181     win->m_toolBarDetached = FALSE;
 182
 183     win->UpdateSize();
 184 }
 185
 186 //-----------------------------------------------------------------------------
 187 // "child_detached" of tool bar
 188 //-----------------------------------------------------------------------------
 189
 190 static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
 191 {
 192     if (g_isIdle)
 193         wxapp_install_idle_handler();
 194
 195     if (!win->m_hasVMT) return;
 196
 197     win->m_toolBarDetached = TRUE;
 198     win->UpdateSize();
 199 }
 200 #endif // wxUSE_TOOLBAR
 201
 202 //-----------------------------------------------------------------------------
 203 // "configure_event"
 204 //-----------------------------------------------------------------------------
 205
 206 static gint
 207 #if (GTK_MINOR_VERSION > 0)
 208 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxFrame *win )
 209 #else
 210 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrame *win )
 211 #endif
 212 {
 213     if (g_isIdle)
 214         wxapp_install_idle_handler();
 215
 216     if (!win->m_hasVMT)
 217         return FALSE;
 218
 219 #if (GTK_MINOR_VERSION > 0)
 220     int x = 0;
 221     int y = 0;
 222     gdk_window_get_root_origin( win->m_widget->window, &x, &y );
 223     win->m_x = x;
 224     win->m_y = y;
 225 #else
 226     win->m_x = event->x;
 227     win->m_y = event->y;
 228 #endif
 229
 230     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
 231     mevent.SetEventObject( win );
 232     win->GetEventHandler()->ProcessEvent( mevent );
 233
 234     return FALSE;
 235 }
 236
 237 //-----------------------------------------------------------------------------
 238 // "realize" from m_widget
 239 //-----------------------------------------------------------------------------
 240
 241 /* we cannot MWM hints and icons before the widget has been realized,
 242    so we do this directly after realization */
 243
 244 static gint
 245 gtk_frame_realized_callback( GtkWidget *widget, wxFrame *win )
 246 {
 247     if (g_isIdle)
 248         wxapp_install_idle_handler();
 249
 250     /* I haven't been able to set the position of
 251        the dialog before it is shown, so I set the
 252        position in "realize" */
 253     gtk_widget_set_uposition( widget, win->m_x, win->m_y );
 254
 255     /* all this is for Motif Window Manager "hints" and is supposed to be
 256        recognized by other WM as well. not tested. */
 257     long decor = (long) GDK_DECOR_BORDER;
 258     long func = (long) GDK_FUNC_MOVE;
 259
 260     if ((win->GetWindowStyle() & wxCAPTION) != 0)
 261         decor |= GDK_DECOR_TITLE;
 262     if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
 263     {
 264        decor |= GDK_DECOR_MENU;
 265        func |= GDK_FUNC_CLOSE;
 266     }
 267     if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
 268     {
 269         func |= GDK_FUNC_MINIMIZE;
 270         decor |= GDK_DECOR_MINIMIZE;
 271     }
 272     if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
 273     {
 274         func |= GDK_FUNC_MAXIMIZE;
 275         decor |= GDK_DECOR_MAXIMIZE;
 276     }
 277     if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
 278     {
 279        func |= GDK_FUNC_RESIZE;
 280        decor |= GDK_DECOR_RESIZEH;
 281     }
 282
 283     gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
 284     gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
 285
 286     /* GTK's shrinking/growing policy */
 287     if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
 288         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
 289     else
 290         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 291
 292     /* set size hints */
 293     gint flag = 0; // GDK_HINT_POS;
 294     if ((win->GetMinWidth() != -1) || (win->GetMinHeight() != -1)) flag |= GDK_HINT_MIN_SIZE;
 295     if ((win->GetMaxWidth() != -1) || (win->GetMaxHeight() != -1)) flag |= GDK_HINT_MAX_SIZE;
 296     if (flag)
 297     {
 298         gdk_window_set_hints( win->m_widget->window,
 299                               win->m_x, win->m_y,
 300                               win->GetMinWidth(), win->GetMinHeight(),
 301                               win->GetMaxWidth(), win->GetMaxHeight(),
 302                               flag );
 303     }
 304
 305     /* reset the icon */
 306     wxIcon iconOld = win->GetIcon();
 307     if ( iconOld != wxNullIcon )
 308     {
 309         wxIcon icon( iconOld );
 310         win->SetIcon( wxNullIcon );
 311         win->SetIcon( icon );
 312     }
 313
 314     /* we set the focus to the child that accepts the focus. this
 315        doesn't really have to be done in "realize" but why not? */
 316     wxWindowList::Node *node = win->GetChildren().GetFirst();
 317     while (node)
 318     {
 319         wxWindow *child = node->GetData();
 320         if (child->AcceptsFocus())
 321         {
 322             child->SetFocus();
 323             break;
 324         }
 325
 326         node = node->GetNext();
 327     }
 328
 329     return FALSE;
 330 }
 331
 332 // ----------------------------------------------------------------------------
 333 // wxFrame itself
 334 // ----------------------------------------------------------------------------
 335
 336 //-----------------------------------------------------------------------------
 337 // InsertChild for wxFrame
 338 //-----------------------------------------------------------------------------
 339
 340 /* Callback for wxFrame. This very strange beast has to be used because
 341  * C++ has no virtual methods in a constructor. We have to emulate a
 342  * virtual function here as wxWindows requires different ways to insert
 343  * a child in container classes. */
 344
 345 static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
 346 {
 347     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 348
 349     if (!parent->m_insertInClientArea)
 350     {
 351         /* these are outside the client area */
 352         wxFrame* frame = (wxFrame*) parent;
 353         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
 354                          GTK_WIDGET(child->m_widget),
 355                          child->m_x,
 356                          child->m_y,
 357                          child->m_width,
 358                          child->m_height );
 359
 360 #if wxUSE_TOOLBAR_NATIVE
 361         /* we connect to these events for recalculating the client area
 362            space when the toolbar is floating */
 363         if (wxIS_KIND_OF(child,wxToolBar))
 364         {
 365             wxToolBar *toolBar = (wxToolBar*) child;
 366             if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
 367             {
 368                 gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",
 369                     GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );
 370
 371                 gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",
 372                     GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );
 373             }
 374         }
 375 #endif // wxUSE_TOOLBAR
 376     }
 377     else
 378     {
 379         /* these are inside the client area */
 380         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 381                          GTK_WIDGET(child->m_widget),
 382                          child->m_x,
 383                          child->m_y,
 384                          child->m_width,
 385                          child->m_height );
 386     }
 387
 388     /* resize on OnInternalIdle */
 389     parent->UpdateSize();
 390 }
 391
 392 // ----------------------------------------------------------------------------
 393 // wxFrame creation
 394 // ----------------------------------------------------------------------------
 395
 396 void wxFrame::Init()
 397 {
 398     m_sizeSet = FALSE;
 399     m_miniEdge = 0;
 400     m_miniTitle = 0;
 401     m_mainWidget = (GtkWidget*) NULL;
 402     m_menuBarDetached = FALSE;
 403     m_toolBarDetached = FALSE;
 404     m_insertInClientArea = TRUE;
 405     m_isFrame = TRUE;
 406 }
 407
 408 bool wxFrame::Create( wxWindow *parent,
 409                       wxWindowID id,
 410                       const wxString &title,
 411                       const wxPoint &pos,
 412                       const wxSize &size,
 413                       long style,
 414                       const wxString &name )
 415 {
 416     wxTopLevelWindows.Append( this );
 417
 418     m_needParent = FALSE;
 419
 420     if (!PreCreation( parent, pos, size ) ||
 421         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 422     {
 423         wxFAIL_MSG( wxT("wxFrame creation failed") );
 424         return FALSE;
 425     }
 426
 427     m_title = title;
 428
 429     m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
 430
 431     GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
 432     if (style & wxSIMPLE_BORDER) win_type = GTK_WINDOW_POPUP;
 433
 434     m_widget = gtk_window_new( win_type );
 435
 436     if (!name.IsEmpty())
 437         gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
 438
 439 #ifdef __WXDEBUG__
 440     debug_focus_in( m_widget, wxT("wxFrame::m_widget"), name );
 441 #endif
 442
 443     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 444     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 445
 446     gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
 447         GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
 448
 449     /* m_mainWidget holds the toolbar, the menubar and the client area */
 450     m_mainWidget = gtk_pizza_new();
 451     gtk_widget_show( m_mainWidget );
 452     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
 453     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 454
 455 #ifdef __WXDEBUG__
 456     debug_focus_in( m_mainWidget, wxT("wxFrame::m_mainWidget"), name );
 457 #endif
 458
 459     /* m_wxwindow only represents the client area without toolbar and menubar */
 460     m_wxwindow = gtk_pizza_new();
 461     gtk_widget_show( m_wxwindow );
 462     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 463
 464 #ifdef __WXDEBUG__
 465     debug_focus_in( m_wxwindow, wxT("wxFrame::m_wxwindow"), name );
 466 #endif
 467
 468     /* we donm't allow the frame to get the focus as otherwise
 469        the frame will grabit at arbitrary fcous changes. */
 470     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 471
 472     if (m_parent) m_parent->AddChild( this );
 473
 474     /* the user resized the frame by dragging etc. */
 475     gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
 476         GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );
 477
 478     PostCreation();
 479
 480     /*  we cannot set MWM hints and icons before the widget has
 481         been realized, so we do this directly after realization */
 482     gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
 483                         GTK_SIGNAL_FUNC(gtk_frame_realized_callback), (gpointer) this );
 484
 485     /* the only way to get the window size is to connect to this event */
 486     gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
 487         GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
 488
 489     /* disable native tab traversal */
 490     gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
 491         GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this );
 492
 493     return TRUE;
 494 }
 495
 496 wxFrame::~wxFrame()
 497 {
 498     m_isBeingDeleted = TRUE;
 499
 500     DeleteAllBars();
 501
 502     wxTopLevelWindows.DeleteObject( this );
 503
 504     if (wxTheApp->GetTopWindow() == this)
 505         wxTheApp->SetTopWindow( (wxWindow*) NULL );
 506
 507     if (wxTopLevelWindows.Number() == 0)
 508         wxTheApp->ExitMainLoop();
 509 }
 510
 511 // ----------------------------------------------------------------------------
 512 // overridden wxWindow methods
 513 // ----------------------------------------------------------------------------
 514
 515 bool wxFrame::Show( bool show )
 516 {
 517     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 518
 519     if (show && !m_sizeSet)
 520     {
 521         /* by calling GtkOnSize here, we don't have to call
 522            either after showing the frame, which would entail
 523            much ugly flicker or from within the size_allocate
 524            handler, because GTK 1.1.X forbids that. */
 525
 526         GtkOnSize( m_x, m_y, m_width, m_height );
 527     }
 528
 529     return wxWindow::Show( show );
 530 }
 531
 532 void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 533 {
 534     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 535
 536     /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
 537     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 538
 539     /* avoid recursions */
 540     if (m_resizing)
 541         return;
 542     m_resizing = TRUE;
 543
 544     int old_x = m_x;
 545     int old_y = m_y;
 546
 547     int old_width = m_width;
 548     int old_height = m_height;
 549
 550     if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
 551     {
 552         if (x != -1) m_x = x;
 553         if (y != -1) m_y = y;
 554         if (width != -1) m_width = width;
 555         if (height != -1) m_height = height;
 556     }
 557     else
 558     {
 559         m_x = x;
 560         m_y = y;
 561         m_width = width;
 562         m_height = height;
 563     }
 564
 565 /*
 566     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
 567     {
 568         if (width == -1) m_width = 80;
 569     }
 570
 571     if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
 572     {
 573        if (height == -1) m_height = 26;
 574     }
 575 */
 576
 577     if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
 578     if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
 579     if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
 580     if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 581
 582     if ((m_x != -1) || (m_y != -1))
 583     {
 584         if ((m_x != old_x) || (m_y != old_y))
 585         {
 586             gtk_widget_set_uposition( m_widget, m_x, m_y );
 587         }
 588     }
 589
 590     if ((m_width != old_width) || (m_height != old_height))
 591     {
 592         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 593            done either directly before the frame is shown or in idle time
 594            so that different calls to SetSize() don't lead to flicker. */
 595         m_sizeSet = FALSE;
 596     }
 597
 598     m_resizing = FALSE;
 599 }
 600
 601 void wxFrame::DoGetClientSize( int *width, int *height ) const
 602 {
 603     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 604
 605     wxWindow::DoGetClientSize( width, height );
 606     if (height)
 607     {
 608         /* menu bar */
 609         if (m_frameMenuBar)
 610         {
 611             if (!m_menuBarDetached)
 612                 (*height) -= wxMENU_HEIGHT;
 613             else
 614                 (*height) -= wxPLACE_HOLDER;
 615         }
 616
 617 #if wxUSE_STATUSBAR
 618         /* status bar */
 619         if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
 620 #endif // wxUSE_STATUSBAR
 621
 622 #if wxUSE_TOOLBAR
 623         /* tool bar */
 624         if (m_frameToolBar)
 625         {
 626             if (m_toolBarDetached)
 627             {
 628                 *height -= wxPLACE_HOLDER;
 629             }
 630             else
 631             {
 632                 int x, y;
 633                 m_frameToolBar->GetSize( &x, &y );
 634                 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
 635                 {
 636                     *width -= x;
 637                 }
 638                 else
 639                 {
 640                     *height -= y;
 641                 }
 642             }
 643         }
 644 #endif // wxUSE_TOOLBAR
 645
 646         /* mini edge */
 647         *height -= m_miniEdge*2 + m_miniTitle;
 648     }
 649     if (width)
 650     {
 651         *width -= m_miniEdge*2;
 652     }
 653 }
 654
 655 void wxFrame::DoSetClientSize( int width, int height )
 656 {
 657     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 658
 659         /* menu bar */
 660         if (m_frameMenuBar)
 661         {
 662             if (!m_menuBarDetached)
 663                 height += wxMENU_HEIGHT;
 664             else
 665                 height += wxPLACE_HOLDER;
 666         }
 667
 668 #if wxUSE_STATUSBAR
 669         /* status bar */
 670         if (m_frameStatusBar) height += wxSTATUS_HEIGHT;
 671 #endif
 672
 673 #if wxUSE_TOOLBAR
 674         /* tool bar */
 675         if (m_frameToolBar)
 676         {
 677             if (m_toolBarDetached)
 678             {
 679                 height += wxPLACE_HOLDER;
 680             }
 681             else
 682             {
 683                 int x, y;
 684                 m_frameToolBar->GetSize( &x, &y );
 685                 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
 686                 {
 687                     width += x;
 688                 }
 689                 else
 690                 {
 691                     height += y;
 692                 }
 693             }
 694         }
 695 #endif
 696
 697     DoSetSize( -1, -1, width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0 );
 698 }
 699
 700 void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 701                          int width, int height )
 702 {
 703     // due to a bug in gtk, x,y are always 0
 704     // m_x = x;
 705     // m_y = y;
 706
 707     /* avoid recursions */
 708     if (m_resizing) return;
 709     m_resizing = TRUE;
 710
 711     /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
 712     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 713
 714     m_width = width;
 715     m_height = height;
 716
 717     /* space occupied by m_frameToolBar and m_frameMenuBar */
 718     int client_area_x_offset = 0,
 719         client_area_y_offset = 0;
 720
 721     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 722        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 723        set in wxFrame::Create so it is used to check what kind of frame we
 724        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 725        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 726        importantly) m_mainWidget */
 727
 728     if (m_mainWidget)
 729     {
 730         /* check if size is in legal range */
 731         if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
 732         if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
 733         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
 734         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 735
 736         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
 737          * menubar, the toolbar and the client area, which is represented by
 738          * m_wxwindow.
 739          * this hurts in the eye, but I don't want to call SetSize()
 740          * because I don't want to call any non-native functions here. */
 741
 742         if (m_frameMenuBar)
 743         {
 744             int xx = m_miniEdge;
 745             int yy = m_miniEdge + m_miniTitle;
 746             int ww = m_width  - 2*m_miniEdge;
 747             int hh = wxMENU_HEIGHT;
 748             if (m_menuBarDetached) hh = wxPLACE_HOLDER;
 749             m_frameMenuBar->m_x = xx;
 750             m_frameMenuBar->m_y = yy;
 751             m_frameMenuBar->m_width = ww;
 752             m_frameMenuBar->m_height = hh;
 753             gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 754                                   m_frameMenuBar->m_widget,
 755                                   xx, yy, ww, hh );
 756             client_area_y_offset += hh;
 757         }
 758
 759 #if wxUSE_TOOLBAR
 760         if ((m_frameToolBar) &&
 761             (m_frameToolBar->m_widget->parent == m_mainWidget))
 762         {
 763             int xx = m_miniEdge;
 764             int yy = m_miniEdge + m_miniTitle;
 765             if (m_frameMenuBar)
 766             {
 767                 if (!m_menuBarDetached)
 768                     yy += wxMENU_HEIGHT;
 769                 else
 770                     yy += wxPLACE_HOLDER;
 771             }
 772
 773             m_frameToolBar->m_x = xx;
 774             m_frameToolBar->m_y = yy;
 775
 776             /* don't change the toolbar's reported height/width */
 777             int ww, hh;
 778             if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
 779             {
 780                 ww = m_toolBarDetached ? wxPLACE_HOLDER
 781                                        : m_frameToolBar->m_width;
 782                 hh = m_height - 2*m_miniEdge;
 783
 784                 client_area_x_offset += ww;
 785             }
 786             else
 787             {
 788                 ww = m_width - 2*m_miniEdge;
 789                 hh = m_toolBarDetached ? wxPLACE_HOLDER
 790                                        : m_frameToolBar->m_height;
 791
 792                 client_area_y_offset += hh;
 793             }
 794
 795             gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 796                                   m_frameToolBar->m_widget,
 797                                   xx, yy, ww, hh );
 798         }
 799 #endif // wxUSE_TOOLBAR
 800
 801         int client_x = client_area_x_offset + m_miniEdge;
 802         int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
 803         int client_w = m_width - client_area_x_offset - 2*m_miniEdge;
 804         int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
 805         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 806                               m_wxwindow,
 807                               client_x, client_y, client_w, client_h );
 808     }
 809     else
 810     {
 811         /* if there is no m_mainWidget between m_widget and m_wxwindow there
 812            is no need to set the size or position of m_wxwindow. */
 813     }
 814
 815 #if wxUSE_STATUSBAR
 816     if (m_frameStatusBar)
 817     {
 818         int xx = 0 + m_miniEdge;
 819         int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
 820         int ww = m_width - 2*m_miniEdge;
 821         int hh = wxSTATUS_HEIGHT;
 822         m_frameStatusBar->m_x = xx;
 823         m_frameStatusBar->m_y = yy;
 824         m_frameStatusBar->m_width = ww;
 825         m_frameStatusBar->m_height = hh;
 826         gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
 827                             m_frameStatusBar->m_widget,
 828                             xx, yy, ww, hh );
 829     }
 830 #endif
 831
 832     /* we actually set the size of a frame here and no-where else */
 833     gtk_widget_set_usize( m_widget, m_width, m_height );
 834
 835     m_sizeSet = TRUE;
 836
 837     // send size event to frame
 838     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
 839     event.SetEventObject( this );
 840     GetEventHandler()->ProcessEvent( event );
 841
 842     // send size event to status bar
 843     if (m_frameStatusBar)
 844     {
 845         wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
 846         event2.SetEventObject( m_frameStatusBar );
 847         m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
 848     }
 849
 850     m_resizing = FALSE;
 851 }
 852
 853 void wxFrame::MakeModal( bool modal )
 854 {
 855     if (modal)
 856         gtk_grab_add( m_widget );
 857     else
 858         gtk_grab_remove( m_widget );
 859 }
 860
 861 void wxFrame::OnInternalIdle()
 862 {
 863     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
 864     {
 865         GtkOnSize( m_x, m_y, m_width, m_height );
 866
 867         // we'll come back later
 868         if (g_isIdle)
 869             wxapp_install_idle_handler();
 870         return;
 871     }
 872
 873     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
 874 #if wxUSE_TOOLBAR
 875     if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
 876 #endif
 877 #if wxUSE_STATUSBAR
 878     if (m_frameStatusBar) m_frameStatusBar->OnInternalIdle();
 879 #endif
 880
 881     wxWindow::OnInternalIdle();
 882 }
 883
 884 // ----------------------------------------------------------------------------
 885 // menu/tool/status bar stuff
 886 // ----------------------------------------------------------------------------
 887
 888 void wxFrame::SetMenuBar( wxMenuBar *menuBar )
 889 {
 890     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 891     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 892
 893     m_frameMenuBar = menuBar;
 894
 895     if (m_frameMenuBar)
 896     {
 897         m_frameMenuBar->SetInvokingWindow( this );
 898
 899         if (m_frameMenuBar->GetParent() != this)
 900         {
 901             m_frameMenuBar->SetParent(this);
 902             gtk_pizza_put( GTK_PIZZA(m_mainWidget),
 903                 m_frameMenuBar->m_widget,
 904                 m_frameMenuBar->m_x,
 905                 m_frameMenuBar->m_y,
 906                 m_frameMenuBar->m_width,
 907                 m_frameMenuBar->m_height );
 908
 909             if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
 910             {
 911                 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
 912                     GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
 913
 914                 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
 915                     GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
 916             }
 917
 918             m_frameMenuBar->Show( TRUE );
 919         }
 920     }
 921
 922     /* resize window in OnInternalIdle */
 923     m_sizeSet = FALSE;
 924 }
 925
 926 #if wxUSE_TOOLBAR
 927 wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
 928 {
 929     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 930
 931     m_insertInClientArea = FALSE;
 932
 933     m_frameToolBar = wxFrameBase::CreateToolBar( style, id, name );
 934
 935     if (m_frameToolBar)
 936         GetChildren().DeleteObject( m_frameToolBar );
 937
 938     m_insertInClientArea = TRUE;
 939
 940     m_sizeSet = FALSE;
 941
 942     return m_frameToolBar;
 943 }
 944
 945 void wxFrame::SetToolBar(wxToolBar *toolbar)
 946 {
 947     wxFrameBase::SetToolBar(toolbar);
 948
 949     if (m_frameToolBar)
 950     {
 951         /* insert into toolbar area if not already there */
 952         if ((m_frameToolBar->m_widget->parent) &&
 953             (m_frameToolBar->m_widget->parent != m_mainWidget))
 954         {
 955             GetChildren().DeleteObject( m_frameToolBar );
 956
 957             gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );
 958             UpdateSize();
 959         }
 960     }
 961 }
 962
 963 #endif // wxUSE_TOOLBAR
 964
 965 #if wxUSE_STATUSBAR
 966
 967 wxStatusBar* wxFrame::CreateStatusBar(int number,
 968                                       long style,
 969                                       wxWindowID id,
 970                                       const wxString& name)
 971 {
 972     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 973
 974     // because it will change when toolbar is added
 975     m_sizeSet = FALSE;
 976
 977     return wxFrameBase::CreateStatusBar( number, style, id, name );
 978 }
 979
 980 #endif // wxUSE_STATUSBAR
 981
 982 // ----------------------------------------------------------------------------
 983 // frame title/icon
 984 // ----------------------------------------------------------------------------
 985
 986 void wxFrame::SetTitle( const wxString &title )
 987 {
 988     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 989
 990     m_title = title;
 991     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 992 }
 993
 994 void wxFrame::SetIcon( const wxIcon &icon )
 995 {
 996     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 997
 998     wxFrameBase::SetIcon(icon);
 999
1000     if ( !m_icon.Ok() )
1001         return;
1002
1003     if (!m_widget->window)
1004         return;
1005
1006     wxMask *mask = icon.GetMask();
1007     GdkBitmap *bm = (GdkBitmap *) NULL;
1008     if (mask) bm = mask->GetBitmap();
1009
1010     gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
1011 }
1012
1013 // ----------------------------------------------------------------------------
1014 // frame state: maximized/iconized/normal (TODO)
1015 // ----------------------------------------------------------------------------
1016
1017 void wxFrame::Maximize(bool WXUNUSED(maximize))
1018 {
1019 }
1020
1021 bool wxFrame::IsMaximized() const
1022 {
1023     return FALSE;
1024 }
1025
1026 void wxFrame::Restore()
1027 {
1028 }
1029
1030 void wxFrame::Iconize( bool iconize )
1031 {
1032    if (iconize)
1033    {
1034         XIconifyWindow( GDK_WINDOW_XDISPLAY( m_widget->window ),
1035                         GDK_WINDOW_XWINDOW( m_widget->window ),
1036                         DefaultScreen( GDK_DISPLAY() ) );
1037    }
1038 }
1039
1040 bool wxFrame::IsIconized() const
1041 {
1042     return FALSE;
1043 }