src/gtk1/frame.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        frame.cpp
// Purpose:
// Author:      Robert Roebling
// Created:     01/02/97
// Id:
// Copyright:   (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "frame.h"
#endif

#include "wx/frame.h"
#include "wx/dialog.h"
#include "wx/control.h"
#include "wx/app.h"
#include "wx/menu.h"
#include "wx/toolbar.h"
#include "wx/statusbr.h"
#include "wx/mdi.h"
#include "wx/gtk/win_gtk.h"

const wxMENU_HEIGHT    = 28;
const wxSTATUS_HEIGHT  = 25;

extern wxList wxTopLevelWindows;
extern wxList wxPendingDelete;

//-----------------------------------------------------------------------------
// wxFrame
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// set size

void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxFrame *win )
{
  if (!win->HasVMT()) return;

/*
  printf( "OnFrameResize from " );
  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
    printf( win->GetClassInfo()->GetClassName() );
  printf( ".\n" );
*/

  win->GtkOnSize( alloc->x, alloc->y, alloc->width, alloc->height );
};

//-----------------------------------------------------------------------------
// delete

bool gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxFrame *win )
{
/*
  printf( "OnDelete from " );
  if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
    printf( win->GetClassInfo()->GetClassName() );
  printf( ".\n" );
*/

  win->Close();

  return TRUE;
};

//-----------------------------------------------------------------------------
// configure

gint gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrame *win )
{
  if (!win->HasVMT()) return FALSE;

  win->m_x = event->x;
  win->m_y = event->y;

  return FALSE;
};

//-----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(wxFrame, wxWindow)
  EVT_SIZE(wxFrame::OnSize)
  EVT_CLOSE(wxFrame::OnCloseWindow)
  EVT_IDLE(wxFrame::OnIdle)
END_EVENT_TABLE()

IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)

wxFrame::wxFrame()
{
  m_frameMenuBar = NULL;
  m_frameStatusBar = NULL;
  m_frameToolBar = NULL;
  m_sizeSet = FALSE;
  m_addPrivateChild = FALSE;
  m_wxwindow = NULL;
  m_mainWindow = NULL;
  wxTopLevelWindows.Insert( this );
};

wxFrame::wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
      const wxPoint &pos, const wxSize &size,
      long style, const wxString &name )
{
  m_frameMenuBar = NULL;
  m_frameStatusBar = NULL;
  m_frameToolBar = NULL;
  m_sizeSet = FALSE;
  m_addPrivateChild = FALSE;
  m_wxwindow = NULL;
  m_mainWindow = NULL;
  Create( parent, id, title, pos, size, style, name );
  wxTopLevelWindows.Insert( this );
};

bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
      const wxPoint &pos, const wxSize &size,
      long style, const wxString &name )
{
  m_needParent = FALSE;

  PreCreation( parent, id, pos, size, style, name );

  m_title = title;

  m_widget = gtk_window_new( GTK_WINDOW_TOPLEVEL );
  if ((size.x != -1) && (size.y != -1))
    gtk_widget_set_usize( m_widget, m_width, m_height );
  if ((pos.x != -1) && (pos.y != -1))
    gtk_widget_set_uposition( m_widget, m_x, m_y );

  gtk_window_set_title( GTK_WINDOW(m_widget), title );
  GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );

  gtk_widget_set( m_widget, "GtkWindow::allow_shrink", TRUE, NULL);

  gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
    GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );

  m_mainWindow = gtk_myfixed_new();
  gtk_widget_show( m_mainWindow );
  GTK_WIDGET_UNSET_FLAGS( m_mainWindow, GTK_CAN_FOCUS );

  gtk_container_add( GTK_CONTAINER(m_widget), m_mainWindow );
  gtk_widget_set_uposition( m_mainWindow, 0, 0 );

  m_wxwindow = gtk_myfixed_new();
  gtk_widget_show( m_wxwindow );
  GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );

  gtk_container_add( GTK_CONTAINER(m_mainWindow), m_wxwindow );

  gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
    GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );

  gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
    GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );

  PostCreation();

  gtk_widget_realize( m_mainWindow );

  return TRUE;
};

wxFrame::~wxFrame()
{
  if (m_frameMenuBar) delete m_frameMenuBar;
  if (m_frameStatusBar) delete m_frameStatusBar;

//  if (m_mainWindow) gtk_widget_destroy( m_mainWindow );

  wxTopLevelWindows.DeleteObject( this );
  if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
};

