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