src/gtk1/frame.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        frame.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Created:     01/02/97
   6 // Id:
   7 // Copyright:   (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 #ifdef __GNUG__
  12 #pragma implementation "frame.h"
  13 #endif
  14
  15 #include "wx/frame.h"
  16 #include "wx/dialog.h"
  17 #include "wx/control.h"
  18 #include "wx/app.h"
  19 #include "wx/menu.h"
  20 #include "wx/toolbar.h"
  21 #include "wx/statusbr.h"
  22 #include "wx/mdi.h"
  23 #include "wx/dcclient.h"
  24 #include "wx/gtk/win_gtk.h"
  25
  26 const int wxMENU_HEIGHT    = 28;
  27 const int wxSTATUS_HEIGHT  = 25;
  28
  29 extern wxList wxTopLevelWindows;
  30 extern wxList wxPendingDelete;
  31
  32 //-----------------------------------------------------------------------------
  33 // wxFrame
  34 //-----------------------------------------------------------------------------
  35
  36 //-----------------------------------------------------------------------------
  37 // set size
  38
  39 void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxFrame *win )
  40 {
  41   if (!win->HasVMT()) return;
  42
  43 /*
  44   printf( "OnFrameResize from " );
  45   if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
  46     printf( win->GetClassInfo()->GetClassName() );
  47   printf( ".\n" );
  48 */
  49
  50   win->GtkOnSize( alloc->x, alloc->y, alloc->width, alloc->height );
  51 }
  52
  53 //-----------------------------------------------------------------------------
  54 // delete
  55
  56 bool gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxFrame *win )
  57 {
  58 /*
  59   printf( "OnDelete from " );
  60   if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
  61     printf( win->GetClassInfo()->GetClassName() );
  62   printf( ".\n" );
  63 */
  64
  65   win->Close();
  66
  67   return TRUE;
  68 }
  69
  70 //-----------------------------------------------------------------------------
  71 // configure
  72
  73 gint gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrame *win )
  74 {
  75   if (!win->HasVMT()) return FALSE;
  76
  77   win->m_x = event->x;
  78   win->m_y = event->y;
  79
  80   return FALSE;
  81 }
  82
  83 //-----------------------------------------------------------------------------
  84
  85 BEGIN_EVENT_TABLE(wxFrame, wxWindow)
  86   EVT_SIZE(wxFrame::OnSize)
  87   EVT_CLOSE(wxFrame::OnCloseWindow)
  88   EVT_IDLE(wxFrame::OnIdle)
  89 END_EVENT_TABLE()
  90
  91 IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
  92
  93 wxFrame::wxFrame()
  94 {
  95   m_frameMenuBar = (wxMenuBar *) NULL;
  96   m_frameStatusBar = (wxStatusBar *) NULL;
  97   m_frameToolBar = (wxToolBar *) NULL;
  98   m_sizeSet = FALSE;
  99   m_addPrivateChild = FALSE;
 100   m_wxwindow = (GtkWidget *) NULL;
 101   m_mainWindow = (GtkWidget *) NULL;
 102   wxTopLevelWindows.Insert( this );
 103 }
 104
 105 wxFrame::wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
 106       const wxPoint &pos, const wxSize &size,
 107       long style, const wxString &name )
 108 {
 109   m_frameMenuBar = (wxMenuBar *) NULL;
 110   m_frameStatusBar = (wxStatusBar *) NULL;
 111   m_frameToolBar = (wxToolBar *) NULL;
 112   m_sizeSet = FALSE;
 113   m_addPrivateChild = FALSE;
 114   m_wxwindow = (GtkWidget *) NULL;
 115   m_mainWindow = (GtkWidget *) NULL;
 116   Create( parent, id, title, pos, size, style, name );
 117   wxTopLevelWindows.Insert( this );
 118 }
 119
 120 bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
 121       const wxPoint &pos, const wxSize &size,
 122       long style, const wxString &name )
 123 {
 124   m_needParent = FALSE;
 125
 126   PreCreation( parent, id, pos, size, style, name );
 127
 128   m_title = title;
 129
 130   m_widget = gtk_window_new( GTK_WINDOW_TOPLEVEL );
 131   if ((size.x != -1) && (size.y != -1))
 132     gtk_widget_set_usize( m_widget, m_width, m_height );
 133   if ((pos.x != -1) && (pos.y != -1))
 134     gtk_widget_set_uposition( m_widget, m_x, m_y );
 135
 136   gtk_window_set_title( GTK_WINDOW(m_widget), title );
 137   GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 138
 139   gtk_widget_set( m_widget, "GtkWindow::allow_shrink", TRUE, NULL);
 140
 141   gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
 142     GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
 143
 144   m_mainWindow = gtk_myfixed_new();
 145   gtk_widget_show( m_mainWindow );
 146   GTK_WIDGET_UNSET_FLAGS( m_mainWindow, GTK_CAN_FOCUS );
 147
 148   gtk_container_add( GTK_CONTAINER(m_widget), m_mainWindow );
 149   gtk_widget_set_uposition( m_mainWindow, 0, 0 );
 150
 151   m_wxwindow = gtk_myfixed_new();
 152   gtk_widget_show( m_wxwindow );
 153   GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 154
 155   gtk_container_add( GTK_CONTAINER(m_mainWindow), m_wxwindow );
 156
 157   gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
 158     GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );
 159
 160   gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
 161     GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
 162
 163   PostCreation();
 164
 165   gtk_widget_realize( m_mainWindow );
 166
 167   return TRUE;
 168 }
 169
 170 wxFrame::~wxFrame()
 171 {
 172   if (m_frameMenuBar) delete m_frameMenuBar;
 173   if (m_frameStatusBar) delete m_frameStatusBar;
 174   if (m_frameToolBar) delete m_frameToolBar;
 175
 176 //  if (m_mainWindow) gtk_widget_destroy( m_mainWindow );
 177
 178   wxTopLevelWindows.DeleteObject( this );
 179   if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
 180 }
 181
 182 bool wxFrame::Show( bool show )
 183 {
 184   if (show)
 185   {
 186     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
 187     m_sizeSet = FALSE;
 188     ProcessEvent( event );
 189   }
 190   return wxWindow::Show( show );
 191 }
 192
 193 void wxFrame::Enable( bool enable )
 194 {
 195   wxWindow::Enable( enable );
 196   gtk_widget_set_sensitive( m_mainWindow, enable );
 197 }
 198
 199 void wxFrame::OnCloseWindow( wxCloseEvent &event )
 200 {
 201     if ( GetEventHandler()->OnClose() || event.GetForce())
 202     {
 203         this->Destroy();
 204     }
 205 }
 206
 207 bool wxFrame::Destroy()
 208 {
 209   if (!wxPendingDelete.Member(this))
 210     wxPendingDelete.Append(this);
 211
 212   return TRUE;
 213 }
 214
 215 void wxFrame::ImplementSetPosition(void)
 216 {
 217   if ((m_x != -1) || (m_y != -1))
 218      gtk_widget_set_uposition( m_widget, m_x, m_y );
 219 }
 220
 221 void wxFrame::Centre( int direction )
 222 {
 223   if (direction & wxHORIZONTAL == wxHORIZONTAL) m_x = (gdk_screen_width () - m_width) / 2;
 224   if (direction & wxVERTICAL == wxVERTICAL) m_y = (gdk_screen_height () - m_height) / 2;
 225   ImplementSetPosition();
 226 }
 227
 228 void wxFrame::GetClientSize( int *width, int *height ) const
 229 {
 230   wxWindow::GetClientSize( width, height );
 231   if (height)
 232   {
 233     if (m_frameMenuBar) (*height) -= wxMENU_HEIGHT;
 234     if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
 235     if (m_frameToolBar)
 236     {
 237       int y = 0;
 238       m_frameToolBar->GetSize( (int *) NULL, &y );
 239       (*height) -= y;
 240     }
 241   }
 242 }
 243
 244 void wxFrame::SetClientSize( int const width, int const height )
 245 {
 246   int h = height;
 247   if (m_frameMenuBar) h += wxMENU_HEIGHT;
 248   if (m_frameStatusBar) h += wxSTATUS_HEIGHT;
 249   if (m_frameToolBar)
 250   {
 251     int y = 0;
 252     m_frameToolBar->GetSize( (int *) NULL, &y );
 253     h += y;
 254   }
 255   wxWindow::SetClientSize( width, h );
 256 }
 257
 258 void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height )
 259 {
 260   // due to a bug in gtk, x,y are always 0
 261   // m_x = x;
 262   // m_y = y;
 263
 264   if ((m_height == height) && (m_width == width) &&
 265       (m_sizeSet)) return;
 266   if (!m_mainWindow) return;
 267   if (!m_wxwindow) return;
 268
 269   m_width = width;
 270   m_height = height;
 271
 272   // VZ: why??
 273   //gtk_widget_set_usize( m_widget, width, height );
 274
 275   int main_x = 0;
 276   int main_y = 0;
 277   int main_height = height;
 278   int main_width = width;
 279
 280   // This emulates Windows behaviour:
 281   // The menu bar is part of the main window, but the status bar
 282   // is on the implementation side in the client area. The
 283   // function GetClientSize returns the size of the client area
 284   // minus the status bar height. Under wxGTK, the main window
 285   // is represented by m_mainWindow. The menubar is inserted
 286   // into m_mainWindow whereas the statusbar is insertes into
 287   // m_wxwindow just like any other window.
 288
 289 //  not really needed
 290 //  gtk_widget_set_usize( m_mainWindow, width, height );
 291
 292   if (m_frameMenuBar)
 293   {
 294     main_y = wxMENU_HEIGHT;
 295     main_height -= wxMENU_HEIGHT;
 296   }
 297
 298   int toolbar_height = 0;
 299   if (m_frameToolBar) m_frameToolBar->GetSize( (int *) NULL, &toolbar_height );
 300
 301   main_y += toolbar_height;
 302   main_height -= toolbar_height;
 303
 304   gtk_myfixed_move( GTK_MYFIXED(m_mainWindow), m_wxwindow, main_x, main_y );
 305   gtk_widget_set_usize( m_wxwindow, main_width, main_height );
 306
 307   if (m_frameMenuBar)
 308   {
 309     gtk_myfixed_move( GTK_MYFIXED(m_mainWindow), m_frameMenuBar->m_widget, 1, 1 );
 310     gtk_widget_set_usize( m_frameMenuBar->m_widget, width-2, wxMENU_HEIGHT-2 );
 311   }
 312
 313   if (m_frameToolBar)
 314   {
 315     gtk_myfixed_move( GTK_MYFIXED(m_mainWindow), m_frameToolBar->m_widget, 1, wxMENU_HEIGHT );
 316     gtk_widget_set_usize( m_frameToolBar->m_widget, width-2, toolbar_height );
 317   }
 318
 319   if (m_frameStatusBar)
 320   {
 321     m_frameStatusBar->SetSize( 0, main_height-wxSTATUS_HEIGHT, width, wxSTATUS_HEIGHT );
 322   }
 323
 324   m_sizeSet = TRUE;
 325
 326   wxSizeEvent event( wxSize(m_width,m_height), GetId() );
 327   event.SetEventObject( this );
 328   ProcessEvent( event );
 329 }
 330
 331 void wxFrame::OnSize( wxSizeEvent &WXUNUSED(event) )
 332 {
 333   if ( GetAutoLayout() )
 334     Layout();
 335   else {
 336     // no child: go out !
 337     if (!GetChildren()->First())
 338       return;
 339
 340     // do we have exactly one child?
 341     wxWindow *child = (wxWindow *) NULL;
 342     for(wxNode *node = GetChildren()->First(); node; node = node->Next())
 343     {
 344       wxWindow *win = (wxWindow *)node->Data();
 345       if (!IS_KIND_OF(win,wxFrame) && !IS_KIND_OF(win,wxDialog)
 346 #if 0  // not in m_children anyway
 347           && (win != m_frameMenuBar) &&
 348              (win != m_frameToolBar) &&
 349              (win != m_frameStatusBar)
 350 #endif
 351          )
 352       {
 353         if ( child )  // it's the second one: do nothing
 354           return;
 355
 356         child = win;
 357       }
 358     }
 359
 360     // yes: set it's size to fill all the frame
 361     int client_x, client_y;
 362     GetClientSize(&client_x, &client_y);
 363     child->SetSize( 1, 1, client_x-2, client_y);
 364   }
 365 }
 366
 367 void wxFrame::AddChild( wxWindow *child )
 368 {
 369   // wxFrame and wxDialog as children aren't placed into the parents
 370
 371   if (IS_KIND_OF(child,wxMDIChildFrame)) printf( "wxFrame::AddChild error.\n" );
 372
 373   if ( IS_KIND_OF(child,wxFrame) || IS_KIND_OF(child,wxDialog))
 374   {
 375     m_children.Append( child );
 376
 377     if ((child->m_x != -1) && (child->m_y != -1))
 378       gtk_widget_set_uposition( child->m_widget, child->m_x, child->m_y );
 379
 380     return;
 381   }
 382
 383   if (m_addPrivateChild)
 384   {
 385     gtk_myfixed_put( GTK_MYFIXED(m_mainWindow), child->m_widget, child->m_x, child->m_y );
 386
 387     gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
 388   }
 389   else
 390   {
 391     m_children.Append( child );
 392
 393     if (m_wxwindow)
 394       gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget, child->m_x, child->m_y );
 395
 396     gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
 397   }
 398 }
 399
 400 static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
 401 {
 402   menu->SetInvokingWindow( win );
 403   wxNode *node = menu->m_items.First();
 404   while (node)
 405   {
 406     wxMenuItem *menuitem = (wxMenuItem*)node->Data();
 407     if (menuitem->IsSubMenu())
 408       SetInvokingWindow( menuitem->GetSubMenu(), win );
 409     node = node->Next();
 410   }
 411 }
 412
 413 void wxFrame::SetMenuBar( wxMenuBar *menuBar )
 414 {
 415   m_frameMenuBar = menuBar;
 416
 417   if (m_frameMenuBar)
 418   {
 419     wxNode *node = m_frameMenuBar->m_menus.First();
 420     while (node)
 421     {
 422       wxMenu *menu = (wxMenu*)node->Data();
 423       SetInvokingWindow( menu, this );
 424       node = node->Next();
 425     }
 426
 427     if (m_frameMenuBar->m_parent != this)
 428     {
 429       m_frameMenuBar->m_parent = this;
 430       gtk_myfixed_put( GTK_MYFIXED(m_mainWindow),
 431         m_frameMenuBar->m_widget, m_frameMenuBar->m_x, m_frameMenuBar->m_y );
 432     }
 433   }
 434 }
 435
 436 wxMenuBar *wxFrame::GetMenuBar(void) const
 437 {
 438   return m_frameMenuBar;
 439 }
 440
 441 wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
 442 {
 443   wxCHECK_MSG( m_frameToolBar == NULL, FALSE, "recreating toolbar in wxFrame" );
 444
 445   m_addPrivateChild = TRUE;
 446   m_frameToolBar = OnCreateToolBar( style, id, name );
 447   m_addPrivateChild = FALSE;
 448
 449   return m_frameToolBar;
 450 }
 451
 452 wxToolBar* wxFrame::OnCreateToolBar( long style, wxWindowID id, const wxString& name )
 453 {
 454   return new wxToolBar( this, id, wxDefaultPosition, wxDefaultSize, style, name );
 455 }
 456
 457 wxToolBar *wxFrame::GetToolBar(void) const
 458 {
 459   return m_frameToolBar;
 460 }
 461
 462 wxStatusBar* wxFrame::CreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
 463 {
 464   wxCHECK_MSG( m_frameStatusBar == NULL, FALSE, "recreating status bar in wxFrame" );
 465
 466   m_frameStatusBar = OnCreateStatusBar( number, style, id, name );
 467
 468   return m_frameStatusBar;
 469 }
 470
 471 wxStatusBar *wxFrame::OnCreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
 472 {
 473   wxStatusBar *statusBar = (wxStatusBar *) NULL;
 474
 475   statusBar = new wxStatusBar(this, id, wxPoint(0, 0), wxSize(100, 20), style, name);
 476
 477   // Set the height according to the font and the border size
 478   wxClientDC dc(statusBar);
 479   dc.SetFont( *statusBar->GetFont() );
 480
 481   long x, y;
 482   dc.GetTextExtent( "X", &x, &y );
 483
 484   int height = (int)( (y  * 1.1) + 2* statusBar->GetBorderY());
 485
 486   statusBar->SetSize( -1, -1, 100, height );
 487
 488   statusBar->SetFieldsCount( number );
 489   return statusBar;
 490 }
 491
 492 void wxFrame::SetStatusText(const wxString& text, int number)
 493 {
 494   wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set text for" );
 495
 496   m_frameStatusBar->SetStatusText(text, number);
 497 }
 498
 499 void wxFrame::SetStatusWidths(int n, const int widths_field[] )
 500 {
 501   wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set widths for" );
 502
 503   m_frameStatusBar->SetStatusWidths(n, widths_field);
 504 }
 505
 506 wxStatusBar *wxFrame::GetStatusBar(void) const
 507 {
 508   return m_frameStatusBar;
 509 }
 510
 511 void wxFrame::SetTitle( const wxString &title )
 512 {
 513   m_title = title;
 514   if (m_title.IsNull()) m_title = "";
 515   gtk_window_set_title( GTK_WINDOW(m_widget), title );
 516 }
 517
 518 void wxFrame::SetSizeHints(int minW, int minH,
 519                            int WXUNUSED(maxW), int WXUNUSED(maxH),
 520                            int WXUNUSED(incW) )
 521 {
 522   // gdk_window_set_hints alone doesn't really prevent the user from shrinking
 523   // the window to the size smaller than (minW, minH)
 524   gtk_widget_set_usize( GTK_WIDGET(m_widget), minW, minH );
 525
 526   /*
 527   gdk_window_set_hints( m_widget->window, -1, -1,
 528                               minW, minH, maxW, maxH,
 529                         GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE );
 530   */
 531 }
 532
 533 void wxFrame::SetIcon( const wxIcon &icon )
 534 {
 535   m_icon = icon;
 536   if (!icon.Ok()) return;
 537
 538   wxMask *mask = icon.GetMask();
 539   GdkBitmap *bm = (GdkBitmap *) NULL;
 540   if (mask) bm = mask->GetBitmap();
 541
 542   gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
 543 }
 544