[wxWidgets.git] / samples / widgets / notebook.cpp

/////////////////////////////////////////////////////////////////////////////
// Program:     wxWindows Widgets Sample
// Name:        notebook.cpp
// Purpose:     Part of the widgets sample showing wxNotebook
// Author:      Vadim Zeitlin
// Created:     06.04.01
// Id:          $Id$
// Copyright:   (c) 2001 Vadim Zeitlin
// License:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// for compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// for all others, include the necessary headers
#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/log.h"

    #include "wx/button.h"
    #include "wx/checkbox.h"
    #include "wx/combobox.h"
    #include "wx/radiobox.h"
    #include "wx/statbox.h"
    #include "wx/textctrl.h"

    #include "wx/dynarray.h"
#endif

#include "wx/sizer.h"
#include "wx/notebook.h"
#include "wx/artprov.h"

#include "widgets.h"
#if 1
#include "icons/notebook.xpm"

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// control ids
enum
{
    NotebookPage_Reset = 100,
    NotebookPage_SelectPage,
    NotebookPage_AddPage,
    NotebookPage_InsertPage,
    NotebookPage_RemovePage,
    NotebookPage_DeleteAll,
    NotebookPage_InsertText,
    NotebookPage_RemoveText,
    NotebookPage_SelectText,
    NotebookPage_NumPagesText,
    NotebookPage_CurSelectText,
    NotebookPage_Notebook
};

// notebook orientations
enum Orient
{
    Orient_Top,
    Orient_Bottom,
    Orient_Left,
    Orient_Right,
    Orient_Max
};

// old versions of wxWindows don't define this style
#ifndef wxNB_TOP
    #define wxNB_TOP (0)
#endif

// ----------------------------------------------------------------------------
// NotebookWidgetsPage
// ----------------------------------------------------------------------------

class NotebookWidgetsPage : public WidgetsPage
{
public:
    NotebookWidgetsPage(wxNotebook *notebook, wxImageList *imaglist);
    virtual ~NotebookWidgetsPage();

protected:
    // event handlers
    void OnPageChanging(wxNotebookEvent& event);
    void OnPageChanged(wxNotebookEvent& event);

    void OnButtonReset(wxCommandEvent& event);
    void OnButtonDeleteAll(wxCommandEvent& event);
    void OnButtonSelectPage(wxCommandEvent& event);
    void OnButtonAddPage(wxCommandEvent& event);
    void OnButtonInsertPage(wxCommandEvent& event);
    void OnButtonRemovePage(wxCommandEvent& event);

    void OnCheckOrRadioBox(wxCommandEvent& event);

    void OnUpdateUINumPagesText(wxUpdateUIEvent& event);
    void OnUpdateUICurSelectText(wxUpdateUIEvent& event);

    void OnUpdateUISelectButton(wxUpdateUIEvent& event);
    void OnUpdateUIInsertButton(wxUpdateUIEvent& event);
    void OnUpdateUIRemoveButton(wxUpdateUIEvent& event);

    void OnUpdateUIResetButton(wxUpdateUIEvent& event);

    // reset the wxNotebook parameters
    void Reset();

    // (re)create the wxNotebook
    void CreateNotebook();

    // create or destroy the image list
    void CreateImageList();

    // create a new page
    wxWindow *CreateNewPage();

    // get the image index for the new page
    int GetIconIndex() const;

    // get the numeric value of text ctrl
    int GetTextValue(wxTextCtrl *text) const;

    // is the value in range?
    bool IsValidValue(int val) const
        { return (val >= 0) && (val < (int) m_notebook->GetPageCount()); }

    // the controls
    // ------------

    // the check/radio boxes for styles
    wxCheckBox *m_chkImages;
    wxRadioBox *m_radioOrient;

    // the text controls containing input for various commands
    wxTextCtrl *m_textInsert,
               *m_textRemove,
               *m_textSelect;

    // the notebook itself and the sizer it is in
    wxNotebook *m_notebook;
    wxSizer *m_sizerNotebook;

    // thei mage list for our notebook
    wxImageList *m_imageList;

private:
    DECLARE_EVENT_TABLE()
    DECLARE_WIDGETS_PAGE(NotebookWidgetsPage)
};

// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(NotebookWidgetsPage, WidgetsPage)
    EVT_BUTTON(NotebookPage_Reset, NotebookWidgetsPage::OnButtonReset)
    EVT_BUTTON(NotebookPage_SelectPage, NotebookWidgetsPage::OnButtonSelectPage)
    EVT_BUTTON(NotebookPage_AddPage, NotebookWidgetsPage::OnButtonAddPage)
    EVT_BUTTON(NotebookPage_InsertPage, NotebookWidgetsPage::OnButtonInsertPage)
    EVT_BUTTON(NotebookPage_RemovePage, NotebookWidgetsPage::OnButtonRemovePage)
    EVT_BUTTON(NotebookPage_DeleteAll, NotebookWidgetsPage::OnButtonDeleteAll)

    EVT_UPDATE_UI(NotebookPage_NumPagesText, NotebookWidgetsPage::OnUpdateUINumPagesText)
    EVT_UPDATE_UI(NotebookPage_CurSelectText, NotebookWidgetsPage::OnUpdateUICurSelectText)

    EVT_UPDATE_UI(NotebookPage_SelectPage, NotebookWidgetsPage::OnUpdateUISelectButton)
    EVT_UPDATE_UI(NotebookPage_InsertPage, NotebookWidgetsPage::OnUpdateUIInsertButton)
    EVT_UPDATE_UI(NotebookPage_RemovePage, NotebookWidgetsPage::OnUpdateUIRemoveButton)

    EVT_NOTEBOOK_PAGE_CHANGING(-1, NotebookWidgetsPage::OnPageChanging)
    EVT_NOTEBOOK_PAGE_CHANGED(-1, NotebookWidgetsPage::OnPageChanged)

    EVT_CHECKBOX(-1, NotebookWidgetsPage::OnCheckOrRadioBox)
    EVT_RADIOBOX(-1, NotebookWidgetsPage::OnCheckOrRadioBox)
END_EVENT_TABLE()

// ============================================================================
// implementation
// ============================================================================

IMPLEMENT_WIDGETS_PAGE(NotebookWidgetsPage, _T("Notebook"));

NotebookWidgetsPage::NotebookWidgetsPage(wxNotebook *notebook,
                                         wxImageList *imaglist)
                  : WidgetsPage(notebook)
{
    imaglist->Add(wxBitmap(notebook_xpm));

    // init everything
    m_chkImages = NULL;
    m_imageList = NULL;

    m_notebook = (wxNotebook *)NULL;
    m_sizerNotebook = (wxSizer *)NULL;

    wxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);

    // left pane
    wxStaticBox *box = new wxStaticBox(this, -1, _T("&Set style"));

    // must be in sync with Orient enum
    wxString orientations[] =
    {
        _T("&top"),
        _T("&bottom"),
        _T("&left"),
        _T("&right"),
    };

    wxASSERT_MSG( WXSIZEOF(orientations) == Orient_Max,
                  _T("forgot to update something") );

    m_chkImages = new wxCheckBox(this, -1, _T("Show &images"));
    m_radioOrient = new wxRadioBox(this, -1, _T("&Tab orientation"),
                                   wxDefaultPosition, wxDefaultSize,
                                   WXSIZEOF(orientations), orientations,
                                   1, wxRA_SPECIFY_COLS);

    wxSizer *sizerLeft = new wxStaticBoxSizer(box, wxVERTICAL);

    sizerLeft->Add(m_chkImages, 0, wxALL, 5);
    sizerLeft->Add(5, 5, 0, wxGROW | wxALL, 5); // spacer
    sizerLeft->Add(m_radioOrient, 0, wxALL, 5);

    wxButton *btn = new wxButton(this, NotebookPage_Reset, _T("&Reset"));
    sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL | wxALL, 15);

    // middle pane
    wxStaticBox *box2 = new wxStaticBox(this, -1, _T("&Contents"));
    wxSizer *sizerMiddle = new wxStaticBoxSizer(box2, wxVERTICAL);

    wxTextCtrl *text;
    wxSizer *sizerRow = CreateSizerWithTextAndLabel(_T("Number of pages: "),
                                                    NotebookPage_NumPagesText,
                                                    &text);
    text->SetEditable(FALSE);
    sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);

    sizerRow = CreateSizerWithTextAndLabel(_T("Current selection: "),
                                           NotebookPage_CurSelectText,
                                           &text);
    text->SetEditable(FALSE);
    sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);

    sizerRow = CreateSizerWithTextAndButton(NotebookPage_SelectPage,
                                            _T("&Select page"),
                                            NotebookPage_SelectText,
                                            &m_textSelect);
    sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);

    btn = new wxButton(this, NotebookPage_AddPage, _T("&Add page"));
    sizerMiddle->Add(btn, 0, wxALL | wxGROW, 5);

    sizerRow = CreateSizerWithTextAndButton(NotebookPage_InsertPage,
                                            _T("&Insert page at"),
                                            NotebookPage_InsertText,
                                            &m_textInsert);
    sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);

    sizerRow = CreateSizerWithTextAndButton(NotebookPage_RemovePage,
                                            _T("&Remove page"),
                                            NotebookPage_RemoveText,
                                            &m_textRemove);
    sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);

    btn = new wxButton(this, NotebookPage_DeleteAll, _T("&Delete All"));
    sizerMiddle->Add(btn, 0, wxALL | wxGROW, 5);

    // right pane
    wxSizer *sizerRight = new wxBoxSizer(wxHORIZONTAL);
    m_notebook = new wxNotebook(this, NotebookPage_Notebook);
    sizerRight->Add(m_notebook, 1, wxGROW | wxALL, 5);
    sizerRight->SetMinSize(150, 0);
    m_sizerNotebook = sizerRight; // save it to modify it later

    // the 3 panes panes compose the window
    sizerTop->Add(sizerLeft, 0, wxGROW | (wxALL & ~wxLEFT), 10);
    sizerTop->Add(sizerMiddle, 0, wxGROW | wxALL, 10);
    sizerTop->Add(sizerRight, 1, wxGROW | (wxALL & ~wxRIGHT), 10);

    // final initializations
    Reset();
    CreateImageList();

    SetAutoLayout(TRUE);
    SetSizer(sizerTop);

    sizerTop->Fit(this);
}

