src/gtk/notebook.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        notebook.cpp
// Purpose:
// Author:      Robert Roebling
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling, Vadim Zeitlin
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#include "wx/notebook.h"
#include "wx/panel.h"
#include "wx/utils.h"
#include "wx/imaglist.h"
#include "wx/intl.h"
#include "wx/log.h"

//-----------------------------------------------------------------------------
// wxNotebookPage
//-----------------------------------------------------------------------------

class wxNotebookPage: public wxObject
{
public:
  wxNotebookPage()
  {
    m_id = -1;
    m_text = "";
    m_image = -1;
    m_page = (GtkNotebookPage *) NULL;
    m_client = (wxWindow *) NULL;
    m_parent = (GtkNotebook *) NULL;
    m_box = (GtkWidget *) NULL;
  }

  int                m_id;
  wxString           m_text;
  int                m_image;
  GtkNotebookPage   *m_page;
  GtkLabel          *m_label;
  wxWindow          *m_client;
  GtkNotebook       *m_parent;
  GtkWidget         *m_box;     // in which the label and image are packed
};

//-----------------------------------------------------------------------------
// "switch_page"
//-----------------------------------------------------------------------------

static void gtk_notebook_page_change_callback(GtkNotebook *WXUNUSED(widget),
                                              GtkNotebookPage *WXUNUSED(page),
                                              gint nPage,
                                              gpointer data)
{
  wxNotebook *notebook = (wxNotebook *)data;

  int old = notebook->GetSelection();

  // TODO: emulate PAGE_CHANGING event

  wxNotebookEvent event( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
                         notebook->GetId(),  nPage, old );
  event.SetEventObject( notebook );
  notebook->GetEventHandler()->ProcessEvent( event );
}

//-----------------------------------------------------------------------------
// "size_allocate"
//-----------------------------------------------------------------------------

static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxWindow *win )
{
  if ((win->m_x == alloc->x) &&
      (win->m_y == alloc->y) &&
      (win->m_width == alloc->width) &&
      (win->m_height == alloc->height))
  {
    return;
  }

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

//-----------------------------------------------------------------------------
// InsertChild callback for wxNotebook
//-----------------------------------------------------------------------------

static void wxInsertChildInNotebook( wxNotebook* parent, wxWindow* child )
{
  wxNotebookPage *page = new wxNotebookPage();

  page->m_id = parent->GetPageCount();

  page->m_box = gtk_hbox_new (FALSE, 0);
  gtk_container_border_width(GTK_CONTAINER(page->m_box), 2);

  GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);

  page->m_client = child;
  gtk_notebook_append_page( notebook, child->m_widget, page->m_box );

  page->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);

  page->m_parent = notebook;

  gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
    GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );

  if (!page->m_page)
  {
     wxLogFatalError( "Notebook page creation error" );
     return;
  }

  parent->m_pages.Append( page );
}

//-----------------------------------------------------------------------------
// wxNotebook
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxNotebook,wxControl)

void wxNotebook::Init()
{
  m_imageList = (wxImageList *) NULL;
  m_pages.DeleteContents( TRUE );
  m_idHandler = 0;
}

wxNotebook::wxNotebook()
{
  Init();
}

wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id,
      const wxPoint& pos, const wxSize& size,
      long style, const wxString& name )
{
  Init();
  Create( parent, id, pos, size, style, name );
}

wxNotebook::~wxNotebook()
{
  // don't generate change page events any more
  if (m_idHandler != 0)
    gtk_signal_disconnect(GTK_OBJECT(m_widget), m_idHandler);

  DeleteAllPages();
}

bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
      const wxPoint& pos, const wxSize& size,
      long style, const wxString& name )
{
  m_needParent = TRUE;
  m_insertCallback = (wxInsertChildFunction)wxInsertChildInNotebook;

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

  m_widget = gtk_notebook_new();

  gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );

  m_idHandler = gtk_signal_connect (
                  GTK_OBJECT(m_widget), "switch_page",
                  GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback),
                  (gpointer)this );

  m_parent->AddChild( this );

  (m_parent->m_insertCallback)( m_parent, this );

  PostCreation();

  Show( TRUE );

  return TRUE;
}

