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