NotebookWidgetsPage::~NotebookWidgetsPage()
{
    delete m_imageList;
}

// ----------------------------------------------------------------------------
// operations
// ----------------------------------------------------------------------------

void NotebookWidgetsPage::Reset()
{
    m_chkImages->SetValue(TRUE);
    m_radioOrient->SetSelection(Orient_Top);
}

void NotebookWidgetsPage::CreateImageList()
{
    if ( m_chkImages->GetValue() )
    {
        if ( !m_imageList )
        {
            // create a dummy image list with a few icons
            m_imageList = new wxImageList(32, 32);
            wxSize size(32, 32);
            m_imageList->Add(wxArtProvider::GetIcon(wxART_INFORMATION, wxART_OTHER, size));
            m_imageList->Add(wxArtProvider::GetIcon(wxART_QUESTION, wxART_OTHER, size));
            m_imageList->Add(wxArtProvider::GetIcon(wxART_WARNING, wxART_OTHER, size));
            m_imageList->Add(wxArtProvider::GetIcon(wxART_ERROR, wxART_OTHER, size));
        }

        m_notebook->SetImageList(m_imageList);
    }
    else // no images
    {
        if ( m_imageList )
        {
            delete m_imageList;
            m_imageList = NULL;
        }
    }

    // because of the bug in wxMSW we can't use SetImageList(NULL) - although
    // it would be logical if this removed the image list from notebook, under
    // MSW it crashes instead
}

void NotebookWidgetsPage::CreateNotebook()
{
    int flags;
    switch ( m_radioOrient->GetSelection() )
    {
        default:
            wxFAIL_MSG( _T("unknown notebok orientation") );
            // fall through

        case Orient_Top:
            flags = wxNB_TOP;
            break;

        case Orient_Bottom:
            flags = wxNB_BOTTOM;
            break;

        case Orient_Left:
            flags = wxNB_LEFT;
            break;

        case Orient_Right:
            flags = wxNB_RIGHT;
            break;
    }

    wxNotebook *notebook = m_notebook;

    m_notebook = new wxNotebook(this, NotebookPage_Notebook,
                                wxDefaultPosition, wxDefaultSize,
                                flags);

    CreateImageList();

    if ( notebook )
    {
        const int sel = notebook->GetSelection();

        const int count = notebook->GetPageCount();

        // recreate the pages
        for ( int n = 0; n < count; n++ )
        {
            m_notebook->AddPage(CreateNewPage(),
                                notebook->GetPageText(n),
                                FALSE,
                                notebook->GetPageImage(n));
        }

        m_sizerNotebook->Detach( notebook );
        delete notebook;

        // restore selection
        if ( sel != -1 )
        {
            m_notebook->SetSelection(sel);
        }
    }

    m_sizerNotebook->Add(m_notebook, 1, wxGROW | wxALL, 5);
    m_sizerNotebook->Layout();
}

// ----------------------------------------------------------------------------
// helpers
// ----------------------------------------------------------------------------

int NotebookWidgetsPage::GetTextValue(wxTextCtrl *text) const
{
    long pos;
    if ( !text->GetValue().ToLong(&pos) )
        pos = -1;

    return (int)pos;
}

int NotebookWidgetsPage::GetIconIndex() const
{
    if ( m_imageList )
    {
       int nImages = m_imageList->GetImageCount();
       if ( nImages > 0 )
       {
           return m_notebook->GetPageCount() % nImages;
       }
    }

    return -1;
}

wxWindow *NotebookWidgetsPage::CreateNewPage()
{
    return new wxTextCtrl(m_notebook, -1, _T("I'm a notebook page"));
}

// ----------------------------------------------------------------------------
// event handlers
// ----------------------------------------------------------------------------

void NotebookWidgetsPage::OnButtonReset(wxCommandEvent& WXUNUSED(event))
{
    Reset();

    CreateNotebook();
}

void NotebookWidgetsPage::OnButtonDeleteAll(wxCommandEvent& WXUNUSED(event))
{
    m_notebook->DeleteAllPages();
}

void NotebookWidgetsPage::OnButtonSelectPage(wxCommandEvent& WXUNUSED(event))
{
    int pos = GetTextValue(m_textSelect);
    wxCHECK_RET( IsValidValue(pos), _T("button should be disabled") );

    m_notebook->SetSelection(pos);
}

void NotebookWidgetsPage::OnButtonAddPage(wxCommandEvent& WXUNUSED(event))
{
    m_notebook->AddPage(CreateNewPage(), _T("Added page"), FALSE,
                        GetIconIndex());
}

