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->GetExitOnFrameDelete()))
 509     {
 510         wxTheApp->ExitMainLoop();
 511     }
 512 }
 513
 514 // ----------------------------------------------------------------------------
 515 // overridden wxWindow methods
 516 // ----------------------------------------------------------------------------
 517
 518 bool wxFrame::Show( bool show )
 519 {
 520     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 521
 522     if (show && !m_sizeSet)
 523     {
 524         /* by calling GtkOnSize here, we don't have to call
 525            either after showing the frame, which would entail
 526            much ugly flicker or from within the size_allocate
 527            handler, because GTK 1.1.X forbids that. */
 528
 529         GtkOnSize( m_x, m_y, m_width, m_height );
 530     }
 531
 532     return wxWindow::Show( show );
 533 }
 534
 535 void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 536 {
 537     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 538
 539     /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
 540     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 541
 542     /* avoid recursions */
 543     if (m_resizing)
 544         return;
 545     m_resizing = TRUE;
 546
 547     int old_x = m_x;
 548     int old_y = m_y;
 549
 550     int old_width = m_width;
 551     int old_height = m_height;
 552
 553     if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
 554     {
 555         if (x != -1) m_x = x;
 556         if (y != -1) m_y = y;
 557         if (width != -1) m_width = width;
 558         if (height != -1) m_height = height;
 559     }
 560     else
 561     {
 562         m_x = x;
 563         m_y = y;
 564         m_width = width;
 565         m_height = height;
 566     }
 567
 568 /*
 569     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
 570     {
 571         if (width == -1) m_width = 80;
 572     }
 573
 574     if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
 575     {
 576        if (height == -1) m_height = 26;
 577     }
 578 */
 579
 580     if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
 581     if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
 582     if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
 583     if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 584
 585     if ((m_x != -1) || (m_y != -1))
 586     {
 587         if ((m_x != old_x) || (m_y != old_y))
 588         {
 589             gtk_widget_set_uposition( m_widget, m_x, m_y );
 590         }
 591     }
 592
 593     if ((m_width != old_width) || (m_height != old_height))
 594     {
 595         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 596            done either directly before the frame is shown or in idle time
 597            so that different calls to SetSize() don't lead to flicker. */
 598         m_sizeSet = FALSE;
 599     }
 600
 601     m_resizing = FALSE;
 602 }
 603
 604 void wxFrame::DoGetClientSize( int *width, int *height ) const
 605 {
 606     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 607
 608     wxWindow::DoGetClientSize( width, height );
 609     if (height)
 610     {
 611         /* menu bar */
 612         if (m_frameMenuBar)
 613         {
 614             if (!m_menuBarDetached)
 615                 (*height) -= wxMENU_HEIGHT;
 616             else
 617                 (*height) -= wxPLACE_HOLDER;
 618         }
 619
 620 #if wxUSE_STATUSBAR
 621         /* status bar */
 622         if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
 623 #endif // wxUSE_STATUSBAR
 624
 625 #if wxUSE_TOOLBAR
 626         /* tool bar */
 627         if (m_frameToolBar)
 628         {
 629             if (m_toolBarDetached)
 630             {
 631                 *height -= wxPLACE_HOLDER;
 632             }
 633             else
 634             {
 635                 int x, y;
 636                 m_frameToolBar->GetSize( &x, &y );
 637                 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
 638                 {
 639                     *width -= x;
 640                 }
 641                 else
 642                 {
 643                     *height -= y;
 644                 }
 645             }
 646         }
 647 #endif // wxUSE_TOOLBAR
 648
 649         /* mini edge */
 650         *height -= m_miniEdge*2 + m_miniTitle;
 651     }
 652     if (width)
 653     {
 654         *width -= m_miniEdge*2;
 655     }
 656 }
 657
 658 void wxFrame::DoSetClientSize( int width, int height )
 659 {
 660     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 661
 662         /* menu bar */
 663         if (m_frameMenuBar)
 664         {
 665             if (!m_menuBarDetached)
 666                 height += wxMENU_HEIGHT;
 667             else
 668                 height += wxPLACE_HOLDER;
 669         }
 670
 671 #if wxUSE_STATUSBAR
 672         /* status bar */
 673         if (m_frameStatusBar) height += wxSTATUS_HEIGHT;
 674 #endif
 675
 676 #if wxUSE_TOOLBAR
 677         /* tool bar */
 678         if (m_frameToolBar)
 679         {
 680             if (m_toolBarDetached)
 681             {
 682                 height += wxPLACE_HOLDER;
 683             }
 684             else
 685             {
 686                 int x, y;
 687                 m_frameToolBar->GetSize( &x, &y );
 688                 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
 689                 {
 690                     width += x;
 691                 }
 692                 else
 693                 {
 694                     height += y;
 695                 }
 696             }
 697         }
 698 #endif
 699
 700     DoSetSize( -1, -1, width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0 );
 701 }
 702
 703 void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 704                          int width, int height )
 705 {
 706     // due to a bug in gtk, x,y are always 0
 707     // m_x = x;
 708     // m_y = y;
 709
 710     /* avoid recursions */
 711     if (m_resizing) return;
 712     m_resizing = TRUE;
 713
 714     /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
 715     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 716
 717     m_width = width;
 718     m_height = height;
 719
 720     /* space occupied by m_frameToolBar and m_frameMenuBar */
 721     int client_area_x_offset = 0,
 722         client_area_y_offset = 0;
 723
 724     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 725        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 726        set in wxFrame::Create so it is used to check what kind of frame we
 727        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 728        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 729        importantly) m_mainWidget */
 730
 731     if (m_mainWidget)
 732     {
 733         /* check if size is in legal range */
 734         if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
 735         if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
 736         if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
 737         if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
 738
 739         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
 740          * menubar, the toolbar and the client area, which is represented by
 741          * m_wxwindow.
 742          * this hurts in the eye, but I don't want to call SetSize()
 743          * because I don't want to call any non-native functions here. */
 744
 745         if (m_frameMenuBar)
 746         {
 747             int xx = m_miniEdge;
 748             int yy = m_miniEdge + m_miniTitle;
 749             int ww = m_width  - 2*m_miniEdge;
 750             int hh = wxMENU_HEIGHT;
 751             if (m_menuBarDetached) hh = wxPLACE_HOLDER;
 752             m_frameMenuBar->m_x = xx;
 753             m_frameMenuBar->m_y = yy;
 754             m_frameMenuBar->m_width = ww;
 755             m_frameMenuBar->m_height = hh;
 756             gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 757                                   m_frameMenuBar->m_widget,
 758                                   xx, yy, ww, hh );
 759             client_area_y_offset += hh;
 760         }
 761
 762 #if wxUSE_TOOLBAR
 763         if ((m_frameToolBar) &&
 764             (m_frameToolBar->m_widget->parent == m_mainWidget))
 765         {
 766             int xx = m_miniEdge;
 767             int yy = m_miniEdge + m_miniTitle;
 768             if (m_frameMenuBar)
 769             {
 770                 if (!m_menuBarDetached)
 771                     yy += wxMENU_HEIGHT;
 772                 else
 773                     yy += wxPLACE_HOLDER;
 774             }
 775
 776             m_frameToolBar->m_x = xx;
 777             m_frameToolBar->m_y = yy;
 778
 779             /* don't change the toolbar's reported height/width */
 780             int ww, hh;
 781             if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
 782             {
 783                 ww = m_toolBarDetached ? wxPLACE_HOLDER
 784                                        : m_frameToolBar->m_width;
 785                 hh = m_height - 2*m_miniEdge;
 786
 787                 client_area_x_offset += ww;
 788             }
 789             else
 790             {
 791                 ww = m_width - 2*m_miniEdge;
 792                 hh = m_toolBarDetached ? wxPLACE_HOLDER
 793                                        : m_frameToolBar->m_height;
 794
 795                 client_area_y_offset += hh;
 796             }
 797
 798             gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 799                                   m_frameToolBar->m_widget,
 800                                   xx, yy, ww, hh );
 801         }
 802 #endif // wxUSE_TOOLBAR
 803
 804         int client_x = client_area_x_offset + m_miniEdge;
 805         int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
 806         int client_w = m_width - client_area_x_offset - 2*m_miniEdge;
 807         int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
 808         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
 809                               m_wxwindow,
 810                               client_x, client_y, client_w, client_h );
 811     }
 812     else
 813     {
 814         /* if there is no m_mainWidget between m_widget and m_wxwindow there
 815            is no need to set the size or position of m_wxwindow. */
 816     }
 817
 818 #if wxUSE_STATUSBAR
 819     if (m_frameStatusBar)
 820     {
 821         int xx = 0 + m_miniEdge;
 822         int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
 823         int ww = m_width - 2*m_miniEdge;
 824         int hh = wxSTATUS_HEIGHT;
 825         m_frameStatusBar->m_x = xx;
 826         m_frameStatusBar->m_y = yy;
 827         m_frameStatusBar->m_width = ww;
 828         m_frameStatusBar->m_height = hh;
 829         gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
 830                             m_frameStatusBar->m_widget,
 831                             xx, yy, ww, hh );
 832     }
 833 #endif
 834
 835     /* we actually set the size of a frame here and no-where else */
 836     gtk_widget_set_usize( m_widget, m_width, m_height );
 837
 838     m_sizeSet = TRUE;
 839
 840     // send size event to frame
 841     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
 842     event.SetEventObject( this );
 843     GetEventHandler()->ProcessEvent( event );
 844
 845     // send size event to status bar
 846     if (m_frameStatusBar)
 847     {
 848         wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
 849         event2.SetEventObject( m_frameStatusBar );
 850         m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
 851     }
 852
 853     m_resizing = FALSE;
 854 }
 855
 856 void wxFrame::MakeModal( bool modal )
 857 {
 858     if (modal)
 859         gtk_grab_add( m_widget );
 860     else
 861         gtk_grab_remove( m_widget );
 862 }
 863
 864 void wxFrame::OnInternalIdle()
 865 {
 866     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
 867     {
 868         GtkOnSize( m_x, m_y, m_width, m_height );
 869
 870         // we'll come back later
 871         if (g_isIdle)
 872             wxapp_install_idle_handler();
 873         return;
 874     }
 875
 876     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
 877 #if wxUSE_TOOLBAR
 878     if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
 879 #endif
 880 #if wxUSE_STATUSBAR
 881     if (m_frameStatusBar) m_frameStatusBar->OnInternalIdle();
 882 #endif
 883
 884     wxWindow::OnInternalIdle();
 885 }
 886
 887 // ----------------------------------------------------------------------------
 888 // menu/tool/status bar stuff
 889 // ----------------------------------------------------------------------------
 890
 891 void wxFrame::SetMenuBar( wxMenuBar *menuBar )
 892 {
 893     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 894     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 895
 896     m_frameMenuBar = menuBar;
 897
 898     if (m_frameMenuBar)
 899     {
 900         m_frameMenuBar->SetInvokingWindow( this );
 901
 902         if (m_frameMenuBar->GetParent() != this)
 903         {
 904             m_frameMenuBar->SetParent(this);
 905             gtk_pizza_put( GTK_PIZZA(m_mainWidget),
 906                 m_frameMenuBar->m_widget,
 907                 m_frameMenuBar->m_x,
 908                 m_frameMenuBar->m_y,
 909                 m_frameMenuBar->m_width,
 910                 m_frameMenuBar->m_height );
 911
 912             if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
 913             {
 914                 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
 915                     GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
 916
 917                 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
 918                     GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
 919             }
 920
 921             m_frameMenuBar->Show( TRUE );
 922         }
 923     }
 924
 925     /* resize window in OnInternalIdle */
 926     m_sizeSet = FALSE;
 927 }
 928
 929 #if wxUSE_TOOLBAR
 930 wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
 931 {
 932     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 933
 934     m_insertInClientArea = FALSE;
 935
 936     m_frameToolBar = wxFrameBase::CreateToolBar( style, id, name );
 937
 938     if (m_frameToolBar)
 939         GetChildren().DeleteObject( m_frameToolBar );
 940
 941     m_insertInClientArea = TRUE;
 942
 943     m_sizeSet = FALSE;
 944
 945     return m_frameToolBar;
 946 }
 947
 948 void wxFrame::SetToolBar(wxToolBar *toolbar)
 949 {
 950     wxFrameBase::SetToolBar(toolbar);
 951
 952     if (m_frameToolBar)
 953     {
 954         /* insert into toolbar area if not already there */
 955         if ((m_frameToolBar->m_widget->parent) &&
 956             (m_frameToolBar->m_widget->parent != m_mainWidget))
 957         {
 958             GetChildren().DeleteObject( m_frameToolBar );
 959
 960             gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );
 961             UpdateSize();
 962         }
 963     }
 964 }
 965
 966 #endif // wxUSE_TOOLBAR
 967
 968 #if wxUSE_STATUSBAR
 969
 970 wxStatusBar* wxFrame::CreateStatusBar(int number,
 971                                       long style,
 972                                       wxWindowID id,
 973                                       const wxString& name)
 974 {
 975     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 976
 977     // because it will change when toolbar is added
 978     m_sizeSet = FALSE;
 979
 980     return wxFrameBase::CreateStatusBar( number, style, id, name );
 981 }
 982
 983 #endif // wxUSE_STATUSBAR
 984
 985 // ----------------------------------------------------------------------------
 986 // frame title/icon
 987 // ----------------------------------------------------------------------------
 988
 989 void wxFrame::SetTitle( const wxString &title )
 990 {
 991     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 992
 993     m_title = title;
 994     gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
 995 }
 996
 997 void wxFrame::SetIcon( const wxIcon &icon )
 998 {
 999     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1000
1001     wxFrameBase::SetIcon(icon);
1002
1003     if ( !m_icon.Ok() )
1004         return;
1005
1006     if (!m_widget->window)
1007         return;
1008
1009     wxMask *mask = icon.GetMask();
1010     GdkBitmap *bm = (GdkBitmap *) NULL;
1011     if (mask) bm = mask->GetBitmap();
1012
1013     gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
1014 }
1015
1016 // ----------------------------------------------------------------------------
1017 // frame state: maximized/iconized/normal (TODO)
1018 // ----------------------------------------------------------------------------
1019
1020 void wxFrame::Maximize(bool WXUNUSED(maximize))
1021 {
1022 }
1023
1024 bool wxFrame::IsMaximized() const
1025 {
1026     return FALSE;
1027 }
1028
1029 void wxFrame::Restore()
1030 {
1031 }
1032
1033 void wxFrame::Iconize( bool iconize )
1034 {
1035    if (iconize)
1036    {
1037         XIconifyWindow( GDK_WINDOW_XDISPLAY( m_widget->window ),
1038                         GDK_WINDOW_XWINDOW( m_widget->window ),
1039                         DefaultScreen( GDK_DISPLAY() ) );
1040    }
1041 }
1042
1043 bool wxFrame::IsIconized() const
1044 {
1045     return FALSE;
1046 }