bool wxFrame::Show( bool show )
{
  if (show)
  {
    wxSizeEvent event( wxSize(m_width,m_height), GetId() );
    m_sizeSet = FALSE;
    ProcessEvent( event );
  };
  return wxWindow::Show( show );
};

void wxFrame::Enable( bool enable )
{
  wxWindow::Enable( enable );
  gtk_widget_set_sensitive( m_mainWindow, enable );
};

void wxFrame::OnCloseWindow( wxCloseEvent &event )
{
    if ( GetEventHandler()->OnClose() || event.GetForce())
    {
        this->Destroy();
    }
};

bool wxFrame::Destroy()
{
  if (!wxPendingDelete.Member(this))
    wxPendingDelete.Append(this);

  return TRUE;
}

void wxFrame::GetClientSize( int *width, int *height ) const
{
  wxWindow::GetClientSize( width, height );
  if (height)
  {
    if (m_frameMenuBar) (*height) -= wxMENU_HEIGHT;
    if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
    if (m_frameToolBar)
    {
      int y = 0;
      m_frameToolBar->GetSize( NULL, &y );
      (*height) -= y;
    }
  };
};

void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), int width, int height )
{
  // due to a bug in gtk, x,y are always 0
  // m_x = x;
  // m_y = y;

  if ((m_height == height) && (m_width == width) &&
      (m_sizeSet)) return;
  if (!m_mainWindow) return;
  if (!m_wxwindow) return;

  m_width = width;
  m_height = height;

  gtk_widget_set_usize( m_widget, width, height );

  int main_x = 0;
  int main_y = 0;
  int main_height = height;
  int main_width = width;

  // This emulates Windows behaviour:
  // The menu bar is part of the main window, but the status bar
  // is on the implementation side in the client area. The
  // function GetClientSize returns the size of the client area
  // minus the status bar height. Under wxGTK, the main window
  // is represented by m_mainWindow. The menubar is inserted
  // into m_mainWindow whereas the statusbar is insertes into
  // m_wxwindow just like any other window.

//  not really needed
//  gtk_widget_set_usize( m_mainWindow, width, height );

  if (m_frameMenuBar)
  {
    main_y = wxMENU_HEIGHT;
    main_height -= wxMENU_HEIGHT;
  };

  int toolbar_height = 0;
  if (m_frameToolBar) m_frameToolBar->GetSize( NULL, &toolbar_height );

  main_y += toolbar_height;
  main_height -= toolbar_height;

  gtk_myfixed_move( GTK_MYFIXED(m_mainWindow), m_wxwindow, main_x, main_y );
  gtk_widget_set_usize( m_wxwindow, main_width, main_height );

  if (m_frameMenuBar)
  {
    gtk_myfixed_move( GTK_MYFIXED(m_mainWindow), m_frameMenuBar->m_widget, 1, 1 );
    gtk_widget_set_usize( m_frameMenuBar->m_widget, width-2, wxMENU_HEIGHT-2 );
  };

  if (m_frameToolBar)
  {
    gtk_myfixed_move( GTK_MYFIXED(m_mainWindow), m_frameToolBar->m_widget, 1, wxMENU_HEIGHT );
    gtk_widget_set_usize( m_frameToolBar->m_widget, width-2, toolbar_height );
  };

  if (m_frameStatusBar)
  {
    m_frameStatusBar->SetSize( 0, main_height-wxSTATUS_HEIGHT, width, wxSTATUS_HEIGHT );
  };

  m_sizeSet = TRUE;

  wxSizeEvent event( wxSize(m_width,m_height), GetId() );
  event.SetEventObject( this );
  ProcessEvent( event );
};

void wxFrame::OnSize( wxSizeEvent &WXUNUSED(event) )
{
  if ( GetAutoLayout() )
    Layout();
  else {
    // no child: go out !
    if (!GetChildren()->First())
      return;

    // do we have exactly one child?
    wxWindow *child = NULL;
    for(wxNode *node = GetChildren()->First(); node; node = node->Next())
    {
      wxWindow *win = (wxWindow *)node->Data();
      if (!IS_KIND_OF(win,wxFrame) && !IS_KIND_OF(win,wxDialog)
#if 0  // not in m_children anyway
          && (win != m_frameMenuBar) &&
             (win != m_frameToolBar) &&
             (win != m_frameStatusBar)
#endif
         )
      {
        if ( child )  // it's the second one: do nothing
          return;

        child = win;
      };
    };

    // yes: set it's size to fill all the frame
    int client_x, client_y;
    GetClientSize(&client_x, &client_y);
    child->SetSize( 1, 1, client_x-2, client_y);
  }
};