void NotebookWidgetsPage::OnButtonInsertPage(wxCommandEvent& WXUNUSED(event))
{
    int pos = GetTextValue(m_textInsert);
    wxCHECK_RET( IsValidValue(pos), _T("button should be disabled") );

    m_notebook->InsertPage(pos, CreateNewPage(), _T("Inserted page"), FALSE,
                           GetIconIndex());
}

void NotebookWidgetsPage::OnButtonRemovePage(wxCommandEvent& WXUNUSED(event))
{
    int pos = GetTextValue(m_textRemove);
    wxCHECK_RET( IsValidValue(pos), _T("button should be disabled") );

    m_notebook->DeletePage(pos);
}

void NotebookWidgetsPage::OnUpdateUISelectButton(wxUpdateUIEvent& event)
{
    event.Enable( IsValidValue(GetTextValue(m_textSelect)) );
}

void NotebookWidgetsPage::OnUpdateUIInsertButton(wxUpdateUIEvent& event)
{
    event.Enable( IsValidValue(GetTextValue(m_textInsert)) );
}

void NotebookWidgetsPage::OnUpdateUIRemoveButton(wxUpdateUIEvent& event)
{
    event.Enable( IsValidValue(GetTextValue(m_textRemove)) );
}

void NotebookWidgetsPage::OnUpdateUIResetButton(wxUpdateUIEvent& event)
{
    event.Enable( !m_chkImages->GetValue() ||
                  m_radioOrient->GetSelection() != wxNB_TOP );
}

void NotebookWidgetsPage::OnUpdateUINumPagesText(wxUpdateUIEvent& event)
{
    event.SetText( wxString::Format(_T("%d"), m_notebook->GetPageCount()) );
}

void NotebookWidgetsPage::OnUpdateUICurSelectText(wxUpdateUIEvent& event)
{
    event.SetText( wxString::Format(_T("%d"), m_notebook->GetSelection()) );
}

void NotebookWidgetsPage::OnCheckOrRadioBox(wxCommandEvent& WXUNUSED(event))
{
    CreateNotebook();
}

void NotebookWidgetsPage::OnPageChanging(wxNotebookEvent& event)
{
    wxLogMessage(_T("Notebook page changing from %d to %d (currently %d)."),
                 event.GetOldSelection(),
                 event.GetSelection(),
                 m_notebook->GetSelection());

    event.Skip();
}

void NotebookWidgetsPage::OnPageChanged(wxNotebookEvent& event)
{
    wxLogMessage(_T("Notebook page changed from %d to %d (currently %d)."),
                 event.GetOldSelection(),
                 event.GetSelection(),
                 m_notebook->GetSelection());

    event.Skip();
}

#endif
Commit	Line	Data
32b8ec41 VZ	1	/////////////////////////////////////////////////////////////////////////////
	2	// Program: wxWindows Widgets Sample
	3	// Name: notebook.cpp
	4	// Purpose: Part of the widgets sample showing wxNotebook
	5	// Author: Vadim Zeitlin
	6	// Created: 06.04.01
	7	// Id: $Id$
	8	// Copyright: (c) 2001 Vadim Zeitlin
	9	// License: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// for compilers that support precompilation, includes "wx/wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	// for all others, include the necessary headers
	28	#ifndef WX_PRECOMP
	29	#include "wx/app.h"
	30	#include "wx/log.h"
	31
	32	#include "wx/button.h"
	33	#include "wx/checkbox.h"
	34	#include "wx/combobox.h"
	35	#include "wx/radiobox.h"
	36	#include "wx/statbox.h"
	37	#include "wx/textctrl.h"
	38
	39	#include "wx/dynarray.h"
	40	#endif
	41
	42	#include "wx/sizer.h"
	43	#include "wx/notebook.h"
