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"

#include "gdk/gdk.h"
#include "gtk/gtk.h"
#include "wx/gtk/win_gtk.h"
#include "gdk/gdkkeysyms.h"

//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------

extern bool   g_blockEventsOnDrag;

//-----------------------------------------------------------------------------
// 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;
    m_added = FALSE;
  }

  /*
     mark page as "added' to the notebook, return FALSE if the page was
     already added
   */

  bool Add()
  {
    if ( WasAdded() )
      return FALSE;

    m_added = TRUE;
    return TRUE;
  }

  bool WasAdded() const { return m_added; }

  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

private:
  bool m_added;
};

//-----------------------------------------------------------------------------
// "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 );

    if (win->GetAutoLayout()) win->Layout();
}

//-----------------------------------------------------------------------------
// "key_press_event"
//-----------------------------------------------------------------------------

static gint
gtk_notebook_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxNotebook *notebook )
{
    if (g_blockEventsOnDrag) return FALSE;

    if (!notebook->HasVMT()) return FALSE;

    if (gdk_event->keyval != GDK_Down) return FALSE;

    if (notebook != notebook->FindFocus()) return FALSE;

    if (notebook->m_pages.GetCount() == 0) return FALSE;

    wxNode *node = notebook->m_pages.Nth( notebook->GetSelection() );

    if (!node) return FALSE;

    wxNotebookPage *page = (wxNotebookPage*) node->Data();

    // don't let others the key event
    gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );

    page->m_client->SetFocus();

    return TRUE;
}

//-----------------------------------------------------------------------------
// 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 );

    wxASSERT_MSG( page->m_page, "Notebook page creation error" );

    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_acceptsFocus = TRUE;
    m_insertCallback = (wxInsertChildFunction)wxInsertChildInNotebook;

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

    m_widget = gtk_notebook_new();

#ifdef __WXDEBUG__
    debug_focus_in( m_widget, "wxNotebook::m_widget", name );
#endif

    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 );

    gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
      GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)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
{
    // count only the pages which were already added to the notebook for MSW
    // compatibility (and, in fact, this behaviour makes more sense anyhow
    // because only the added pages are shown)

    int n = 0;
    for ( wxNode *node = m_pages.First(); node; node = node->Next() )
    {
        wxNotebookPage *page = (wxNotebookPage*)node->Data();

        if (page->WasAdded()) n++;
    }

    return n;
}

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();
    }

    wxFAIL_MSG( "Notebook page not found!" );

    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;

    if (nb_page->m_text.IsEmpty()) nb_page->m_text = "";

    gtk_label_set(nb_page->m_label, nb_page->m_text);

    return TRUE;
}

