src/gtk/frame.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/frame.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #include "wx/frame.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include "wx/menu.h"
  17     #include "wx/toolbar.h"
  18     #include "wx/statusbr.h"
  19 #endif // WX_PRECOMP
  20
  21 #include <gtk/gtk.h>
  22 #include "wx/gtk/win_gtk.h"
  23
  24 // ----------------------------------------------------------------------------
  25 // constants
  26 // ----------------------------------------------------------------------------
  27
  28 static const int wxSTATUS_HEIGHT  = 25;
  29 static const int wxPLACE_HOLDER   = 0;
  30
  31 // ----------------------------------------------------------------------------
  32 // event tables
  33 // ----------------------------------------------------------------------------
  34
  35 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow)
  36
  37 // ============================================================================
  38 // implementation
  39 // ============================================================================
  40
  41 // ----------------------------------------------------------------------------
  42 // GTK callbacks
  43 // ----------------------------------------------------------------------------
  44
  45 #if wxUSE_MENUS_NATIVE
  46
  47 //-----------------------------------------------------------------------------
  48 // "child_attached" of menu bar
  49 //-----------------------------------------------------------------------------
  50
  51 extern "C" {
  52 static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
  53 {
  54     if (!win->m_hasVMT) return;
  55
  56     win->m_menuBarDetached = false;
  57     win->GtkUpdateSize();
  58 }
  59 }
  60
  61 //-----------------------------------------------------------------------------
  62 // "child_detached" of menu bar
  63 //-----------------------------------------------------------------------------
  64
  65 extern "C" {
  66 static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
  67 {
  68     if (!win->m_hasVMT) return;
  69
  70     // Raise the client area area
  71     gdk_window_raise( win->m_wxwindow->window );
  72
  73     win->m_menuBarDetached = true;
  74     win->GtkUpdateSize();
  75 }
  76 }
  77
  78 #endif // wxUSE_MENUS_NATIVE
  79
  80 #if wxUSE_TOOLBAR
  81 //-----------------------------------------------------------------------------
  82 // "child_attached" of tool bar
  83 //-----------------------------------------------------------------------------
  84
  85 extern "C" {
  86 static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
  87 {
  88     if (!win->m_hasVMT) return;
  89
  90     win->m_toolBarDetached = false;
  91     win->GtkUpdateSize();
  92 }
  93 }
  94
  95 //-----------------------------------------------------------------------------
  96 // "child_detached" of tool bar
  97 //-----------------------------------------------------------------------------
  98
  99 extern "C" {
 100 static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
 101 {
 102     if (!win->m_hasVMT) return;
 103
 104     // Raise the client area area
 105     gdk_window_raise( win->m_wxwindow->window );
 106
 107     win->m_toolBarDetached = true;
 108     win->GtkUpdateSize();
 109 }
 110 }
 111 #endif // wxUSE_TOOLBAR
 112
 113
 114 // ----------------------------------------------------------------------------
 115 // wxFrame itself
 116 // ----------------------------------------------------------------------------
 117
 118 //-----------------------------------------------------------------------------
 119 // InsertChild for wxFrame
 120 //-----------------------------------------------------------------------------
 121
 122 /* Callback for wxFrame. This very strange beast has to be used because
 123  * C++ has no virtual methods in a constructor. We have to emulate a
 124  * virtual function here as wxWidgets requires different ways to insert
 125  * a child in container classes. */
 126
 127 static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
 128 {
 129     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 130
 131     if (!parent->m_insertInClientArea)
 132     {
 133         // These are outside the client area
 134         wxFrame* frame = (wxFrame*) parent;
 135         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
 136                          child->m_widget,
 137                          child->m_x,
 138                          child->m_y,
 139                          child->m_width,
 140                          child->m_height );
 141
 142 #if wxUSE_TOOLBAR_NATIVE
 143         // We connect to these events for recalculating the client area
 144         // space when the toolbar is floating
 145         if (wxIS_KIND_OF(child,wxToolBar))
 146         {
 147             wxToolBar *toolBar = (wxToolBar*) child;
 148             if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
 149             {
 150                 g_signal_connect (toolBar->m_widget, "child_attached",
 151                                   G_CALLBACK (gtk_toolbar_attached_callback),
 152                                   parent);
 153                 g_signal_connect (toolBar->m_widget, "child_detached",
 154                                   G_CALLBACK (gtk_toolbar_detached_callback),
 155                                   parent);
 156             }
 157         }
 158 #endif // wxUSE_TOOLBAR
 159     }
 160     else
 161     {
 162         // These are inside the client area
 163         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 164                          child->m_widget,
 165                          child->m_x,
 166                          child->m_y,
 167                          child->m_width,
 168                          child->m_height );
 169     }
 170 }
 171
 172 // ----------------------------------------------------------------------------
 173 // wxFrame creation
 174 // ----------------------------------------------------------------------------
 175
 176 void wxFrame::Init()
 177 {
 178     m_menuBarDetached = false;
 179     m_toolBarDetached = false;
 180     m_menuBarHeight = 2;
 181 }
 182
 183 bool wxFrame::Create( wxWindow *parent,
 184                       wxWindowID id,
 185                       const wxString& title,
 186                       const wxPoint& pos,
 187                       const wxSize& sizeOrig,
 188                       long style,
 189                       const wxString &name )
 190 {
 191     bool rt = wxTopLevelWindow::Create(parent, id, title, pos, sizeOrig,
 192                                        style, name);
 193     m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
 194
 195     return rt;
 196 }
 197
 198 wxFrame::~wxFrame()
 199 {
 200     m_isBeingDeleted = true;
 201     DeleteAllBars();
 202 }
 203
 204 // ----------------------------------------------------------------------------
 205 // overridden wxWindow methods
 206 // ----------------------------------------------------------------------------
 207
 208 void wxFrame::DoGetClientSize( int *width, int *height ) const
 209 {
 210     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 211
 212     wxTopLevelWindow::DoGetClientSize( width, height );
 213
 214     if (height)
 215     {
 216 #if wxUSE_MENUS_NATIVE
 217         // menu bar
 218         if (m_frameMenuBar && !(m_fsIsShowing && (m_fsSaveFlag & wxFULLSCREEN_NOMENUBAR) != 0))
 219         {
 220             if (!m_menuBarDetached)
 221                 (*height) -= m_menuBarHeight;
 222             else
 223                 (*height) -= wxPLACE_HOLDER;
 224         }
 225 #endif // wxUSE_MENUS_NATIVE
 226
 227 #if wxUSE_STATUSBAR
 228         // status bar
 229         if (m_frameStatusBar && m_frameStatusBar->IsShown() &&
 230             !(m_fsIsShowing && (m_fsSaveFlag & wxFULLSCREEN_NOSTATUSBAR) != 0))
 231             (*height) -= wxSTATUS_HEIGHT;
 232 #endif // wxUSE_STATUSBAR
 233     }
 234
 235 #if wxUSE_TOOLBAR
 236     // tool bar
 237     if (m_frameToolBar && m_frameToolBar->IsShown())
 238     {
 239         if (m_toolBarDetached)
 240         {
 241             if (height != NULL)
 242                 *height -= wxPLACE_HOLDER;
 243         }
 244         else
 245         {
 246             int x, y;
 247             m_frameToolBar->GetSize( &x, &y );
 248             if ( m_frameToolBar->IsVertical() )
 249             {
 250                 if (width != NULL)
 251                     *width -= x;
 252             }
 253             else
 254             {
 255                 if (height != NULL)
 256                     *height -= y;
 257             }
 258         }
 259     }
 260 #endif // wxUSE_TOOLBAR
 261
 262     if (width != NULL && *width < 0)
 263         *width = 0;
 264     if (height != NULL && *height < 0)
 265         *height = 0;
 266 }
 267
 268 void wxFrame::DoSetClientSize( int width, int height )
 269 {
 270     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 271
 272 #if wxUSE_MENUS_NATIVE
 273         // menu bar
 274         if (m_frameMenuBar && !(m_fsIsShowing && (m_fsSaveFlag & wxFULLSCREEN_NOMENUBAR) != 0))
 275         {
 276             if (!m_menuBarDetached)
 277                 height += m_menuBarHeight;
 278             else
 279                 height += wxPLACE_HOLDER;
 280         }
 281 #endif // wxUSE_MENUS_NATIVE
 282
 283 #if wxUSE_STATUSBAR
 284         // status bar
 285         if (m_frameStatusBar && m_frameStatusBar->IsShown() &&
 286             !(m_fsIsShowing && (m_fsSaveFlag & wxFULLSCREEN_NOSTATUSBAR) != 0))
 287             height += wxSTATUS_HEIGHT;
 288 #endif
 289
 290 #if wxUSE_TOOLBAR
 291         // tool bar
 292         if (m_frameToolBar && m_frameToolBar->IsShown())
 293         {
 294             if (m_toolBarDetached)
 295             {
 296                 height += wxPLACE_HOLDER;
 297             }
 298             else
 299             {
 300                 int x, y;
 301                 m_frameToolBar->GetSize( &x, &y );
 302                 if ( m_frameToolBar->IsVertical() )
 303                 {
 304                     width += x;
 305                 }
 306                 else
 307                 {
 308                     height += y;
 309                 }
 310             }
 311         }
 312 #endif
 313
 314     wxTopLevelWindow::DoSetClientSize( width, height );
 315 }
 316
 317 void wxFrame::GtkOnSize()
 318 {
 319     // avoid recursions
 320     if (m_resizing) return;
 321     m_resizing = true;
 322
 323     // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
 324     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 325
 326     // space occupied by m_frameToolBar and m_frameMenuBar
 327     int client_area_x_offset = 0,
 328         client_area_y_offset = 0;
 329
 330     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 331        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 332        set in wxFrame::Create so it is used to check what kind of frame we
 333        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 334        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 335        importantly) m_mainWidget */
 336
 337     int minWidth = GetMinWidth(),
 338         minHeight = GetMinHeight(),
 339         maxWidth = GetMaxWidth(),
 340         maxHeight = GetMaxHeight();
 341
 342     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 343     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 344     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 345     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 346
 347     if (m_mainWidget)
 348     {
 349         // TODO
 350         // Rewrite this terrible code to using GtkVBox
 351
 352         // m_mainWidget holds the menubar, the toolbar and the client
 353         // area, which is represented by m_wxwindow.
 354
 355 #if wxUSE_MENUS_NATIVE
 356         if (m_frameMenuBar && !(m_fsIsShowing && (m_fsSaveFlag & wxFULLSCREEN_NOMENUBAR) != 0))
 357         {
 358             if (!GTK_WIDGET_VISIBLE(m_frameMenuBar->m_widget))
 359                 gtk_widget_show( m_frameMenuBar->m_widget );
 360             int xx = m_miniEdge;
 361             int yy = m_miniEdge + m_miniTitle;
 362             int ww = m_width  - 2*m_miniEdge;
 363             if (ww < 0)
 364                 ww = 0;
 365             int hh = m_menuBarHeight;
 366             if (m_menuBarDetached) hh = wxPLACE_HOLDER;
 367             m_frameMenuBar->m_x = xx;
 368             m_frameMenuBar->m_y = yy;
 369             m_frameMenuBar->m_width = ww;
 370             m_frameMenuBar->m_height = hh;
 371             gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 372                                   m_frameMenuBar->m_widget,
 373                                   xx, yy, ww, hh );
 374             client_area_y_offset += hh;
 375         }
 376         else
 377         {
 378             if (m_frameMenuBar)
 379             {
 380                 if (GTK_WIDGET_VISIBLE(m_frameMenuBar->m_widget))
 381                     gtk_widget_hide( m_frameMenuBar->m_widget );
 382             }
 383         }
 384 #endif // wxUSE_MENUS_NATIVE
 385
 386 #if wxUSE_TOOLBAR
 387         if ((m_frameToolBar) && m_frameToolBar->IsShown() &&
 388             (m_frameToolBar->m_widget->parent == m_mainWidget))
 389         {
 390             int xx = m_miniEdge;
 391             int yy = m_miniEdge + m_miniTitle;
 392 #if wxUSE_MENUS_NATIVE
 393             if (m_frameMenuBar)
 394             {
 395                 if (!m_menuBarDetached)
 396                     yy += m_menuBarHeight;
 397                 else
 398                     yy += wxPLACE_HOLDER;
 399             }
 400 #endif // wxUSE_MENUS_NATIVE
 401
 402             m_frameToolBar->m_x = xx;
 403             m_frameToolBar->m_y = yy;
 404
 405             // don't change the toolbar's reported height/width
 406             int ww, hh;
 407             if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
 408             {
 409                 ww = m_toolBarDetached ? wxPLACE_HOLDER
 410                                        : m_frameToolBar->m_width;
 411                 hh = m_height - 2*m_miniEdge;
 412
 413                 client_area_x_offset += ww;
 414             }
 415             else if( m_frameToolBar->HasFlag(wxTB_RIGHT) )
 416             {
 417                yy += 2;
 418                ww = m_toolBarDetached ? wxPLACE_HOLDER
 419                                       : m_frameToolBar->m_width;
 420                xx = GetClientSize().x - 1;
 421                hh = m_height - 2*m_miniEdge;
 422                if( hh < 0 )
 423                   hh = 0;
 424
 425             }
 426             else if( m_frameToolBar->GetWindowStyle() & wxTB_BOTTOM )
 427             {
 428                 xx = m_miniEdge;
 429                 yy = GetClientSize().y;
 430 #if wxUSE_MENUS_NATIVE
 431                 yy += m_menuBarHeight;
 432 #endif // wxUSE_MENU_NATIVE
 433                 m_frameToolBar->m_x = xx;
 434                 m_frameToolBar->m_y = yy;
 435                 ww = m_width - 2*m_miniEdge;
 436                 hh = m_toolBarDetached ? wxPLACE_HOLDER
 437                                        : m_frameToolBar->m_height;
 438             }
 439             else
 440             {
 441                 ww = m_width - 2*m_miniEdge;
 442                 hh = m_toolBarDetached ? wxPLACE_HOLDER
 443                                        : m_frameToolBar->m_height;
 444
 445                 client_area_y_offset += hh;
 446             }
 447
 448             if (ww < 0)
 449                 ww = 0;
 450             if (hh < 0)
 451                 hh = 0;
 452             gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 453                                   m_frameToolBar->m_widget,
 454                                   xx, yy, ww, hh );
 455         }
 456 #endif // wxUSE_TOOLBAR
 457
 458         int client_x = client_area_x_offset + m_miniEdge;
 459         int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
 460         int client_w = m_width - client_area_x_offset - 2*m_miniEdge;
 461         int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
 462         if (client_w < 0)
 463             client_w = 0;
 464         if (client_h < 0)
 465             client_h = 0;
 466         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 467                               m_wxwindow,
 468                               client_x, client_y, client_w, client_h );
 469     }
 470     else
 471     {
 472         // If there is no m_mainWidget between m_widget and m_wxwindow there
 473         // is no need to set the size or position of m_wxwindow.
 474     }
 475
 476 #if wxUSE_STATUSBAR
 477     if (m_frameStatusBar && m_frameStatusBar->IsShown() &&
 478         !(m_fsIsShowing && (m_fsSaveFlag & wxFULLSCREEN_NOSTATUSBAR) != 0))
 479     {
 480         if (!GTK_WIDGET_VISIBLE(m_frameStatusBar->m_widget))
 481             gtk_widget_show( m_frameStatusBar->m_widget );
 482
 483         int xx = 0 + m_miniEdge;
 484         int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
 485         int ww = m_width - 2*m_miniEdge;
 486         if (ww < 0)
 487             ww = 0;
 488         int hh = wxSTATUS_HEIGHT;
 489         m_frameStatusBar->m_x = xx;
 490         m_frameStatusBar->m_y = yy;
 491         m_frameStatusBar->m_width = ww;
 492         m_frameStatusBar->m_height = hh;
 493         gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
 494                             m_frameStatusBar->m_widget,
 495                             xx, yy, ww, hh );
 496     }
 497     else
 498     {
 499         if (m_frameStatusBar)
 500         {
 501             if (GTK_WIDGET_VISIBLE(m_frameStatusBar->m_widget))
 502                 gtk_widget_hide( m_frameStatusBar->m_widget );
 503         }
 504     }
 505 #endif // wxUSE_STATUSBAR
 506
 507     m_sizeSet = true;
 508
 509     // send size event to frame
 510     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
 511     event.SetEventObject( this );
 512     GetEventHandler()->ProcessEvent( event );
 513
 514 #if wxUSE_STATUSBAR
 515     // send size event to status bar
 516     if (m_frameStatusBar)
 517     {
 518         wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
 519         event2.SetEventObject( m_frameStatusBar );
 520         m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
 521     }
 522 #endif // wxUSE_STATUSBAR
 523
 524     m_resizing = false;
 525 }
 526
 527 void wxFrame::OnInternalIdle()
 528 {
 529     wxFrameBase::OnInternalIdle();
 530
 531 #if wxUSE_MENUS_NATIVE
 532     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
 533 #endif // wxUSE_MENUS_NATIVE
 534 #if wxUSE_TOOLBAR
 535     if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
 536 #endif
 537 #if wxUSE_STATUSBAR
 538     if (m_frameStatusBar)
 539     {
 540         m_frameStatusBar->OnInternalIdle();
 541
 542         // There may be controls in the status bar that
 543         // need to be updated
 544         for ( wxWindowList::compatibility_iterator node = m_frameStatusBar->GetChildren().GetFirst();
 545           node;
 546           node = node->GetNext() )
 547         {
 548             wxWindow *child = node->GetData();
 549             child->OnInternalIdle();
 550         }
 551     }
 552 #endif
 553 }
 554
 555 // ----------------------------------------------------------------------------
 556 // menu/tool/status bar stuff
 557 // ----------------------------------------------------------------------------
 558
 559 #if wxUSE_MENUS_NATIVE
 560
 561 void wxFrame::DetachMenuBar()
 562 {
 563     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 564     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 565
 566     if ( m_frameMenuBar )
 567     {
 568         m_frameMenuBar->UnsetInvokingWindow( this );
 569
 570         if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE)
 571         {
 572             g_signal_handlers_disconnect_by_func (m_frameMenuBar->m_widget,
 573                     (gpointer) gtk_menu_attached_callback,
 574                     this);
 575
 576             g_signal_handlers_disconnect_by_func (m_frameMenuBar->m_widget,
 577                     (gpointer) gtk_menu_detached_callback,
 578                     this);
 579         }
 580
 581         gtk_widget_ref( m_frameMenuBar->m_widget );
 582
 583         gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );
 584     }
 585
 586     wxFrameBase::DetachMenuBar();
 587 }
 588
 589 void wxFrame::AttachMenuBar( wxMenuBar *menuBar )
 590 {
 591     wxFrameBase::AttachMenuBar(menuBar);
 592
 593     if (m_frameMenuBar)
 594     {
 595         m_frameMenuBar->SetInvokingWindow( this );
 596
 597         m_frameMenuBar->SetParent(this);
 598         gtk_pizza_put( GTK_PIZZA(m_mainWidget),
 599                 m_frameMenuBar->m_widget,
 600                 m_frameMenuBar->m_x,
 601                 m_frameMenuBar->m_y,
 602                 m_frameMenuBar->m_width,
 603                 m_frameMenuBar->m_height );
 604
 605         if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
 606         {
 607             g_signal_connect (menuBar->m_widget, "child_attached",
 608                               G_CALLBACK (gtk_menu_attached_callback),
 609                               this);
 610             g_signal_connect (menuBar->m_widget, "child_detached",
 611                               G_CALLBACK (gtk_menu_detached_callback),
 612                               this);
 613         }
 614
 615         gtk_widget_show( m_frameMenuBar->m_widget );
 616
 617         UpdateMenuBarSize();
 618     }
 619     else
 620     {
 621         m_menuBarHeight = 2;
 622         GtkUpdateSize();        // resize window in OnInternalIdle
 623     }
 624 }
 625
 626 void wxFrame::UpdateMenuBarSize()
 627 {
 628     m_menuBarHeight = 2;
 629
 630     // this is called after Remove with a NULL m_frameMenuBar
 631     if ( m_frameMenuBar )
 632     {
 633         GtkRequisition req;
 634         gtk_widget_ensure_style(m_frameMenuBar->m_widget);
 635         // have to call class method directly because
 636         // "size_request" signal is overridden by wx
 637         GTK_WIDGET_GET_CLASS(m_frameMenuBar->m_widget)->size_request(
 638             m_frameMenuBar->m_widget, &req);
 639
 640         m_menuBarHeight = req.height;
 641     }
 642
 643     // resize window in OnInternalIdle
 644     GtkUpdateSize();
 645 }
 646
 647 #endif // wxUSE_MENUS_NATIVE
 648
 649 #if wxUSE_TOOLBAR
 650
 651 wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
 652 {
 653     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 654
 655     m_insertInClientArea = false;
 656
 657     m_frameToolBar = wxFrameBase::CreateToolBar( style, id, name );
 658
 659     m_insertInClientArea = true;
 660
 661     GtkUpdateSize();
 662
 663     return m_frameToolBar;
 664 }
 665
 666 void wxFrame::SetToolBar(wxToolBar *toolbar)
 667 {
 668     bool hadTbar = m_frameToolBar != NULL;
 669
 670     wxFrameBase::SetToolBar(toolbar);
 671
 672     if ( m_frameToolBar )
 673     {
 674         // insert into toolbar area if not already there
 675         if ((m_frameToolBar->m_widget->parent) &&
 676             (m_frameToolBar->m_widget->parent != m_mainWidget))
 677         {
 678             GetChildren().DeleteObject( m_frameToolBar );
 679
 680             gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );
 681             GtkUpdateSize();
 682         }
 683     }
 684     else // toolbar unset
 685     {
 686         // still need to update size if it had been there before
 687         if ( hadTbar )
 688         {
 689             GtkUpdateSize();
 690         }
 691     }
 692 }
 693
 694 #endif // wxUSE_TOOLBAR
 695
 696 #if wxUSE_STATUSBAR
 697
 698 wxStatusBar* wxFrame::CreateStatusBar(int number,
 699                                       long style,
 700                                       wxWindowID id,
 701                                       const wxString& name)
 702 {
 703     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 704
 705     // because it will change when toolbar is added
 706     GtkUpdateSize();
 707
 708     return wxFrameBase::CreateStatusBar( number, style, id, name );
 709 }
 710
 711 void wxFrame::SetStatusBar(wxStatusBar *statbar)
 712 {
 713     bool hadStatBar = m_frameStatusBar != NULL;
 714
 715     wxFrameBase::SetStatusBar(statbar);
 716
 717     if (hadStatBar && !m_frameStatusBar)
 718         GtkUpdateSize();
 719 }
 720
 721 void wxFrame::PositionStatusBar()
 722 {
 723     if ( !m_frameStatusBar )
 724         return;
 725
 726     GtkUpdateSize();
 727 }
 728 #endif // wxUSE_STATUSBAR