389d906b	44	#include "wx/artprov.h"
32b8ec41 VZ	45
32b8ec41 VZ	46	#include "widgets.h"
7b127900	47	#if 1
32b8ec41 VZ	48	#include "icons/notebook.xpm"
	49
	50	// ----------------------------------------------------------------------------
	51	// constants
	52	// ----------------------------------------------------------------------------
	53
	54	// control ids
	55	enum
	56	{
	57	NotebookPage_Reset = 100,
	58	NotebookPage_SelectPage,
	59	NotebookPage_AddPage,
	60	NotebookPage_InsertPage,
	61	NotebookPage_RemovePage,
	62	NotebookPage_DeleteAll,
	63	NotebookPage_InsertText,
	64	NotebookPage_RemoveText,
	65	NotebookPage_SelectText,
	66	NotebookPage_NumPagesText,
	67	NotebookPage_CurSelectText,
	68	NotebookPage_Notebook
	69	};
	70
	71	// notebook orientations
	72	enum Orient
	73	{
	74	Orient_Top,
	75	Orient_Bottom,
	76	Orient_Left,
	77	Orient_Right,
	78	Orient_Max
	79	};
	80
	81	// old versions of wxWindows don't define this style
	82	#ifndef wxNB_TOP
	83	#define wxNB_TOP (0)
	84	#endif
	85
	86	// ----------------------------------------------------------------------------
	87	// NotebookWidgetsPage
	88	// ----------------------------------------------------------------------------
	89
	90	class NotebookWidgetsPage : public WidgetsPage
	91	{
	92	public:
	93	NotebookWidgetsPage(wxNotebook notebook, wxImageList imaglist);
	94	virtual ~NotebookWidgetsPage();
	95
	96	protected:
	97	// event handlers
	98	void OnPageChanging(wxNotebookEvent& event);
	99	void OnPageChanged(wxNotebookEvent& event);
	100
	101	void OnButtonReset(wxCommandEvent& event);
	102	void OnButtonDeleteAll(wxCommandEvent& event);
	103	void OnButtonSelectPage(wxCommandEvent& event);
	104	void OnButtonAddPage(wxCommandEvent& event);
	105	void OnButtonInsertPage(wxCommandEvent& event);
	106	void OnButtonRemovePage(wxCommandEvent& event);
	107
	108	void OnCheckOrRadioBox(wxCommandEvent& event);
	109
	110	void OnUpdateUINumPagesText(wxUpdateUIEvent& event);
	111	void OnUpdateUICurSelectText(wxUpdateUIEvent& event);
112
113	void OnUpdateUISelectButton(wxUpdateUIEvent& event);
114	void OnUpdateUIInsertButton(wxUpdateUIEvent& event);
115	void OnUpdateUIRemoveButton(wxUpdateUIEvent& event);
116
117	void OnUpdateUIResetButton(wxUpdateUIEvent& event);
118
119	// reset the wxNotebook parameters
120	void Reset();
121
122	// (re)create the wxNotebook
123	void CreateNotebook();
124
125	// create or destroy the image list
126	void CreateImageList();
127
128	// create a new page
129	wxWindow *CreateNewPage();
130
131	// get the image index for the new page
132	int GetIconIndex() const;
133
134	// get the numeric value of text ctrl
135	int GetTextValue(wxTextCtrl *text) const;
136
657c8818 JS	137	// is the value in range?
657c8818 JS	138	bool IsValidValue(int val) const
c3ced9ec	139	{ return (val >= 0) && (val < (int) m_notebook->GetPageCount()); }
657c8818	140
32b8ec41 VZ	141	// the controls
	142	// ------------
	143
	144	// the check/radio boxes for styles
	145	wxCheckBox *m_chkImages;
	146	wxRadioBox *m_radioOrient;
	147
	148	// the text controls containing input for various commands
	149	wxTextCtrl *m_textInsert,
	150	*m_textRemove,
	151	*m_textSelect;
	152
	153	// the notebook itself and the sizer it is in
	154	wxNotebook *m_notebook;
	155	wxSizer *m_sizerNotebook;
	156
	157	// thei mage list for our notebook
	158	wxImageList *m_imageList;
	159
	160	private:
5e173f35 GD	161	DECLARE_EVENT_TABLE()
5e173f35 GD	162	DECLARE_WIDGETS_PAGE(NotebookWidgetsPage)
32b8ec41 VZ	163	};
	164
	165	// ----------------------------------------------------------------------------
	166	// event tables
	167	// ----------------------------------------------------------------------------
	168
	169	BEGIN_EVENT_TABLE(NotebookWidgetsPage, WidgetsPage)
	170	EVT_BUTTON(NotebookPage_Reset, NotebookWidgetsPage::OnButtonReset)
	171	EVT_BUTTON(NotebookPage_SelectPage, NotebookWidgetsPage::OnButtonSelectPage)
	172	EVT_BUTTON(NotebookPage_AddPage, NotebookWidgetsPage::OnButtonAddPage)
	173	EVT_BUTTON(NotebookPage_InsertPage, NotebookWidgetsPage::OnButtonInsertPage)
	174	EVT_BUTTON(NotebookPage_RemovePage, NotebookWidgetsPage::OnButtonRemovePage)
	175	EVT_BUTTON(NotebookPage_DeleteAll, NotebookWidgetsPage::OnButtonDeleteAll)
	176
	177	EVT_UPDATE_UI(NotebookPage_NumPagesText, NotebookWidgetsPage::OnUpdateUINumPagesText)
	178	EVT_UPDATE_UI(NotebookPage_CurSelectText, NotebookWidgetsPage::OnUpdateUICurSelectText)
	179
	180	EVT_UPDATE_UI(NotebookPage_SelectPage, NotebookWidgetsPage::OnUpdateUISelectButton)
	181	EVT_UPDATE_UI(NotebookPage_InsertPage, NotebookWidgetsPage::OnUpdateUIInsertButton)
	182	EVT_UPDATE_UI(NotebookPage_RemovePage, NotebookWidgetsPage::OnUpdateUIRemoveButton)
	183
	184	EVT_NOTEBOOK_PAGE_CHANGING(-1, NotebookWidgetsPage::OnPageChanging)
	185	EVT_NOTEBOOK_PAGE_CHANGED(-1, NotebookWidgetsPage::OnPageChanged)
	186
	187	EVT_CHECKBOX(-1, NotebookWidgetsPage::OnCheckOrRadioBox)
	188	EVT_RADIOBOX(-1, NotebookWidgetsPage::OnCheckOrRadioBox)
	189	END_EVENT_TABLE()
	190
	191	// ============================================================================
	192	// implementation
	193	// ============================================================================
	194
	195	IMPLEMENT_WIDGETS_PAGE(NotebookWidgetsPage, _T("Notebook"));
	196
	197	NotebookWidgetsPage::NotebookWidgetsPage(wxNotebook *notebook,
	198	wxImageList *imaglist)
	199	: WidgetsPage(notebook)
	200	{
	201	imaglist->Add(wxBitmap(notebook_xpm));
	202
	203	// init everything
	204	m_chkImages = NULL;
	205	m_imageList = NULL;
	206
	207	m_notebook = (wxNotebook *)NULL;
	208	m_sizerNotebook = (wxSizer *)NULL;
	209
	210	wxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);
	211
	212	// left pane
	213	wxStaticBox *box = new wxStaticBox(this, -1, _T("&Set style"));
	214
	215	// must be in sync with Orient enum
	216	wxString orientations[] =
	217	{
	218	_T("&top"),
	219	_T("&bottom"),
	220	_T("&left"),
	221	_T("&right"),
	222	};
	223
	224	wxASSERT_MSG( WXSIZEOF(orientations) == Orient_Max,
	225	_T("forgot to update something") );
	226