void wxFrame::AddChild( wxWindow *child )
{
  // wxFrame and wxDialog as children aren't placed into the parents

  if (IS_KIND_OF(child,wxMDIChildFrame)) printf( "wxFrame::AddChild error.\n" );

  if ( IS_KIND_OF(child,wxFrame) || IS_KIND_OF(child,wxDialog))
  {
    m_children.Append( child );

    if ((child->m_x != -1) && (child->m_y != -1))
      gtk_widget_set_uposition( child->m_widget, child->m_x, child->m_y );

    return;
  }

  if (m_addPrivateChild)
  {
    gtk_myfixed_put( GTK_MYFIXED(m_mainWindow), child->m_widget, child->m_x, child->m_y );

    gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
  }
  else
  {
    m_children.Append( child );

    if (m_wxwindow)
      gtk_myfixed_put( GTK_MYFIXED(m_wxwindow), child->m_widget, child->m_x, child->m_y );

    gtk_widget_set_usize( child->m_widget, child->m_width, child->m_height );
  }
};

static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
{
  menu->SetInvokingWindow( win );
  wxNode *node = menu->m_items.First();
  while (node)
  {
    wxMenuItem *menuitem = (wxMenuItem*)node->Data();
    if (menuitem->IsSubMenu())
      SetInvokingWindow( menuitem->GetSubMenu(), win );
    node = node->Next();
  };
};

void wxFrame::SetMenuBar( wxMenuBar *menuBar )
{
  m_frameMenuBar = menuBar;

  if (m_frameMenuBar)
  {
    if (m_frameMenuBar->m_parent != this)
    {
      wxNode *node = m_frameMenuBar->m_menus.First();
      while (node)
      {
        wxMenu *menu = (wxMenu*)node->Data();
        SetInvokingWindow( menu, this );
        node = node->Next();
      };

      m_frameMenuBar->m_parent = this;
      gtk_myfixed_put( GTK_MYFIXED(m_mainWindow),
        m_frameMenuBar->m_widget, m_frameMenuBar->m_x, m_frameMenuBar->m_y );
    }
  }
};

wxMenuBar *wxFrame::GetMenuBar(void)
{
  return m_frameMenuBar;
};

wxToolBar *wxFrame::CreateToolBar( long style , wxWindowID id, const wxString& name )
{
  m_addPrivateChild = TRUE;

  m_frameToolBar = new wxToolBar( this, id, wxDefaultPosition, wxDefaultSize, style, name );

  m_addPrivateChild = FALSE;

  return m_frameToolBar;
};

wxToolBar *wxFrame::GetToolBar(void)
{
  return m_frameToolBar;
};

wxStatusBar* wxFrame::CreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
{
  if (m_frameStatusBar)
  delete m_frameStatusBar;

  m_frameStatusBar = new wxStatusBar( this, id, wxPoint(0,0), wxSize(100,20), style, name );

  m_frameStatusBar->SetFieldsCount( number );

  return m_frameStatusBar;
};

void wxFrame::SetStatusText( const wxString &text, int number )
{
  if (m_frameStatusBar) m_frameStatusBar->SetStatusText( text, number );
};

void wxFrame::SetStatusWidths( int n, int *width )
{
  if (m_frameStatusBar) m_frameStatusBar->SetStatusWidths( n, width );
};

wxStatusBar *wxFrame::GetStatusBar(void)
{
  return m_frameStatusBar;
};

void wxFrame::SetTitle( const wxString &title )
{
  m_title = title;
  gtk_window_set_title( GTK_WINDOW(m_widget), title );
};

void wxFrame::SetSizeHints(int minW, int minH, int maxW, int maxH, int WXUNUSED(incW) )
{
  if (m_wxwindow)
    gdk_window_set_hints( m_wxwindow->window, -1, -1,
	                  minW, minH, maxW, maxH, GDK_HINT_MIN_SIZE | GDK_HINT_MIN_SIZE );
}

void wxFrame::SetIcon( const wxIcon &icon )
{
  m_icon = icon;
  if (!icon.Ok()) return;

  wxMask *mask = icon.GetMask();
  GdkBitmap *bm = NULL;
  if (mask) bm = mask->GetBitmap();

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