int wxNotebook::GetSelection() const
{
  wxCHECK_MSG( m_widget != NULL, -1, "invalid notebook" );

  if (m_pages.Number() == 0) return -1;

  GtkNotebookPage *g_page = GTK_NOTEBOOK(m_widget)->cur_page;
  if (!g_page) return -1;

  wxNotebookPage *page = (wxNotebookPage *) NULL;

  wxNode *node = m_pages.First();
  while (node)
  {
    page = (wxNotebookPage*)node->Data();

    if ((page->m_page == g_page) || (page->m_page == (GtkNotebookPage*)NULL))
    {
        // page->m_page is NULL directly after gtk_notebook_append. gtk emits
	// "switch_page" then and we ask for GetSelection() in the handler for
	// "switch_page". otherwise m_page should never be NULL. all this
	// might also be wrong.
        break;
    }
    node = node->Next();
  }

  wxCHECK_MSG( node != NULL, -1, "wxNotebook: no selection?" );

  return page->m_id;
}

int wxNotebook::GetPageCount() const
{
  return m_pages.Number();
}

int wxNotebook::GetRowCount() const
{
  return 1;
}

wxString wxNotebook::GetPageText( int page ) const
{
  wxCHECK_MSG( m_widget != NULL, "", "invalid notebook" );

  wxNotebookPage* nb_page = GetNotebookPage(page);
  if (nb_page)
    return nb_page->m_text;
  else
    return "";
}

int wxNotebook::GetPageImage( int page ) const
{
  wxCHECK_MSG( m_widget != NULL, 0, "invalid notebook" );

  wxNotebookPage* nb_page = GetNotebookPage(page);
  if (nb_page)
    return nb_page->m_image;
  else
    return 0;
}

wxNotebookPage* wxNotebook::GetNotebookPage(int page) const
{
  wxCHECK_MSG( m_widget != NULL, (wxNotebookPage*)NULL, "invalid notebook" );

  wxNotebookPage *nb_page = (wxNotebookPage *) NULL;

  wxNode *node = m_pages.First();
  while (node)
  {
    nb_page = (wxNotebookPage*)node->Data();
    if (nb_page->m_id == page)
      return nb_page;
    node = node->Next();
  }

  wxLogDebug( "Notebook page %d not found!", page );

  return (wxNotebookPage *) NULL;
}

int wxNotebook::SetSelection( int page )
{
  wxCHECK_MSG( m_widget != NULL, -1, "invalid notebook" );

  int selOld = GetSelection();
  wxNotebookPage* nb_page = GetNotebookPage(page);

  if (!nb_page) return -1;

  int page_num = 0;
  GList *child = GTK_NOTEBOOK(m_widget)->children;
  while (child)
  {
    if (nb_page->m_page == (GtkNotebookPage*)child->data)  break;
    page_num++;
    child = child->next;
  }

  if (!child) return -1;

  gtk_notebook_set_page( GTK_NOTEBOOK(m_widget), page_num );

  return selOld;
}

void wxNotebook::AdvanceSelection( bool bForward )
{
  wxCHECK_RET( m_widget != NULL, "invalid notebook" );

  int sel = GetSelection();
  int max = GetPageCount();

  if (bForward)
    SetSelection( sel == max ? 0 : sel + 1 );
  else
    SetSelection( sel == 0 ? max : sel - 1 );
}

void wxNotebook::SetImageList( wxImageList* imageList )
{
  m_imageList = imageList;
}

bool wxNotebook::SetPageText( int page, const wxString &text )
{
  wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );

  wxNotebookPage* nb_page = GetNotebookPage(page);

  if (!nb_page) return FALSE;

  nb_page->m_text = text;

  return TRUE;
}

bool wxNotebook::SetPageImage( int page, int image )
{
  wxNotebookPage* nb_page = GetNotebookPage(page);

  if (!nb_page) return FALSE;

  nb_page->m_image = image;

  return TRUE;
}