227	m_chkImages = new wxCheckBox(this, -1, _T("Show &images"));
228	m_radioOrient = new wxRadioBox(this, -1, _T("&Tab orientation"),
229	wxDefaultPosition, wxDefaultSize,
230	WXSIZEOF(orientations), orientations,
231	1, wxRA_SPECIFY_COLS);
232
233	wxSizer *sizerLeft = new wxStaticBoxSizer(box, wxVERTICAL);
234
235	sizerLeft->Add(m_chkImages, 0, wxALL, 5);
236	sizerLeft->Add(5, 5, 0, wxGROW \| wxALL, 5); // spacer
237	sizerLeft->Add(m_radioOrient, 0, wxALL, 5);
238
239	wxButton *btn = new wxButton(this, NotebookPage_Reset, _T("&Reset"));
240	sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL \| wxALL, 15);
241
242	// middle pane
243	wxStaticBox *box2 = new wxStaticBox(this, -1, _T("&Contents"));
244	wxSizer *sizerMiddle = new wxStaticBoxSizer(box2, wxVERTICAL);
245
246	wxTextCtrl *text;
247	wxSizer *sizerRow = CreateSizerWithTextAndLabel(_T("Number of pages: "),
248	NotebookPage_NumPagesText,
249	&text);
250	text->SetEditable(FALSE);
251	sizerMiddle->Add(sizerRow, 0, wxALL \| wxGROW, 5);
252
253	sizerRow = CreateSizerWithTextAndLabel(_T("Current selection: "),
254	NotebookPage_CurSelectText,
255	&text);
256	text->SetEditable(FALSE);
257	sizerMiddle->Add(sizerRow, 0, wxALL \| wxGROW, 5);
258
259	sizerRow = CreateSizerWithTextAndButton(NotebookPage_SelectPage,
260	_T("&Select page"),
261	NotebookPage_SelectText,
262	&m_textSelect);
263	sizerMiddle->Add(sizerRow, 0, wxALL \| wxGROW, 5);
264
265	btn = new wxButton(this, NotebookPage_AddPage, _T("&Add page"));
266	sizerMiddle->Add(btn, 0, wxALL \| wxGROW, 5);
267
268	sizerRow = CreateSizerWithTextAndButton(NotebookPage_InsertPage,
269	_T("&Insert page at"),
270	NotebookPage_InsertText,
271	&m_textInsert);
272	sizerMiddle->Add(sizerRow, 0, wxALL \| wxGROW, 5);
273
274	sizerRow = CreateSizerWithTextAndButton(NotebookPage_RemovePage,
275	_T("&Remove page"),
276	NotebookPage_RemoveText,
277	&m_textRemove);
278	sizerMiddle->Add(sizerRow, 0, wxALL \| wxGROW, 5);
279
280	btn = new wxButton(this, NotebookPage_DeleteAll, _T("&Delete All"));
281	sizerMiddle->Add(btn, 0, wxALL \| wxGROW, 5);
282
283	// right pane
284	wxSizer *sizerRight = new wxBoxSizer(wxHORIZONTAL);
285	m_notebook = new wxNotebook(this, NotebookPage_Notebook);
286	sizerRight->Add(m_notebook, 1, wxGROW \| wxALL, 5);
7b127900	287	sizerRight->SetMinSize(150, 0);
32b8ec41 VZ	288	m_sizerNotebook = sizerRight; // save it to modify it later
	289
	290	// the 3 panes panes compose the window
	291	sizerTop->Add(sizerLeft, 0, wxGROW \| (wxALL & ~wxLEFT), 10);
	292	sizerTop->Add(sizerMiddle, 0, wxGROW \| wxALL, 10);
	293	sizerTop->Add(sizerRight, 1, wxGROW \| (wxALL & ~wxRIGHT), 10);
	294
	295	// final initializations
	296	Reset();
	297	CreateImageList();
	298
	299	SetAutoLayout(TRUE);
	300	SetSizer(sizerTop);
	301
	302	sizerTop->Fit(this);
	303	}
	304
	305	NotebookWidgetsPage::~NotebookWidgetsPage()
	306	{
	307	delete m_imageList;
	308	}
	309
	310	// ----------------------------------------------------------------------------
	311	// operations
	312	// ----------------------------------------------------------------------------
	313
	314	void NotebookWidgetsPage::Reset()
	315	{
	316	m_chkImages->SetValue(TRUE);
	317	m_radioOrient->SetSelection(Orient_Top);
	318	}
	319
	320	void NotebookWidgetsPage::CreateImageList()
	321	{
	322	if ( m_chkImages->GetValue() )
	323	{
	324	if ( !m_imageList )
	325	{
	326	// create a dummy image list with a few icons
	327	m_imageList = new wxImageList(32, 32);
389d906b VS	328	wxSize size(32, 32);
	329	m_imageList->Add(wxArtProvider::GetIcon(wxART_INFORMATION, wxART_OTHER, size));
	330	m_imageList->Add(wxArtProvider::GetIcon(wxART_QUESTION, wxART_OTHER, size));
	331	m_imageList->Add(wxArtProvider::GetIcon(wxART_WARNING, wxART_OTHER, size));
	332	m_imageList->Add(wxArtProvider::GetIcon(wxART_ERROR, wxART_OTHER, size));
32b8ec41 VZ	333	}
	334
	335	m_notebook->SetImageList(m_imageList);
	336	}
	337	else // no images
	338	{
	339	if ( m_imageList )
	340	{
	341	delete m_imageList;
	342	m_imageList = NULL;
	343	}
	344	}
	345
	346	// because of the bug in wxMSW we can't use SetImageList(NULL) - although
	347	// it would be logical if this removed the image list from notebook, under
	348	// MSW it crashes instead
	349	}
	350
	351	void NotebookWidgetsPage::CreateNotebook()
	352	{
	353	int flags;
	354	switch ( m_radioOrient->GetSelection() )
	355	{
	356	default:
	357	wxFAIL_MSG( _T("unknown notebok orientation") );
	358	// fall through
	359
	360	case Orient_Top:
	361	flags = wxNB_TOP;
	362	break;
	363
	364	case Orient_Bottom:
	365	flags = wxNB_BOTTOM;
	366	break;
	367
	368	case Orient_Left:
	369	flags = wxNB_LEFT;
	370	break;
	371
	372	case Orient_Right:
	373	flags = wxNB_RIGHT;
	374	break;
	375	}
	376
	377	wxNotebook *notebook = m_notebook;
	378
	379	m_notebook = new wxNotebook(this, NotebookPage_Notebook,
	380	wxDefaultPosition, wxDefaultSize,
	381	flags);
	382
	383	CreateImageList();
	384
	385	if ( notebook )
	386	{
2b5f62a0	387	const int sel = notebook->GetSelection();
32b8ec41	388
2b5f62a0 VZ	389	const int count = notebook->GetPageCount();
	390
	391	// recreate the pages
32b8ec41 VZ	392	for ( int n = 0; n < count; n++ )
32b8ec41 VZ	393	{
2b5f62a0 VZ	394	m_notebook->AddPage(CreateNewPage(),
	395	notebook->GetPageText(n),
	396	FALSE,
	397	notebook->GetPageImage(n));
32b8ec41 VZ	398	}
32b8ec41 VZ	399
12a3f227	400	m_sizerNotebook->Detach( notebook );
32b8ec41 VZ	401	delete notebook;
	402
	403	// restore selection
	404	if ( sel != -1 )
	405	{
	406	m_notebook->SetSelection(sel);
	407	}
	408	}
	409
	410	m_sizerNotebook->Add(m_notebook, 1, wxGROW \| wxALL, 5);
	411	m_sizerNotebook->Layout();
	412	}
	413
	414	// ----------------------------------------------------------------------------
	415	// helpers
	416	// ----------------------------------------------------------------------------
	417
	418	int NotebookWidgetsPage::GetTextValue(wxTextCtrl *text) const
	419	{
	420	long pos;
	421	if ( !text->GetValue().ToLong(&pos) )
	422	pos = -1;
	423
	424	return (int)pos;
	425	}
	426
	427	int NotebookWidgetsPage::GetIconIndex() const
	428	{
	429	if ( m_imageList )
	430	{
	431	int nImages = m_imageList->GetImageCount();
	432	if ( nImages > 0 )
	433	{
	434	return m_notebook->GetPageCount() % nImages;
	435	}
	436	}
	437
	438	return -1;
	439	}
	440
	441	wxWindow *NotebookWidgetsPage::CreateNewPage()
	442	{
	443	return new wxTextCtrl(m_notebook, -1, _T("I'm a notebook page"));
	444	}
	445
	446	// ----------------------------------------------------------------------------
	447	// event handlers
	448	// ----------------------------------------------------------------------------
	449
	450	void NotebookWidgetsPage::OnButtonReset(wxCommandEvent& WXUNUSED(event))
	451	{
	452	Reset();
	453
	454	CreateNotebook();
	455	}
	456
	457	void NotebookWidgetsPage::OnButtonDeleteAll(wxCommandEvent& WXUNUSED(event))
	458	{
	459	m_notebook->DeleteAllPages();
	460	}
	461