bool wxNotebook::SetPageImage( int page, int image )
{
    /* HvdH 28-12-98: now it works, but it's a bit of a kludge */

    wxNotebookPage* nb_page = GetNotebookPage(page);

    if (!nb_page) return FALSE;

    /* Optimization posibility: return immediately if image unchanged.
     * Not enabled because it may break existing (stupid) code that
     * manipulates the imagelist to cycle images */

    /* if (image == nb_page->m_image) return TRUE; */

    /* For different cases:
       1) no image -> no image
       2) image -> no image
       3) no image -> image
       4) image -> image */

    if (image == -1 && nb_page->m_image == -1)
        return TRUE; /* Case 1): Nothing to do. */

    GtkWidget *pixmapwid = (GtkWidget*) NULL;

    if (nb_page->m_image != -1)
    {
        /* Case 2) or 4). There is already an image in the gtkhbox. Let's find it */

        GList *child = gtk_container_children(GTK_CONTAINER(nb_page->m_box));
        while (child)
	{
            if (GTK_IS_PIXMAP(child->data))
	    {
 	        pixmapwid = GTK_WIDGET(child->data);
 	        break;
            }
	    child = child->next;
	}

        /* We should have the pixmap widget now */
        wxASSERT(pixmapwid != NULL);

        if (image == -1)
	{
            /* If there's no new widget, just remove the old from the box */
            gtk_container_remove(GTK_CONTAINER(nb_page->m_box), pixmapwid);
            nb_page->m_image = -1;

            return TRUE; /* Case 2) */
        }
    }

    /* Only cases 3) and 4) left */
    wxASSERT( m_imageList != NULL ); /* Just in case */

    /* Construct the new pixmap */
    const wxBitmap *bmp = m_imageList->GetBitmap(image);
    GdkPixmap *pixmap = bmp->GetPixmap();
    GdkBitmap *mask = (GdkBitmap*) NULL;
    if ( bmp->GetMask() )
    {
        mask = bmp->GetMask()->GetBitmap();
    }

    if (pixmapwid == NULL)
    {
        /* Case 3) No old pixmap. Create a new one and prepend it to the hbox */
        pixmapwid = gtk_pixmap_new (pixmap, mask );

        /* CHECKME: Are these pack flags okay? */
        gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, 3);
        gtk_widget_show(pixmapwid);
    }
    else
    {
        /* Case 4) Simply replace the pixmap */
        gtk_pixmap_set(GTK_PIXMAP(pixmapwid), pixmap, mask);
    }

    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 select, 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!" );

    wxCHECK_MSG( page->Add(), FALSE,
               "Can't add the same page twice to a 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_end( 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 (select) SetSelection( GetPageCount()-1 );

    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, wxNotifyEvent)
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	#include "gdk/gdk.h"
	22	#include "gtk/gtk.h"
	23	#include "wx/gtk/win_gtk.h"
	24	#include "gdk/gdkkeysyms.h"
	25
	26	//-----------------------------------------------------------------------------
	27	// data
	28	//-----------------------------------------------------------------------------
	29
	30	extern bool g_blockEventsOnDrag;
	31
	32	//-----------------------------------------------------------------------------
	33	// wxNotebookPage
	34	//-----------------------------------------------------------------------------
	35
	36	class wxNotebookPage: public wxObject
	37	{
	38	public:
	39	wxNotebookPage()
	40	{
	41	m_id = -1;
	42	m_text = "";
	43	m_image = -1;
	44	m_page = (GtkNotebookPage *) NULL;
	45	m_client = (wxWindow *) NULL;
	46	m_parent = (GtkNotebook *) NULL;
	47	m_box = (GtkWidget *) NULL;
	48	m_added = FALSE;
	49	}
	50
	51	/*
	52	mark page as "added' to the notebook, return FALSE if the page was
	53	already added
	54	*/
	55
	56	bool Add()
	57	{
	58	if ( WasAdded() )
	59	return FALSE;
	60
	61	m_added = TRUE;
	62	return TRUE;
	63	}
	64
	65	bool WasAdded() const { return m_added; }
	66
	67	int m_id;
	68	wxString m_text;
	69	int m_image;
	70	GtkNotebookPage *m_page;
	71	GtkLabel *m_label;
	72	wxWindow *m_client;
	73	GtkNotebook *m_parent;
	74	GtkWidget *m_box; // in which the label and image are packed
	75
	76	private:
	77	bool m_added;
	78	};
	79
	80	//-----------------------------------------------------------------------------
	81	// "switch_page"
	82	//-----------------------------------------------------------------------------
	83
	84	static void gtk_notebook_page_change_callback(GtkNotebook *WXUNUSED(widget),
	85	GtkNotebookPage *WXUNUSED(page),
	86	gint nPage,
	87	gpointer data)
	88	{
	89	wxNotebook notebook = (wxNotebook )data;
	90
	91	int old = notebook->GetSelection();
	92
	93	// TODO: emulate PAGE_CHANGING event
	94
	95	wxNotebookEvent event( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
	96	notebook->GetId(), nPage, old );
	97	event.SetEventObject( notebook );
	98	notebook->GetEventHandler()->ProcessEvent( event );
	99	}
	100
	101	//-----------------------------------------------------------------------------
	102	// "size_allocate"
	103	//-----------------------------------------------------------------------------
	104
	105	static void gtk_page_size_callback( GtkWidget WXUNUSED(widget), GtkAllocation alloc, wxWindow *win )
	106	{
	107	if ((win->m_x == alloc->x) &&
	108	(win->m_y == alloc->y) &&
	109	(win->m_width == alloc->width) &&
	110	(win->m_height == alloc->height))
	111	{
	112	return;
	113	}
	114
	115	win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
	116
	117	if (win->GetAutoLayout()) win->Layout();
	118	}
	119
	120	//-----------------------------------------------------------------------------
	121	// "key_press_event"
	122	//-----------------------------------------------------------------------------
	123
	124	static gint
	125	gtk_notebook_key_press_callback( GtkWidget widget, GdkEventKey gdk_event, wxNotebook *notebook )
	126	{
	127	if (g_blockEventsOnDrag) return FALSE;
	128
	129	if (!notebook->HasVMT()) return FALSE;
	130
	131	if (gdk_event->keyval != GDK_Down) return FALSE;
	132
	133	if (notebook != notebook->FindFocus()) return FALSE;
	134
	135	if (notebook->m_pages.GetCount() == 0) return FALSE;
	136
	137	wxNode *node = notebook->m_pages.Nth( notebook->GetSelection() );
	138
	139	if (!node) return FALSE;
	140
	141	wxNotebookPage page = (wxNotebookPage) node->Data();
	142
	143	// don't let others the key event
	144	gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_press_event" );
	145
	146	page->m_client->SetFocus();
	147
	148	return TRUE;
	149	}
	150
	151	//-----------------------------------------------------------------------------
	152	// InsertChild callback for wxNotebook
	153	//-----------------------------------------------------------------------------
	154
	155	static void wxInsertChildInNotebook( wxNotebook* parent, wxWindow* child )
	156	{
	157	wxNotebookPage *page = new wxNotebookPage();
	158
	159	page->m_id = parent->GetPageCount();
	160
	161	page->m_box = gtk_hbox_new (FALSE, 0);
	162	gtk_container_border_width(GTK_CONTAINER(page->m_box), 2);
	163
	164	GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
	165
	166	page->m_client = child;
	167	gtk_notebook_append_page( notebook, child->m_widget, page->m_box );
	168
	169	page->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
	170
	171	page->m_parent = notebook;
	172
	173	gtk_signal_connect( GTK_OBJECT(child->m_widget), "size_allocate",
	174	GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)child );
	175
	176	wxASSERT_MSG( page->m_page, "Notebook page creation error" );
	177
	178	parent->m_pages.Append( page );
	179	}
	180
	181	//-----------------------------------------------------------------------------
	182	// wxNotebook
	183	//-----------------------------------------------------------------------------
	184
	185	IMPLEMENT_DYNAMIC_CLASS(wxNotebook,wxControl)
	186
	187	void wxNotebook::Init()
	188	{
	189	m_imageList = (wxImageList *) NULL;
	190	m_pages.DeleteContents( TRUE );
	191	m_idHandler = 0;
	192	}
	193
	194	wxNotebook::wxNotebook()
	195	{
	196	Init();
	197	}
	198
	199	wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id,
	200	const wxPoint& pos, const wxSize& size,
	201	long style, const wxString& name )
	202	{
	203	Init();
	204	Create( parent, id, pos, size, style, name );
	205	}
	206
	207	wxNotebook::~wxNotebook()
	208	{
	209	// don't generate change page events any more
	210	if (m_idHandler != 0)
	211	gtk_signal_disconnect(GTK_OBJECT(m_widget), m_idHandler);
	212
	213	DeleteAllPages();
	214	}
	215
	216	bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
	217	const wxPoint& pos, const wxSize& size,
	218	long style, const wxString& name )
	219	{
	220	m_needParent = TRUE;
	221	m_acceptsFocus = TRUE;
	222	m_insertCallback = (wxInsertChildFunction)wxInsertChildInNotebook;
	223
	224	PreCreation( parent, id, pos, size, style, name );
	225
	226	m_widget = gtk_notebook_new();
	227
	228	#ifdef __WXDEBUG__
	229	debug_focus_in( m_widget, "wxNotebook::m_widget", name );
	230	#endif
	231
	232	gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
	233
	234	m_idHandler = gtk_signal_connect (
	235	GTK_OBJECT(m_widget), "switch_page",
	236	GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback),
	237	(gpointer)this );
	238
	239	m_parent->AddChild( this );
	240
	241	(m_parent->m_insertCallback)( m_parent, this );
	242
	243	gtk_signal_connect( GTK_OBJECT(m_widget), "key_press_event",
	244	GTK_SIGNAL_FUNC(gtk_notebook_key_press_callback), (gpointer)this );
	245
	246	PostCreation();
	247
	248	Show( TRUE );
	249
	250	return TRUE;
	251	}
	252
	253	int wxNotebook::GetSelection() const
	254	{
	255	wxCHECK_MSG( m_widget != NULL, -1, "invalid notebook" );
	256
	257	if (m_pages.Number() == 0) return -1;
	258
	259	GtkNotebookPage *g_page = GTK_NOTEBOOK(m_widget)->cur_page;
	260	if (!g_page) return -1;
	261
	262	wxNotebookPage page = (wxNotebookPage ) NULL;
	263
	264	wxNode *node = m_pages.First();
	265	while (node)
	266	{
	267	page = (wxNotebookPage*)node->Data();
	268
	269	if ((page->m_page == g_page) \|\| (page->m_page == (GtkNotebookPage*)NULL))
	270	{
	271	// page->m_page is NULL directly after gtk_notebook_append. gtk emits
	272	// "switch_page" then and we ask for GetSelection() in the handler for
	273	// "switch_page". otherwise m_page should never be NULL. all this
	274	// might also be wrong.
	275	break;
	276	}
	277	node = node->Next();
	278	}
	279
	280	wxCHECK_MSG( node != NULL, -1, "wxNotebook: no selection?" );
	281
	282	return page->m_id;
	283	}
	284
	285	int wxNotebook::GetPageCount() const
	286	{
	287	// count only the pages which were already added to the notebook for MSW
	288	// compatibility (and, in fact, this behaviour makes more sense anyhow
	289	// because only the added pages are shown)
	290
	291	int n = 0;
	292	for ( wxNode *node = m_pages.First(); node; node = node->Next() )
	293	{
	294	wxNotebookPage page = (wxNotebookPage)node->Data();
	295
	296	if (page->WasAdded()) n++;
	297	}
	298
	299	return n;
	300	}
	301
	302	int wxNotebook::GetRowCount() const
	303	{
	304	return 1;
	305	}
	306
	307	wxString wxNotebook::GetPageText( int page ) const
	308	{
	309	wxCHECK_MSG( m_widget != NULL, "", "invalid notebook" );
	310
	311	wxNotebookPage* nb_page = GetNotebookPage(page);
	312	if (nb_page)
	313	return nb_page->m_text;
	314	else
	315	return "";
	316	}
	317
	318	int wxNotebook::GetPageImage( int page ) const
	319	{
	320	wxCHECK_MSG( m_widget != NULL, 0, "invalid notebook" );
	321
	322	wxNotebookPage* nb_page = GetNotebookPage(page);
	323	if (nb_page)
	324	return nb_page->m_image;
	325	else
	326	return 0;
	327	}
	328
	329	wxNotebookPage* wxNotebook::GetNotebookPage(int page) const
	330	{
	331	wxCHECK_MSG( m_widget != NULL, (wxNotebookPage*)NULL, "invalid notebook" );
	332
	333	wxNotebookPage nb_page = (wxNotebookPage ) NULL;
	334
	335	wxNode *node = m_pages.First();
	336	while (node)
	337	{
	338	nb_page = (wxNotebookPage*)node->Data();
	339	if (nb_page->m_id == page)
	340	return nb_page;
	341	node = node->Next();
	342	}
	343
	344	wxFAIL_MSG( "Notebook page not found!" );
	345
	346	return (wxNotebookPage *) NULL;
	347	}
	348
	349	int wxNotebook::SetSelection( int page )
	350	{
	351	wxCHECK_MSG( m_widget != NULL, -1, "invalid notebook" );
	352
	353	int selOld = GetSelection();
	354	wxNotebookPage* nb_page = GetNotebookPage(page);
	355
	356	if (!nb_page) return -1;
	357
	358	int page_num = 0;
	359	GList *child = GTK_NOTEBOOK(m_widget)->children;
	360	while (child)
	361	{
	362	if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
	363	page_num++;
	364	child = child->next;
	365	}
	366
	367	if (!child) return -1;
	368
	369	gtk_notebook_set_page( GTK_NOTEBOOK(m_widget), page_num );
	370
	371	return selOld;
	372	}
	373
	374	void wxNotebook::AdvanceSelection( bool bForward )
	375	{
	376	wxCHECK_RET( m_widget != NULL, "invalid notebook" );
	377
	378	int sel = GetSelection();
	379	int max = GetPageCount();
	380
	381	if (bForward)
	382	SetSelection( sel == max ? 0 : sel + 1 );
	383	else
	384	SetSelection( sel == 0 ? max : sel - 1 );
	385	}
	386
	387	void wxNotebook::SetImageList( wxImageList* imageList )
	388	{
	389	m_imageList = imageList;
	390	}
	391
	392	bool wxNotebook::SetPageText( int page, const wxString &text )
	393	{
	394	wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );
	395
	396	wxNotebookPage* nb_page = GetNotebookPage(page);
	397
	398	if (!nb_page) return FALSE;
	399
	400	nb_page->m_text = text;
	401
	402	if (nb_page->m_text.IsEmpty()) nb_page->m_text = "";
	403
	404	gtk_label_set(nb_page->m_label, nb_page->m_text);
	405
	406	return TRUE;
	407	}
	408
	409	bool wxNotebook::SetPageImage( int page, int image )
	410	{
	411	/* HvdH 28-12-98: now it works, but it's a bit of a kludge */
	412
	413	wxNotebookPage* nb_page = GetNotebookPage(page);
	414
	415	if (!nb_page) return FALSE;
	416
	417	/* Optimization posibility: return immediately if image unchanged.
	418	* Not enabled because it may break existing (stupid) code that
	419	* manipulates the imagelist to cycle images */
	420
	421	/* if (image == nb_page->m_image) return TRUE; */
	422
	423	/* For different cases:
	424	1) no image -> no image
	425	2) image -> no image
	426	3) no image -> image
	427	4) image -> image */
	428
	429	if (image == -1 && nb_page->m_image == -1)
	430	return TRUE; /* Case 1): Nothing to do. */
	431
	432	GtkWidget pixmapwid = (GtkWidget) NULL;
	433
	434	if (nb_page->m_image != -1)
	435	{
	436	/* Case 2) or 4). There is already an image in the gtkhbox. Let's find it */
	437
	438	GList *child = gtk_container_children(GTK_CONTAINER(nb_page->m_box));
	439	while (child)
	440	{
	441	if (GTK_IS_PIXMAP(child->data))
	442	{
	443	pixmapwid = GTK_WIDGET(child->data);
	444	break;
	445	}
	446	child = child->next;
	447	}
	448
	449	/* We should have the pixmap widget now */
	450	wxASSERT(pixmapwid != NULL);
	451
	452	if (image == -1)
	453	{
	454	/* If there's no new widget, just remove the old from the box */
	455	gtk_container_remove(GTK_CONTAINER(nb_page->m_box), pixmapwid);
	456	nb_page->m_image = -1;
	457
	458	return TRUE; /* Case 2) */
	459	}
	460	}
	461
	462	/* Only cases 3) and 4) left */
	463	wxASSERT( m_imageList != NULL ); /* Just in case */
	464
	465	/* Construct the new pixmap */
	466	const wxBitmap *bmp = m_imageList->GetBitmap(image);
	467	GdkPixmap *pixmap = bmp->GetPixmap();
	468	GdkBitmap mask = (GdkBitmap) NULL;
	469	if ( bmp->GetMask() )
	470	{
	471	mask = bmp->GetMask()->GetBitmap();
	472	}
	473
	474	if (pixmapwid == NULL)
	475	{
	476	/* Case 3) No old pixmap. Create a new one and prepend it to the hbox */
	477	pixmapwid = gtk_pixmap_new (pixmap, mask );
	478
	479	/* CHECKME: Are these pack flags okay? */
	480	gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, 3);
	481	gtk_widget_show(pixmapwid);
	482	}
	483	else
	484	{
	485	/* Case 4) Simply replace the pixmap */
	486	gtk_pixmap_set(GTK_PIXMAP(pixmapwid), pixmap, mask);
	487	}
	488
	489	nb_page->m_image = image;
	490
	491	return TRUE;
	492	}
	493
	494	void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
	495	{
	496	wxFAIL_MSG( "wxNotebook::SetPageSize not implemented" );
	497	}
	498
	499	void wxNotebook::SetPadding( const wxSize &WXUNUSED(padding) )
	500	{
	501	wxFAIL_MSG( "wxNotebook::SetPadding not implemented" );
	502	}
	503
	504	bool wxNotebook::DeleteAllPages()
	505	{
	506	wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );
	507
	508	wxNode *page_node = m_pages.First();
	509	while (page_node)
	510	{
	511	wxNotebookPage page = (wxNotebookPage)page_node->Data();
	512
	513	DeletePage( page->m_id );
	514
	515	page_node = m_pages.First();
	516	}
	517
	518	return TRUE;
	519	}
	520
	521	bool wxNotebook::DeletePage( int page )
	522	{
	523	wxNotebookPage* nb_page = GetNotebookPage(page);
	524	if (!nb_page) return FALSE;
	525
	526	int page_num = 0;
	527	GList *child = GTK_NOTEBOOK(m_widget)->children;
	528	while (child)
	529	{
	530	if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
	531	page_num++;
	532	child = child->next;
	533	}
	534
	535	wxCHECK_MSG( child != NULL, FALSE, "illegal notebook index" );
	536
	537	delete nb_page->m_client;
	538
	539	m_pages.DeleteObject( nb_page );
	540
	541	return TRUE;
	542	}
	543
	544	bool wxNotebook::RemovePage( int page )
	545	{
	546	wxNotebookPage* nb_page = GetNotebookPage(page);
	547	if (!nb_page) return FALSE;
	548
	549	int page_num = 0;
	550	GList *child = GTK_NOTEBOOK(m_widget)->children;
	551	while (child)
	552	{
	553	if (nb_page->m_page == (GtkNotebookPage*)child->data) break;
	554	page_num++;
	555	child = child->next;
	556	}
	557
	558	wxCHECK_MSG( child != NULL, FALSE, "illegal notebook index" );
	559
	560	gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page_num );
	561
	562	m_pages.DeleteObject( nb_page );
	563
	564	return TRUE;
	565	}
	566
	567	bool wxNotebook::AddPage(wxWindow* win, const wxString& text,
	568	bool select, int imageId)
	569	{
	570	wxCHECK_MSG( m_widget != NULL, FALSE, "invalid notebook" );
	571
	572	/* we've created the notebook page in AddChild(). Now we just have to set
	573	the caption for the page and set the others parameters. */
	574
	575	wxNotebookPage page = (wxNotebookPage ) NULL;
	576
	577	wxNode *node = m_pages.First();
	578	while (node)
	579	{
	580	page = (wxNotebookPage*)node->Data();
	581	if ( page->m_client == win ) break;
	582	node = node->Next();
	583	}
	584
	585	wxCHECK_MSG( page != NULL, FALSE,
	586	"Can't add a page whose parent is not the notebook!" );
	587
	588	wxCHECK_MSG( page->Add(), FALSE,
	589	"Can't add the same page twice to a notebook." );
	590
	591	if (imageId != -1)
	592	{
	593	wxASSERT( m_imageList != NULL );
	594
	595	const wxBitmap *bmp = m_imageList->GetBitmap(imageId);
	596	GdkPixmap *pixmap = bmp->GetPixmap();
	597	GdkBitmap mask = (GdkBitmap) NULL;
	598	if ( bmp->GetMask() )
	599	{
	600	mask = bmp->GetMask()->GetBitmap();
	601	}
	602
	603	GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask );
	604
	605	gtk_box_pack_start(GTK_BOX(page->m_box), pixmapwid, FALSE, FALSE, 3);
	606
	607	gtk_widget_show(pixmapwid);
	608	}
	609
	610	/* then set the attributes */
	611	page->m_text = text;
	612	if (page->m_text.IsEmpty()) page->m_text = "";
	613	page->m_image = imageId;
	614	page->m_label = (GtkLabel *)gtk_label_new(page->m_text);
	615	gtk_box_pack_end( GTK_BOX(page->m_box), (GtkWidget *)page->m_label, FALSE, FALSE, 3);
	616
	617	/* @@@: what does this do? do we still need it?
	618	gtk_misc_set_alignment(GTK_MISC(page->m_label), 0.0, 0.5); */
	619
	620	gtk_widget_show((GtkWidget *)page->m_label);
	621
	622	if (select) SetSelection( GetPageCount()-1 );
	623
	624	return TRUE;
	625	}
	626
	627	wxWindow *wxNotebook::GetPage( int page ) const
	628	{
	629	wxCHECK_MSG( m_widget != NULL, (wxWindow*) NULL, "invalid notebook" );
	630
	631	wxNotebookPage* nb_page = GetNotebookPage(page);
	632	if (!nb_page)
	633	return (wxWindow *) NULL;
	634	else
	635	return nb_page->m_client;
	636	}
	637
	638	// override these 2 functions to do nothing: everything is done in OnSize
	639	void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
	640	{
	641	// don't set the sizes of the pages - their correct size is not yet known
	642	wxControl::SetConstraintSizes(FALSE);
	643	}
	644
	645	bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
	646	{
	647	return TRUE;
	648	}
	649
	650	void wxNotebook::ApplyWidgetStyle()
	651	{
	652	SetWidgetStyle();
	653	gtk_widget_set_style( m_widget, m_widgetStyle );
	654	}
	655
	656	//-----------------------------------------------------------------------------
	657	// wxNotebookEvent
	658	//-----------------------------------------------------------------------------
	659
	660	IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent)
	661