void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
{
  wxFAIL_MSG( "wxNotebook::SetPageSize not implemented" );
}

void wxNotebook::SetPadding( const wxSize &WXUNUSED(padding) )
{
  wxFAIL_MSG( "wxNotebook::SetPadding not implemented" );
}

bool wxNotebook::DeleteAllPages()
{
  wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );

  wxNode *page_node = m_pages.First();
  while (page_node)
  {
    wxNotebookPage *page = (wxNotebookPage*)page_node->Data();

    DeletePage( page->m_id );

    page_node = m_pages.First();
  }

  return TRUE;
}

bool wxNotebook::DeletePage( int page )
{
  wxNotebookPage* nb_page = GetNotebookPage(page);
  if (!nb_page) return FALSE;

  int page_num = 0;
  GList *child = GTK_NOTEBOOK(m_widget)->children;
  while (child)
  {
    if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
    page_num++;
    child = child->next;
  }

  wxCHECK_MSG( child != NULL, FALSE, "illegal notebook index" );

  delete nb_page->m_client;

  m_pages.DeleteObject( nb_page );

  return TRUE;
}

bool wxNotebook::RemovePage( int page )
{
  wxNotebookPage* nb_page = GetNotebookPage(page);
  if (!nb_page) return FALSE;

  int page_num = 0;
  GList *child = GTK_NOTEBOOK(m_widget)->children;
  while (child)
  {
    if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
    page_num++;
    child = child->next;
  }

  wxCHECK_MSG( child != NULL, FALSE, "illegal notebook index" );

  gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page_num );

  m_pages.DeleteObject( nb_page );

  return TRUE;
}

bool wxNotebook::AddPage(wxWindow* win, const wxString& text,
                         bool bSelect, int imageId)
{
  wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );

  // we've created the notebook page in AddChild(). Now we just have to set
  // the caption for the page and set the others parameters.

  wxNotebookPage *page = (wxNotebookPage *) NULL;

  wxNode *node = m_pages.First();
  while (node)
  {
    page = (wxNotebookPage*)node->Data();
    if ( page->m_client == win ) break;
    node = node->Next();
  }

  wxCHECK_MSG( page != NULL, FALSE, "Can't add a page whose parent is not the notebook!" );

  if (imageId != -1)
  {
    wxASSERT( m_imageList != NULL );

    const wxBitmap *bmp = m_imageList->GetBitmap(imageId);
    GdkPixmap *pixmap = bmp->GetPixmap();
    GdkBitmap *mask = (GdkBitmap*) NULL;
    if ( bmp->GetMask() )
    {
      mask = bmp->GetMask()->GetBitmap();
    }

    GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask );

    gtk_box_pack_start(GTK_BOX(page->m_box), pixmapwid, FALSE, FALSE, 3);

    gtk_widget_show(pixmapwid);
  }

  // then set the attributes
  page->m_text = text;
  if (page->m_text.IsEmpty()) page->m_text = "";
  page->m_image = imageId;
  page->m_label = (GtkLabel *)gtk_label_new(page->m_text);
  gtk_box_pack_start( GTK_BOX(page->m_box), (GtkWidget *)page->m_label, FALSE, FALSE, 3);

  // @@@: what does this do? do we still need it?
  // gtk_misc_set_alignment(GTK_MISC(page->m_label), 0.0, 0.5);

  gtk_widget_show((GtkWidget *)page->m_label);

  if (bSelect) SetSelection(GetPageCount());

  return TRUE;
}

wxWindow *wxNotebook::GetPage( int page ) const
{
  wxCHECK_MSG( m_widget != NULL, (wxWindow*) NULL, "invalid notebook" );

  wxNotebookPage* nb_page = GetNotebookPage(page);
  if (!nb_page)
    return (wxWindow *) NULL;
  else
    return nb_page->m_client;
}

// override these 2 functions to do nothing: everything is done in OnSize
void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
{
  // don't set the sizes of the pages - their correct size is not yet known
  wxControl::SetConstraintSizes(FALSE);
}

bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
{
  return TRUE;
}

void wxNotebook::ApplyWidgetStyle()
{
  SetWidgetStyle();
  gtk_widget_set_style( m_widget, m_widgetStyle );
}

//-----------------------------------------------------------------------------
// wxNotebookEvent
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: notebook.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Id: $Id$
	6	// Copyright: (c) 1998 Robert Roebling, Vadim Zeitlin
	7	// Licence: wxWindows licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	#ifdef __GNUG__
	11	#pragma implementation "notebook.h"
	12	#endif
	13
	14	#include "wx/notebook.h"
	15	#include "wx/panel.h"
	16	#include "wx/utils.h"
	17	#include "wx/imaglist.h"
	18	#include "wx/intl.h"
	19	#include "wx/log.h"
	20
	21	//-----------------------------------------------------------------------------
	22	// wxNotebookPage
	23	//-----------------------------------------------------------------------------
	24
	25	class wxNotebookPage: public wxObject
	26	{
	27	public:
	28	wxNotebookPage()
	29	{
	30	m_id = -1;
	31	m_text = "";
	32	m_image = -1;
	33	m_page = (GtkNotebookPage *) NULL;
	34	m_client = (wxWindow *) NULL;
	35	m_parent = (GtkNotebook *) NULL;
	36	m_box = (GtkWidget *) NULL;
	37	}
	38
	39	int m_id;
	40	wxString m_text;
	41	int m_image;
	42	GtkNotebookPage *m_page;
	43	GtkLabel *m_label;
	44	wxWindow *m_client;
	45	GtkNotebook *m_parent;
	46	GtkWidget *m_box; // in which the label and image are packed
	47	};
	48
	49	//-----------------------------------------------------------------------------
	50	// "switch_page"
	51	//-----------------------------------------------------------------------------
	52
	53	static void gtk_notebook_page_change_callback(GtkNotebook *WXUNUSED(widget),
	54	GtkNotebookPage *WXUNUSED(page),
	55	gint nPage,
	56	gpointer data)
	57	{
	58	wxNotebook notebook = (wxNotebook )data;
	59
	60	int old = notebook->GetSelection();
	61
	62	// TODO: emulate PAGE_CHANGING event
	63
	64	wxNotebookEvent event( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
	65	notebook->GetId(), nPage, old );
	66	event.SetEventObject( notebook );
	67	notebook->GetEventHandler()->ProcessEvent( event );
	68	}
	69
	70	//-----------------------------------------------------------------------------
	71	// "size_allocate"
	72	//-----------------------------------------------------------------------------
	73
	74	static void gtk_page_size_callback( GtkWidget WXUNUSED(widget), GtkAllocation alloc, wxWindow *win )
	75	{
	76	if ((win->m_x == alloc->x) &&
	77	(win->m_y == alloc->y) &&
	78	(win->m_width == alloc->width) &&
	79	(win->m_height == alloc->height))
	80	{
	81	return;
	82	}
	83
	84	win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
	85	}
	86
	87	//-----------------------------------------------------------------------------
	88	// InsertChild callback for wxNotebook
	89	//-----------------------------------------------------------------------------
	90
	91	static void wxInsertChildInNotebook( wxNotebook* parent, wxWindow* child )
	92	{
	93	wxNotebookPage *page = new wxNotebookPage();
	94
	95	page->m_id = parent->GetPageCount();
	96
	97	page->m_box = gtk_hbox_new (FALSE, 0);
	98	gtk_container_border_width(GTK_CONTAINER(page->m_box), 2);
	99
	100	GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
	101
	102	page->m_client = child;
	103	gtk_notebook_append_page( notebook, child->m_widget, page->m_box );
	104
	105	page->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
	106
	107	page->m_parent = notebook;
	108
	109	gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
	110	GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
	111
	112	if (!page->m_page)
	113	{
	114	wxLogFatalError( "Notebook page creation error" );
	115	return;
	116	}
	117
	118	parent->m_pages.Append( page );
	119	}
	120
	121	//-----------------------------------------------------------------------------
	122	// wxNotebook
	123	//-----------------------------------------------------------------------------
	124
	125	IMPLEMENT_DYNAMIC_CLASS(wxNotebook,wxControl)
	126
	127	void wxNotebook::Init()
	128	{
	129	m_imageList = (wxImageList *) NULL;
	130	m_pages.DeleteContents( TRUE );
	131	m_idHandler = 0;
	132	}
	133
	134	wxNotebook::wxNotebook()
	135	{
	136	Init();
	137	}
	138
	139	wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id,
	140	const wxPoint& pos, const wxSize& size,
	141	long style, const wxString& name )
	142	{
	143	Init();
	144	Create( parent, id, pos, size, style, name );
	145	}
	146
	147	wxNotebook::~wxNotebook()
	148	{
	149	// don't generate change page events any more
	150	if (m_idHandler != 0)
	151	gtk_signal_disconnect(GTK_OBJECT(m_widget), m_idHandler);
	152
	153	DeleteAllPages();
	154	}
	155
	156	bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
	157	const wxPoint& pos, const wxSize& size,
	158	long style, const wxString& name )
	159	{
	160	m_needParent = TRUE;
	161	m_insertCallback = (wxInsertChildFunction)wxInsertChildInNotebook;
	162
	163	PreCreation( parent, id, pos, size, style, name );
	164
	165	m_widget = gtk_notebook_new();
	166
	167	gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
	168
	169	m_idHandler = gtk_signal_connect (
	170	GTK_OBJECT(m_widget), "switch_page",
	171	GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback),
	172	(gpointer)this );
	173
	174	m_parent->AddChild( this );
	175
	176	(m_parent->m_insertCallback)( m_parent, this );
	177
	178	PostCreation();
	179
	180	Show( TRUE );
	181
	182	return TRUE;
	183	}
	184
	185	int wxNotebook::GetSelection() const
	186	{
	187	wxCHECK_MSG( m_widget != NULL, -1, "invalid notebook" );
	188
	189	if (m_pages.Number() == 0) return -1;
	190
	191	GtkNotebookPage *g_page = GTK_NOTEBOOK(m_widget)->cur_page;
	192	if (!g_page) return -1;
	193
	194	wxNotebookPage page = (wxNotebookPage ) NULL;
	195
	196	wxNode *node = m_pages.First();
	197	while (node)
	198	{
	199	page = (wxNotebookPage*)node->Data();
	200
	201	if ((page->m_page == g_page) \|\| (page->m_page == (GtkNotebookPage*)NULL))
	202	{
	203	// page->m_page is NULL directly after gtk_notebook_append. gtk emits
	204	// "switch_page" then and we ask for GetSelection() in the handler for
	205	// "switch_page". otherwise m_page should never be NULL. all this
	206	// might also be wrong.
	207	break;
	208	}
	209	node = node->Next();
	210	}
	211
	212	wxCHECK_MSG( node != NULL, -1, "wxNotebook: no selection?" );
	213
	214	return page->m_id;
	215	}
	216
	217	int wxNotebook::GetPageCount() const
	218	{
	219	return m_pages.Number();
	220	}
	221
	222	int wxNotebook::GetRowCount() const
	223	{
	224	return 1;
	225	}
	226
	227	wxString wxNotebook::GetPageText( int page ) const
	228	{
	229	wxCHECK_MSG( m_widget != NULL, "", "invalid notebook" );
	230
	231	wxNotebookPage* nb_page = GetNotebookPage(page);
	232	if (nb_page)
	233	return nb_page->m_text;
	234	else
	235	return "";
	236	}
	237
	238	int wxNotebook::GetPageImage( int page ) const
	239	{
	240	wxCHECK_MSG( m_widget != NULL, 0, "invalid notebook" );
	241
	242	wxNotebookPage* nb_page = GetNotebookPage(page);
	243	if (nb_page)
	244	return nb_page->m_image;
	245	else
	246	return 0;
	247	}
	248
	249	wxNotebookPage* wxNotebook::GetNotebookPage(int page) const
	250	{
	251	wxCHECK_MSG( m_widget != NULL, (wxNotebookPage*)NULL, "invalid notebook" );
	252
	253	wxNotebookPage nb_page = (wxNotebookPage ) NULL;
	254
	255	wxNode *node = m_pages.First();
	256	while (node)
	257	{
	258	nb_page = (wxNotebookPage*)node->Data();
	259	if (nb_page->m_id == page)
	260	return nb_page;
	261	node = node->Next();
	262	}
	263
	264	wxLogDebug( "Notebook page %d not found!", page );
	265
	266	return (wxNotebookPage *) NULL;
	267	}
	268
	269	int wxNotebook::SetSelection( int page )
	270	{
	271	wxCHECK_MSG( m_widget != NULL, -1, "invalid notebook" );
	272
	273	int selOld = GetSelection();
	274	wxNotebookPage* nb_page = GetNotebookPage(page);
	275
	276	if (!nb_page) return -1;
	277
	278	int page_num = 0;
	279	GList *child = GTK_NOTEBOOK(m_widget)->children;
	280	while (child)
	281	{
	282	if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
	283	page_num++;
	284	child = child->next;
	285	}
	286
	287	if (!child) return -1;
	288
	289	gtk_notebook_set_page( GTK_NOTEBOOK(m_widget), page_num );
	290
	291	return selOld;
	292	}
	293
	294	void wxNotebook::AdvanceSelection( bool bForward )
	295	{
	296	wxCHECK_RET( m_widget != NULL, "invalid notebook" );
	297
	298	int sel = GetSelection();
	299	int max = GetPageCount();
	300
	301	if (bForward)
	302	SetSelection( sel == max ? 0 : sel + 1 );
	303	else
	304	SetSelection( sel == 0 ? max : sel - 1 );
	305	}
	306
	307	void wxNotebook::SetImageList( wxImageList* imageList )
	308	{
	309	m_imageList = imageList;
	310	}
	311
	312	bool wxNotebook::SetPageText( int page, const wxString &text )
	313	{
	314	wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );
	315
	316	wxNotebookPage* nb_page = GetNotebookPage(page);
	317
	318	if (!nb_page) return FALSE;
	319
	320	nb_page->m_text = text;
	321
	322	return TRUE;
	323	}
	324
	325	bool wxNotebook::SetPageImage( int page, int image )
	326	{
	327	wxNotebookPage* nb_page = GetNotebookPage(page);
	328
	329	if (!nb_page) return FALSE;
	330
	331	nb_page->m_image = image;
	332
	333	return TRUE;
	334	}
	335
	336	void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
	337	{
	338	wxFAIL_MSG( "wxNotebook::SetPageSize not implemented" );
	339	}
	340
	341	void wxNotebook::SetPadding( const wxSize &WXUNUSED(padding) )
	342	{
	343	wxFAIL_MSG( "wxNotebook::SetPadding not implemented" );
	344	}
	345
	346	bool wxNotebook::DeleteAllPages()
	347	{
	348	wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );
	349
	350	wxNode *page_node = m_pages.First();
	351	while (page_node)
	352	{
	353	wxNotebookPage page = (wxNotebookPage)page_node->Data();
	354
	355	DeletePage( page->m_id );
	356
	357	page_node = m_pages.First();
	358	}
	359
	360	return TRUE;
	361	}
	362
	363	bool wxNotebook::DeletePage( int page )
	364	{
	365	wxNotebookPage* nb_page = GetNotebookPage(page);
	366	if (!nb_page) return FALSE;
	367
	368	int page_num = 0;
	369	GList *child = GTK_NOTEBOOK(m_widget)->children;
	370	while (child)
	371	{
	372	if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
	373	page_num++;
	374	child = child->next;
	375	}
	376
	377	wxCHECK_MSG( child != NULL, FALSE, "illegal notebook index" );
	378
	379	delete nb_page->m_client;
	380
	381	m_pages.DeleteObject( nb_page );
	382
	383	return TRUE;
	384	}
	385
	386	bool wxNotebook::RemovePage( int page )
	387	{
	388	wxNotebookPage* nb_page = GetNotebookPage(page);
	389	if (!nb_page) return FALSE;
	390
	391	int page_num = 0;
	392	GList *child = GTK_NOTEBOOK(m_widget)->children;
	393	while (child)
	394	{
	395	if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
	396	page_num++;
	397	child = child->next;
	398	}
	399
	400	wxCHECK_MSG( child != NULL, FALSE, "illegal notebook index" );
	401
	402	gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page_num );
	403
	404	m_pages.DeleteObject( nb_page );
	405
	406	return TRUE;
	407	}
	408
	409	bool wxNotebook::AddPage(wxWindow* win, const wxString& text,
	410	bool bSelect, int imageId)
	411	{
	412	wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );
	413
	414	// we've created the notebook page in AddChild(). Now we just have to set
	415	// the caption for the page and set the others parameters.
	416
	417	wxNotebookPage page = (wxNotebookPage ) NULL;
	418
	419	wxNode *node = m_pages.First();
	420	while (node)
	421	{
	422	page = (wxNotebookPage*)node->Data();
	423	if ( page->m_client == win ) break;
	424	node = node->Next();
	425	}
	426
	427	wxCHECK_MSG( page != NULL, FALSE, "Can't add a page whose parent is not the notebook!" );
	428
	429	if (imageId != -1)
	430	{
	431	wxASSERT( m_imageList != NULL );
	432
	433	const wxBitmap *bmp = m_imageList->GetBitmap(imageId);
	434	GdkPixmap *pixmap = bmp->GetPixmap();
	435	GdkBitmap mask = (GdkBitmap) NULL;
	436	if ( bmp->GetMask() )
	437	{
	438	mask = bmp->GetMask()->GetBitmap();
	439	}
	440
	441	GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask );
	442
	443	gtk_box_pack_start(GTK_BOX(page->m_box), pixmapwid, FALSE, FALSE, 3);
	444
	445	gtk_widget_show(pixmapwid);
	446	}
	447
	448	// then set the attributes
	449	page->m_text = text;
	450	if (page->m_text.IsEmpty()) page->m_text = "";
	451	page->m_image = imageId;
	452	page->m_label = (GtkLabel *)gtk_label_new(page->m_text);
	453	gtk_box_pack_start( GTK_BOX(page->m_box), (GtkWidget *)page->m_label, FALSE, FALSE, 3);
	454
	455	// @@@: what does this do? do we still need it?
	456	// gtk_misc_set_alignment(GTK_MISC(page->m_label), 0.0, 0.5);
	457
	458	gtk_widget_show((GtkWidget *)page->m_label);
	459
	460	if (bSelect) SetSelection(GetPageCount());
	461
	462	return TRUE;
	463	}
	464
	465	wxWindow *wxNotebook::GetPage( int page ) const
	466	{
	467	wxCHECK_MSG( m_widget != NULL, (wxWindow*) NULL, "invalid notebook" );
	468
	469	wxNotebookPage* nb_page = GetNotebookPage(page);
	470	if (!nb_page)
	471	return (wxWindow *) NULL;
	472	else
	473	return nb_page->m_client;
	474	}
	475
	476	// override these 2 functions to do nothing: everything is done in OnSize
	477	void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
	478	{
	479	// don't set the sizes of the pages - their correct size is not yet known
	480	wxControl::SetConstraintSizes(FALSE);
	481	}
	482
	483	bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
	484	{
	485	return TRUE;
	486	}
	487
	488	void wxNotebook::ApplyWidgetStyle()
	489	{
	490	SetWidgetStyle();
	491	gtk_widget_set_style( m_widget, m_widgetStyle );
	492	}
	493
	494	//-----------------------------------------------------------------------------
	495	// wxNotebookEvent
	496	//-----------------------------------------------------------------------------
	497
	498	IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
	499