c02e5a31	462	void NotebookWidgetsPage::OnButtonSelectPage(wxCommandEvent& WXUNUSED(event))
32b8ec41 VZ	463	{
32b8ec41 VZ	464	int pos = GetTextValue(m_textSelect);
657c8818	465	wxCHECK_RET( IsValidValue(pos), _T("button should be disabled") );
32b8ec41 VZ	466
	467	m_notebook->SetSelection(pos);
	468	}
	469
	470	void NotebookWidgetsPage::OnButtonAddPage(wxCommandEvent& WXUNUSED(event))
	471	{
	472	m_notebook->AddPage(CreateNewPage(), _T("Added page"), FALSE,
	473	GetIconIndex());
	474	}
	475
	476	void NotebookWidgetsPage::OnButtonInsertPage(wxCommandEvent& WXUNUSED(event))
	477	{
	478	int pos = GetTextValue(m_textInsert);
657c8818	479	wxCHECK_RET( IsValidValue(pos), _T("button should be disabled") );
32b8ec41 VZ	480
	481	m_notebook->InsertPage(pos, CreateNewPage(), _T("Inserted page"), FALSE,
	482	GetIconIndex());
	483	}
	484
	485	void NotebookWidgetsPage::OnButtonRemovePage(wxCommandEvent& WXUNUSED(event))
	486	{
	487	int pos = GetTextValue(m_textRemove);
657c8818	488	wxCHECK_RET( IsValidValue(pos), _T("button should be disabled") );
32b8ec41 VZ	489
	490	m_notebook->DeletePage(pos);
	491	}
	492
	493	void NotebookWidgetsPage::OnUpdateUISelectButton(wxUpdateUIEvent& event)
	494	{
657c8818	495	event.Enable( IsValidValue(GetTextValue(m_textSelect)) );
32b8ec41 VZ	496	}
	497
	498	void NotebookWidgetsPage::OnUpdateUIInsertButton(wxUpdateUIEvent& event)
	499	{
657c8818	500	event.Enable( IsValidValue(GetTextValue(m_textInsert)) );
32b8ec41 VZ	501	}
	502
	503	void NotebookWidgetsPage::OnUpdateUIRemoveButton(wxUpdateUIEvent& event)
	504	{
657c8818	505	event.Enable( IsValidValue(GetTextValue(m_textRemove)) );
32b8ec41 VZ	506	}
	507
	508	void NotebookWidgetsPage::OnUpdateUIResetButton(wxUpdateUIEvent& event)
	509	{
	510	event.Enable( !m_chkImages->GetValue() \|\|
	511	m_radioOrient->GetSelection() != wxNB_TOP );
	512	}
	513
	514	void NotebookWidgetsPage::OnUpdateUINumPagesText(wxUpdateUIEvent& event)
	515	{
	516	event.SetText( wxString::Format(_T("%d"), m_notebook->GetPageCount()) );
	517	}
	518
	519	void NotebookWidgetsPage::OnUpdateUICurSelectText(wxUpdateUIEvent& event)
	520	{
	521	event.SetText( wxString::Format(_T("%d"), m_notebook->GetSelection()) );
	522	}
	523
c02e5a31	524	void NotebookWidgetsPage::OnCheckOrRadioBox(wxCommandEvent& WXUNUSED(event))
32b8ec41 VZ	525	{
	526	CreateNotebook();
	527	}
	528
	529	void NotebookWidgetsPage::OnPageChanging(wxNotebookEvent& event)
	530	{
	531	wxLogMessage(_T("Notebook page changing from %d to %d (currently %d)."),
	532	event.GetOldSelection(),
	533	event.GetSelection(),
	534	m_notebook->GetSelection());
	535
	536	event.Skip();
	537	}
	538
	539	void NotebookWidgetsPage::OnPageChanged(wxNotebookEvent& event)
	540	{
	541	wxLogMessage(_T("Notebook page changed from %d to %d (currently %d)."),
	542	event.GetOldSelection(),
	543	event.GetSelection(),
	544	m_notebook->GetSelection());
	545
	546	event.Skip();
	547	}
	548
2b5f62a0	549	#endif