Use template class instead of template function in wxVectorSort().

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

diff --git a/samples/widgets/notebook.cpp b/samples/widgets/notebook.cpp
index 736e43f8fb8bb45f62b61475dc9452938e8ca1f3..ded5de39005a79ec12b68446eff84e8005488f1b 100644 (file)
--- a/samples/widgets/notebook.cpp
+++ b/samples/widgets/notebook.cpp
@@ -1,11 +1,11 @@
 /////////////////////////////////////////////////////////////////////////////
 // Program:     wxWidgets Widgets Sample
 // Name:        notebook.cpp
 /////////////////////////////////////////////////////////////////////////////
 // Program:     wxWidgets Widgets Sample
 // Name:        notebook.cpp

-// Purpose:     Part of the widgets sample showing wxNotebook
-// Author:      Vadim Zeitlin
+// Purpose:     Part of the widgets sample showing book controls
+// Author:      Vadim Zeitlin, Wlodzimierz ABX Skiba

 // Created:     06.04.01
 // Id:          $Id$
 // Created:     06.04.01
 // Id:          $Id$

-// Copyright:   (c) 2001 Vadim Zeitlin
+// Copyright:   (c) 2001 Vadim Zeitlin, 2006 Wlodzimierz Skiba

 // License:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 
 // License:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 


@@ -24,7 +24,7 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

-#if wxUSE_NOTEBOOK
+#if wxUSE_BOOKCTRL

 
 // for all others, include the necessary headers
 #ifndef WX_PRECOMP
 
 // for all others, include the necessary headers
 #ifndef WX_PRECOMP


@@ -42,11 +42,11 @@
 #endif
 
 #include "wx/sizer.h"
 #endif
 
 #include "wx/sizer.h"

-#include "wx/notebook.h"
+#include "wx/bookctrl.h"

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

+#include "wx/imaglist.h"

 
 #include "widgets.h"
 
 #include "widgets.h"

-#include "icons/notebook.xpm"

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


@@ -55,21 +55,21 @@
 // control ids
 enum
 {
 // 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
+    BookPage_Reset = wxID_HIGHEST,
+    BookPage_SelectPage,
+    BookPage_AddPage,
+    BookPage_InsertPage,
+    BookPage_RemovePage,
+    BookPage_DeleteAll,
+    BookPage_InsertText,
+    BookPage_RemoveText,
+    BookPage_SelectText,
+    BookPage_NumPagesText,
+    BookPage_CurSelectText,
+    BookPage_Book

 };
 
 };
 

-// notebook orientations
+// book orientations

 enum Orient
 {
     Orient_Top,
 enum Orient
 {
     Orient_Top,


@@ -80,22 +80,23 @@ enum Orient
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------

-// NotebookWidgetsPage
+// BookWidgetsPage

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

-class NotebookWidgetsPage : public WidgetsPage
+class BookWidgetsPage : public WidgetsPage

 {
 public:
 {
 public:

-    NotebookWidgetsPage(wxNotebook *notebook, wxImageList *imaglist);
-    virtual ~NotebookWidgetsPage();
+    BookWidgetsPage(WidgetsBookCtrl *book, wxImageList *imaglist, const char *const icon[]);
+    virtual ~BookWidgetsPage();
+
+    virtual wxControl *GetWidget() const { return m_book; }
+    virtual void RecreateWidget() { RecreateBook(); }

 
 

-    virtual wxControl *GetWidget() const { return m_notebook; }
+    // lazy creation of the content
+    virtual void CreateContent();

 
 protected:
     // event handlers
 
 protected:
     // event handlers

-    void OnPageChanging(wxNotebookEvent& event);
-    void OnPageChanged(wxNotebookEvent& event);
-

     void OnButtonReset(wxCommandEvent& event);
     void OnButtonDeleteAll(wxCommandEvent& event);
     void OnButtonSelectPage(wxCommandEvent& event);
     void OnButtonReset(wxCommandEvent& event);
     void OnButtonDeleteAll(wxCommandEvent& event);
     void OnButtonSelectPage(wxCommandEvent& event);


@@ -114,14 +115,17 @@ protected:
 
     void OnUpdateUIResetButton(wxUpdateUIEvent& event);
 
 
     void OnUpdateUIResetButton(wxUpdateUIEvent& event);
 

-    // reset the wxNotebook parameters
+    // reset book parameters

     void Reset();
 
     void Reset();
 

-    // (re)create the wxNotebook
-    void CreateNotebook();
+    // (re)create book
+    void RecreateBook();
+    virtual wxBookCtrlBase *CreateBook(long flags) = 0;

 
 

+#if USE_ICONS_IN_BOOK

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

+#endif // USE_ICONS_IN_BOOK

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


@@ -134,7 +138,7 @@ protected:
 
     // is the value in range?
     bool IsValidValue(int val) const
 
     // is the value in range?
     bool IsValidValue(int val) const

-        { return (val >= 0) && (val < (int) m_notebook->GetPageCount()); }
+        { return (val >= 0) && (val < (int) m_book->GetPageCount()); }

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


@@ -148,85 +152,81 @@ protected:
                *m_textRemove,
                *m_textSelect;
 
                *m_textRemove,
                *m_textSelect;
 

-    // the notebook itself and the sizer it is in
-    wxNotebook *m_notebook;
-    wxSizer *m_sizerNotebook;
+    // the book itself and the sizer it is in
+    wxBookCtrlBase *m_book;
+    wxSizer *m_sizerBook;

 
 

-    // thei mage list for our notebook
+#if USE_ICONS_IN_BOOK
+    // the image list for our book

     wxImageList *m_imageList;
     wxImageList *m_imageList;

+#endif // USE_ICONS_IN_BOOK

 
 private:
     DECLARE_EVENT_TABLE()
 
 private:
     DECLARE_EVENT_TABLE()

-    DECLARE_WIDGETS_PAGE(NotebookWidgetsPage)

 };
 
 // ----------------------------------------------------------------------------
 // event tables
 // ----------------------------------------------------------------------------
 
 };
 
 // ----------------------------------------------------------------------------
 // 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)
+BEGIN_EVENT_TABLE(BookWidgetsPage, WidgetsPage)
+    EVT_BUTTON(BookPage_Reset, BookWidgetsPage::OnButtonReset)
+    EVT_BUTTON(BookPage_SelectPage, BookWidgetsPage::OnButtonSelectPage)
+    EVT_BUTTON(BookPage_AddPage, BookWidgetsPage::OnButtonAddPage)
+    EVT_BUTTON(BookPage_InsertPage, BookWidgetsPage::OnButtonInsertPage)
+    EVT_BUTTON(BookPage_RemovePage, BookWidgetsPage::OnButtonRemovePage)
+    EVT_BUTTON(BookPage_DeleteAll, BookWidgetsPage::OnButtonDeleteAll)

 
 

-    EVT_UPDATE_UI(NotebookPage_NumPagesText, NotebookWidgetsPage::OnUpdateUINumPagesText)
-    EVT_UPDATE_UI(NotebookPage_CurSelectText, NotebookWidgetsPage::OnUpdateUICurSelectText)
+    EVT_UPDATE_UI(BookPage_NumPagesText, BookWidgetsPage::OnUpdateUINumPagesText)
+    EVT_UPDATE_UI(BookPage_CurSelectText, BookWidgetsPage::OnUpdateUICurSelectText)

 
 

-    EVT_UPDATE_UI(NotebookPage_SelectPage, NotebookWidgetsPage::OnUpdateUISelectButton)
-    EVT_UPDATE_UI(NotebookPage_InsertPage, NotebookWidgetsPage::OnUpdateUIInsertButton)
-    EVT_UPDATE_UI(NotebookPage_RemovePage, NotebookWidgetsPage::OnUpdateUIRemoveButton)
+    EVT_UPDATE_UI(BookPage_SelectPage, BookWidgetsPage::OnUpdateUISelectButton)
+    EVT_UPDATE_UI(BookPage_InsertPage, BookWidgetsPage::OnUpdateUIInsertButton)
+    EVT_UPDATE_UI(BookPage_RemovePage, BookWidgetsPage::OnUpdateUIRemoveButton)

 
 

-    EVT_NOTEBOOK_PAGE_CHANGING(wxID_ANY, NotebookWidgetsPage::OnPageChanging)
-    EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, NotebookWidgetsPage::OnPageChanged)
-
-    EVT_CHECKBOX(wxID_ANY, NotebookWidgetsPage::OnCheckOrRadioBox)
-    EVT_RADIOBOX(wxID_ANY, NotebookWidgetsPage::OnCheckOrRadioBox)
+    EVT_CHECKBOX(wxID_ANY, BookWidgetsPage::OnCheckOrRadioBox)
+    EVT_RADIOBOX(wxID_ANY, BookWidgetsPage::OnCheckOrRadioBox)

 END_EVENT_TABLE()
 
 // ============================================================================
 // implementation
 // ============================================================================
 
 END_EVENT_TABLE()
 
 // ============================================================================
 // implementation
 // ============================================================================
 

-IMPLEMENT_WIDGETS_PAGE(NotebookWidgetsPage, _T("Notebook"));
-
-NotebookWidgetsPage::NotebookWidgetsPage(wxNotebook *notebook,
-                                         wxImageList *imaglist)
-                  : WidgetsPage(notebook)
+BookWidgetsPage::BookWidgetsPage(WidgetsBookCtrl *book, wxImageList *imaglist, const char *const icon[])
+                :WidgetsPage(book, imaglist, icon)

 {
 {

-    imaglist->Add(wxBitmap(notebook_xpm));
-

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

+#if USE_ICONS_IN_BOOK

     m_imageList = NULL;
     m_imageList = NULL;

+#endif // USE_ICONS_IN_BOOK

 
 

-    m_notebook = (wxNotebook *)NULL;
-    m_sizerNotebook = (wxSizer *)NULL;
+    m_book = NULL;
+    m_radioOrient = NULL;
+    m_sizerBook = (wxSizer *)NULL;
+}

 
 

+void BookWidgetsPage::CreateContent()
+{

     wxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);
 
     // left pane
     wxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);
 
     // left pane

-    wxStaticBox *box = new wxStaticBox(this, wxID_ANY, _T("&Set style"));
+    wxStaticBox *box = new wxStaticBox(this, wxID_ANY, wxT("&Set style"));

 
     // must be in sync with Orient enum
 
     // must be in sync with Orient enum

-    wxString orientations[] =
-    {
-        _T("&top"),
-        _T("&bottom"),
-        _T("&left"),
-        _T("&right"),
-    };
+    wxArrayString orientations;
+    orientations.Add(wxT("&top"));
+    orientations.Add(wxT("&bottom"));
+    orientations.Add(wxT("&left"));
+    orientations.Add(wxT("&right"));

 
 

-    wxASSERT_MSG( WXSIZEOF(orientations) == Orient_Max,
-                  _T("forgot to update something") );
+    wxASSERT_MSG( orientations.GetCount() == Orient_Max,
+                  wxT("forgot to update something") );

 
 

-    m_chkImages = new wxCheckBox(this, wxID_ANY, _T("Show &images"));
-    m_radioOrient = new wxRadioBox(this, wxID_ANY, _T("&Tab orientation"),
+    m_chkImages = new wxCheckBox(this, wxID_ANY, wxT("Show &images"));
+    m_radioOrient = new wxRadioBox(this, wxID_ANY, wxT("&Tab orientation"),

                                    wxDefaultPosition, wxDefaultSize,
                                    wxDefaultPosition, wxDefaultSize,

-                                   WXSIZEOF(orientations), orientations,
-                                   1, wxRA_SPECIFY_COLS);
+                                   orientations, 1, wxRA_SPECIFY_COLS);

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


@@ -234,87 +234,88 @@ NotebookWidgetsPage::NotebookWidgetsPage(wxNotebook *notebook,
     sizerLeft->Add(5, 5, 0, wxGROW | wxALL, 5); // spacer
     sizerLeft->Add(m_radioOrient, 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"));
+    wxButton *btn = new wxButton(this, BookPage_Reset, wxT("&Reset"));

     sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL | wxALL, 15);
 
     // middle pane
     sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL | wxALL, 15);
 
     // middle pane

-    wxStaticBox *box2 = new wxStaticBox(this, wxID_ANY, _T("&Contents"));
+    wxStaticBox *box2 = new wxStaticBox(this, wxID_ANY, wxT("&Contents"));

     wxSizer *sizerMiddle = new wxStaticBoxSizer(box2, wxVERTICAL);
 
     wxTextCtrl *text;
     wxSizer *sizerMiddle = new wxStaticBoxSizer(box2, wxVERTICAL);
 
     wxTextCtrl *text;

-    wxSizer *sizerRow = CreateSizerWithTextAndLabel(_T("Number of pages: "),
-                                                    NotebookPage_NumPagesText,
+    wxSizer *sizerRow = CreateSizerWithTextAndLabel(wxT("Number of pages: "),
+                                                    BookPage_NumPagesText,

                                                     &text);
     text->SetEditable(false);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 
                                                     &text);
     text->SetEditable(false);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 

-    sizerRow = CreateSizerWithTextAndLabel(_T("Current selection: "),
-                                           NotebookPage_CurSelectText,
+    sizerRow = CreateSizerWithTextAndLabel(wxT("Current selection: "),
+                                           BookPage_CurSelectText,

                                            &text);
     text->SetEditable(false);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 
                                            &text);
     text->SetEditable(false);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 

-    sizerRow = CreateSizerWithTextAndButton(NotebookPage_SelectPage,
-                                            _T("&Select page"),
-                                            NotebookPage_SelectText,
+    sizerRow = CreateSizerWithTextAndButton(BookPage_SelectPage,
+                                            wxT("&Select page"),
+                                            BookPage_SelectText,

                                             &m_textSelect);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 
                                             &m_textSelect);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 

-    btn = new wxButton(this, NotebookPage_AddPage, _T("&Add page"));
+    btn = new wxButton(this, BookPage_AddPage, wxT("&Add page"));

     sizerMiddle->Add(btn, 0, wxALL | wxGROW, 5);
 
     sizerMiddle->Add(btn, 0, wxALL | wxGROW, 5);
 

-    sizerRow = CreateSizerWithTextAndButton(NotebookPage_InsertPage,
-                                            _T("&Insert page at"),
-                                            NotebookPage_InsertText,
+    sizerRow = CreateSizerWithTextAndButton(BookPage_InsertPage,
+                                            wxT("&Insert page at"),
+                                            BookPage_InsertText,

                                             &m_textInsert);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 
                                             &m_textInsert);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 

-    sizerRow = CreateSizerWithTextAndButton(NotebookPage_RemovePage,
-                                            _T("&Remove page"),
-                                            NotebookPage_RemoveText,
+    sizerRow = CreateSizerWithTextAndButton(BookPage_RemovePage,
+                                            wxT("&Remove page"),
+                                            BookPage_RemoveText,

                                             &m_textRemove);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 
                                             &m_textRemove);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 

-    btn = new wxButton(this, NotebookPage_DeleteAll, _T("&Delete All"));
+    btn = new wxButton(this, BookPage_DeleteAll, wxT("&Delete All"));

     sizerMiddle->Add(btn, 0, wxALL | wxGROW, 5);
 
     // right pane
     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
+    m_sizerBook = new wxBoxSizer(wxHORIZONTAL);

 
 

-    // the 3 panes panes compose the window
+    // the 3 panes compose the window

     sizerTop->Add(sizerLeft, 0, wxGROW | (wxALL & ~wxLEFT), 10);
     sizerTop->Add(sizerMiddle, 0, wxGROW | wxALL, 10);
     sizerTop->Add(sizerLeft, 0, wxGROW | (wxALL & ~wxLEFT), 10);
     sizerTop->Add(sizerMiddle, 0, wxGROW | wxALL, 10);

-    sizerTop->Add(sizerRight, 1, wxGROW | (wxALL & ~wxRIGHT), 10);
+    sizerTop->Add(m_sizerBook, 1, wxGROW | (wxALL & ~wxRIGHT), 10);
+
+    RecreateBook();

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

+#if USE_ICONS_IN_BOOK

     CreateImageList();
     CreateImageList();

+#endif // USE_ICONS_IN_BOOK

 
     SetSizer(sizerTop);
 
     SetSizer(sizerTop);

-
-    sizerTop->Fit(this);

 }
 
 }
 

-NotebookWidgetsPage::~NotebookWidgetsPage()
+BookWidgetsPage::~BookWidgetsPage()

 {
 {

+#if USE_ICONS_IN_BOOK

     delete m_imageList;
     delete m_imageList;

+#endif // USE_ICONS_IN_BOOK

 }
 
 // ----------------------------------------------------------------------------
 // operations
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // operations
 // ----------------------------------------------------------------------------
 

-void NotebookWidgetsPage::Reset()
+void BookWidgetsPage::Reset()

 {
     m_chkImages->SetValue(true);
     m_radioOrient->SetSelection(Orient_Top);
 }
 
 {
     m_chkImages->SetValue(true);
     m_radioOrient->SetSelection(Orient_Top);
 }
 

-void NotebookWidgetsPage::CreateImageList()
+#if USE_ICONS_IN_BOOK
+void BookWidgetsPage::CreateImageList()

 {
     if ( m_chkImages->GetValue() )
     {
 {
     if ( m_chkImages->GetValue() )
     {


@@ -329,7 +330,8 @@ void NotebookWidgetsPage::CreateImageList()
             m_imageList->Add(wxArtProvider::GetIcon(wxART_ERROR, wxART_OTHER, size));
         }
 
             m_imageList->Add(wxArtProvider::GetIcon(wxART_ERROR, wxART_OTHER, size));
         }
 

-        m_notebook->SetImageList(m_imageList);
+        if ( m_book )
+            m_book->SetImageList(m_imageList);

     }
     else // no images
     {
     }
     else // no images
     {


@@ -341,207 +343,427 @@ void NotebookWidgetsPage::CreateImageList()
     }
 
     // because of the bug in wxMSW we can't use SetImageList(NULL) - although
     }
 
     // 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
+    // it would be logical if this removed the image list from book, under
+    // MSW it crashes instead - FIXME

 }
 }

+#endif // USE_ICONS_IN_BOOK

 
 

-void NotebookWidgetsPage::CreateNotebook()
+void BookWidgetsPage::RecreateBook()

 {
 {

-    int flags;
+    // do not recreate anything in case page content was not prepared yet
+    if(!m_radioOrient)
+        return;
+
+    int flags = ms_defaultFlags;
+

     switch ( m_radioOrient->GetSelection() )
     {
         default:
     switch ( m_radioOrient->GetSelection() )
     {
         default:

-            wxFAIL_MSG( _T("unknown notebook orientation") );
+            wxFAIL_MSG( wxT("unknown orientation") );

             // fall through
 
         case Orient_Top:
             // fall through
 
         case Orient_Top:

-            flags = wxNB_TOP;
+            flags |= wxBK_TOP;

             break;
 
         case Orient_Bottom:
             break;
 
         case Orient_Bottom:

-            flags = wxNB_BOTTOM;
+            flags |= wxBK_BOTTOM;

             break;
 
         case Orient_Left:
             break;
 
         case Orient_Left:

-            flags = wxNB_LEFT;
+            flags |= wxBK_LEFT;

             break;
 
         case Orient_Right:
             break;
 
         case Orient_Right:

-            flags = wxNB_RIGHT;
+            flags |= wxBK_RIGHT;

             break;
     }
 
             break;
     }
 

-    wxNotebook *old_note = m_notebook;
+    wxBookCtrlBase *oldBook = m_book;

 
 

-    m_notebook = new wxNotebook(this, NotebookPage_Notebook,
-                                wxDefaultPosition, wxDefaultSize,
-                                flags);
+    m_book = CreateBook(flags);

 
 

+#if USE_ICONS_IN_BOOK

     CreateImageList();
     CreateImageList();

+#endif // USE_ICONS_IN_BOOK

 
 

-    if ( old_note )
+    if ( oldBook )

     {
     {

-        const int sel = old_note->GetSelection();
+        const int sel = oldBook->GetSelection();

 
 

-        const int count = old_note->GetPageCount();
+        const int count = oldBook->GetPageCount();

 
         // recreate the pages
         for ( int n = 0; n < count; n++ )
         {
 
         // recreate the pages
         for ( int n = 0; n < count; n++ )
         {

-            m_notebook->AddPage(CreateNewPage(),
-                                old_note->GetPageText(n),
-                                false,
-                                m_chkImages->GetValue() ?
-                                GetIconIndex() : -1);
+            m_book->AddPage(CreateNewPage(),
+                            oldBook->GetPageText(n),
+                            false,
+                            m_chkImages->GetValue() ?
+                            GetIconIndex() : -1);

         }
 
         }
 

-        m_sizerNotebook->Detach( old_note );
-        delete old_note;
+        m_sizerBook->Detach( oldBook );
+        delete oldBook;

 
         // restore selection
         if ( sel != -1 )
         {
 
         // restore selection
         if ( sel != -1 )
         {

-            m_notebook->SetSelection(sel);
+            m_book->SetSelection(sel);

         }
     }
 
         }
     }
 

-    m_sizerNotebook->Add(m_notebook, 1, wxGROW | wxALL, 5);
-    m_sizerNotebook->Layout();
+    m_sizerBook->Add(m_book, 1, wxGROW | wxALL, 5);
+    m_sizerBook->SetMinSize(150, 0);
+    m_sizerBook->Layout();

 }
 
 // ----------------------------------------------------------------------------
 // helpers
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // helpers
 // ----------------------------------------------------------------------------
 

-int NotebookWidgetsPage::GetTextValue(wxTextCtrl *text) const
+int BookWidgetsPage::GetTextValue(wxTextCtrl *text) const

 {
 {

-    long pos;
-    if ( !text->GetValue().ToLong(&pos) )
+    long pos = -1;
+
+    if ( !text || !text->GetValue().ToLong(&pos) )

         pos = -1;
 
     return (int)pos;
 }
 
         pos = -1;
 
     return (int)pos;
 }
 

-int NotebookWidgetsPage::GetIconIndex() const
+int BookWidgetsPage::GetIconIndex() const

 {
 {

+#if USE_ICONS_IN_BOOK

     if ( m_imageList )
     {
        int nImages = m_imageList->GetImageCount();
        if ( nImages > 0 )
        {
     if ( m_imageList )
     {
        int nImages = m_imageList->GetImageCount();
        if ( nImages > 0 )
        {

-           return m_notebook->GetPageCount() % nImages;
+           return m_book->GetPageCount() % nImages;

        }
     }
        }
     }

+#endif // USE_ICONS_IN_BOOK

 
     return -1;
 }
 
 
     return -1;
 }
 

-wxWindow *NotebookWidgetsPage::CreateNewPage()
+wxWindow *BookWidgetsPage::CreateNewPage()

 {
 {

-    return new wxTextCtrl(m_notebook, wxID_ANY, _T("I'm a notebook page"));
+    return new wxTextCtrl(m_book, wxID_ANY, wxT("I'm a book page"));

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

-void NotebookWidgetsPage::OnButtonReset(wxCommandEvent& WXUNUSED(event))
+void BookWidgetsPage::OnButtonReset(wxCommandEvent& WXUNUSED(event))

 {
     Reset();
 
 {
     Reset();
 

-    CreateNotebook();
+    RecreateBook();

 }
 
 }
 

-void NotebookWidgetsPage::OnButtonDeleteAll(wxCommandEvent& WXUNUSED(event))
+void BookWidgetsPage::OnButtonDeleteAll(wxCommandEvent& WXUNUSED(event))

 {
 {

-    m_notebook->DeleteAllPages();
+    m_book->DeleteAllPages();

 }
 
 }
 

-void NotebookWidgetsPage::OnButtonSelectPage(wxCommandEvent& WXUNUSED(event))
+void BookWidgetsPage::OnButtonSelectPage(wxCommandEvent& WXUNUSED(event))

 {
     int pos = GetTextValue(m_textSelect);
 {
     int pos = GetTextValue(m_textSelect);

-    wxCHECK_RET( IsValidValue(pos), _T("button should be disabled") );
+    wxCHECK_RET( IsValidValue(pos), wxT("button should be disabled") );

 
 

-    m_notebook->SetSelection(pos);
+    m_book->SetSelection(pos);

 }
 
 }
 

-void NotebookWidgetsPage::OnButtonAddPage(wxCommandEvent& WXUNUSED(event))
+void BookWidgetsPage::OnButtonAddPage(wxCommandEvent& WXUNUSED(event))

 {
 {

-    m_notebook->AddPage(CreateNewPage(), _T("Added page"), false,
-                        GetIconIndex());
+    m_book->AddPage(CreateNewPage(), wxT("Added page"), false,
+                    GetIconIndex());

 }
 
 }
 

-void NotebookWidgetsPage::OnButtonInsertPage(wxCommandEvent& WXUNUSED(event))
+void BookWidgetsPage::OnButtonInsertPage(wxCommandEvent& WXUNUSED(event))

 {
     int pos = GetTextValue(m_textInsert);
 {
     int pos = GetTextValue(m_textInsert);

-    wxCHECK_RET( IsValidValue(pos), _T("button should be disabled") );
+    wxCHECK_RET( IsValidValue(pos), wxT("button should be disabled") );

 
 

-    m_notebook->InsertPage(pos, CreateNewPage(), _T("Inserted page"), false,
-                           GetIconIndex());
+    m_book->InsertPage(pos, CreateNewPage(), wxT("Inserted page"), false,
+                       GetIconIndex());

 }
 
 }
 

-void NotebookWidgetsPage::OnButtonRemovePage(wxCommandEvent& WXUNUSED(event))
+void BookWidgetsPage::OnButtonRemovePage(wxCommandEvent& WXUNUSED(event))

 {
     int pos = GetTextValue(m_textRemove);
 {
     int pos = GetTextValue(m_textRemove);

-    wxCHECK_RET( IsValidValue(pos), _T("button should be disabled") );
+    wxCHECK_RET( IsValidValue(pos), wxT("button should be disabled") );

 
 

-    m_notebook->DeletePage(pos);
+    m_book->DeletePage(pos);

 }
 
 }
 

-void NotebookWidgetsPage::OnUpdateUISelectButton(wxUpdateUIEvent& event)
+void BookWidgetsPage::OnUpdateUISelectButton(wxUpdateUIEvent& event)

 {
     event.Enable( IsValidValue(GetTextValue(m_textSelect)) );
 }
 
 {
     event.Enable( IsValidValue(GetTextValue(m_textSelect)) );
 }
 

-void NotebookWidgetsPage::OnUpdateUIInsertButton(wxUpdateUIEvent& event)
+void BookWidgetsPage::OnUpdateUIInsertButton(wxUpdateUIEvent& event)

 {
     event.Enable( IsValidValue(GetTextValue(m_textInsert)) );
 }
 
 {
     event.Enable( IsValidValue(GetTextValue(m_textInsert)) );
 }
 

-void NotebookWidgetsPage::OnUpdateUIRemoveButton(wxUpdateUIEvent& event)
+void BookWidgetsPage::OnUpdateUIRemoveButton(wxUpdateUIEvent& event)

 {
     event.Enable( IsValidValue(GetTextValue(m_textRemove)) );
 }
 
 {
     event.Enable( IsValidValue(GetTextValue(m_textRemove)) );
 }
 

-void NotebookWidgetsPage::OnUpdateUIResetButton(wxUpdateUIEvent& event)
+void BookWidgetsPage::OnUpdateUIResetButton(wxUpdateUIEvent& event)

 {
 {

-    event.Enable( !m_chkImages->GetValue() ||
-                  m_radioOrient->GetSelection() != wxNB_TOP );
+    if(m_chkImages && m_radioOrient)
+        event.Enable( !m_chkImages->GetValue() ||
+                      m_radioOrient->GetSelection() != wxBK_TOP );

 }
 
 }
 

-void NotebookWidgetsPage::OnUpdateUINumPagesText(wxUpdateUIEvent& event)
+void BookWidgetsPage::OnUpdateUINumPagesText(wxUpdateUIEvent& event)

 {
 {

-    event.SetText( wxString::Format(_T("%d"), m_notebook->GetPageCount()) );
+    if(m_book)
+        event.SetText( wxString::Format(wxT("%u"), unsigned(m_book->GetPageCount())) );

 }
 
 }
 

-void NotebookWidgetsPage::OnUpdateUICurSelectText(wxUpdateUIEvent& event)
+void BookWidgetsPage::OnUpdateUICurSelectText(wxUpdateUIEvent& event)

 {
 {

-    event.SetText( wxString::Format(_T("%d"), m_notebook->GetSelection()) );
+    if(m_book)
+        event.SetText( wxString::Format(wxT("%d"), m_book->GetSelection()) );

 }
 
 }
 

-void NotebookWidgetsPage::OnCheckOrRadioBox(wxCommandEvent& WXUNUSED(event))
+void BookWidgetsPage::OnCheckOrRadioBox(wxCommandEvent& WXUNUSED(event))

 {
 {

-    CreateNotebook();
+    RecreateBook();

 }
 
 }
 

+#if wxUSE_NOTEBOOK
+
+#include "icons/notebook.xpm"
+#include "wx/notebook.h"
+
+// ----------------------------------------------------------------------------
+// NotebookWidgetsPage
+// ----------------------------------------------------------------------------
+
+class NotebookWidgetsPage : public BookWidgetsPage
+{
+public:
+    NotebookWidgetsPage(WidgetsBookCtrl *book, wxImageList *imaglist)
+        : BookWidgetsPage(book, imaglist, notebook_xpm)
+    {
+        RecreateBook();
+    }
+    virtual ~NotebookWidgetsPage() {}
+
+protected:
+
+    // event handlers
+    void OnPageChanging(wxNotebookEvent& event);
+    void OnPageChanged(wxNotebookEvent& event);
+
+    // (re)create book
+    virtual wxBookCtrlBase *CreateBook(long flags)
+    {
+        return new wxNotebook(this, BookPage_Book,
+                              wxDefaultPosition, wxDefaultSize,
+                              flags);
+    }
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_WIDGETS_PAGE(NotebookWidgetsPage)
+};
+
+// ----------------------------------------------------------------------------
+// event table
+// ----------------------------------------------------------------------------
+
+BEGIN_EVENT_TABLE(NotebookWidgetsPage, BookWidgetsPage)
+    EVT_NOTEBOOK_PAGE_CHANGING(wxID_ANY, NotebookWidgetsPage::OnPageChanging)
+    EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, NotebookWidgetsPage::OnPageChanged)
+END_EVENT_TABLE()
+
+#if defined(__WXUNIVERSAL__)
+    #define FAMILY_CTRLS UNIVERSAL_CTRLS
+#elif defined(__WXMOTIF__)
+    #define FAMILY_CTRLS GENERIC_CTRLS
+#else
+    #define FAMILY_CTRLS NATIVE_CTRLS
+#endif
+
+IMPLEMENT_WIDGETS_PAGE(NotebookWidgetsPage, wxT("Notebook"),
+                       FAMILY_CTRLS | BOOK_CTRLS
+                       );
+

 void NotebookWidgetsPage::OnPageChanging(wxNotebookEvent& event)
 {
 void NotebookWidgetsPage::OnPageChanging(wxNotebookEvent& event)
 {

-    wxLogMessage(_T("Notebook page changing from %d to %d (currently %d)."),
+    wxLogMessage(wxT("Notebook page changing from %d to %d (currently %d)."),

                  event.GetOldSelection(),
                  event.GetSelection(),
                  event.GetOldSelection(),
                  event.GetSelection(),

-                 m_notebook->GetSelection());
+                 m_book->GetSelection());

 
     event.Skip();
 }
 
 void NotebookWidgetsPage::OnPageChanged(wxNotebookEvent& event)
 {
 
     event.Skip();
 }
 
 void NotebookWidgetsPage::OnPageChanged(wxNotebookEvent& event)
 {

-    wxLogMessage(_T("Notebook page changed from %d to %d (currently %d)."),
+    wxLogMessage(wxT("Notebook page changed from %d to %d (currently %d)."),

                  event.GetOldSelection(),
                  event.GetSelection(),
                  event.GetOldSelection(),
                  event.GetSelection(),

-                 m_notebook->GetSelection());
+                 m_book->GetSelection());

 
     event.Skip();
 }
 
 #endif // wxUSE_NOTEBOOK
 
     event.Skip();
 }
 
 #endif // wxUSE_NOTEBOOK

+
+#if wxUSE_LISTBOOK
+
+#include "icons/listbook.xpm"
+#include "wx/listbook.h"
+
+// ----------------------------------------------------------------------------
+// ListbookWidgetsPage
+// ----------------------------------------------------------------------------
+
+class ListbookWidgetsPage : public BookWidgetsPage
+{
+public:
+    ListbookWidgetsPage(WidgetsBookCtrl *book, wxImageList *imaglist)
+        : BookWidgetsPage(book, imaglist, listbook_xpm)
+    {
+        RecreateBook();
+    }
+    virtual ~ListbookWidgetsPage() {}
+
+protected:
+
+    // event handlers
+    void OnPageChanging(wxListbookEvent& event);
+    void OnPageChanged(wxListbookEvent& event);
+
+    // (re)create book
+    virtual wxBookCtrlBase *CreateBook(long flags)
+    {
+        return new wxListbook(this, BookPage_Book,
+                              wxDefaultPosition, wxDefaultSize,
+                              flags);
+    }
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_WIDGETS_PAGE(ListbookWidgetsPage)
+};
+
+// ----------------------------------------------------------------------------
+// event table
+// ----------------------------------------------------------------------------
+
+BEGIN_EVENT_TABLE(ListbookWidgetsPage, BookWidgetsPage)
+    EVT_LISTBOOK_PAGE_CHANGING(wxID_ANY, ListbookWidgetsPage::OnPageChanging)
+    EVT_LISTBOOK_PAGE_CHANGED(wxID_ANY, ListbookWidgetsPage::OnPageChanged)
+END_EVENT_TABLE()
+
+IMPLEMENT_WIDGETS_PAGE(ListbookWidgetsPage, wxT("Listbook"),
+                       GENERIC_CTRLS | BOOK_CTRLS
+                       );
+
+void ListbookWidgetsPage::OnPageChanging(wxListbookEvent& event)
+{
+    wxLogMessage(wxT("Listbook page changing from %d to %d (currently %d)."),
+                 event.GetOldSelection(),
+                 event.GetSelection(),
+                 m_book->GetSelection());
+
+    event.Skip();
+}
+
+void ListbookWidgetsPage::OnPageChanged(wxListbookEvent& event)
+{
+    wxLogMessage(wxT("Listbook page changed from %d to %d (currently %d)."),
+                 event.GetOldSelection(),
+                 event.GetSelection(),
+                 m_book->GetSelection());
+
+    event.Skip();
+}
+
+#endif // wxUSE_LISTBOOK
+
+#if wxUSE_CHOICEBOOK
+
+#include "icons/choicebk.xpm"
+#include "wx/choicebk.h"
+
+// ----------------------------------------------------------------------------
+// ChoicebookWidgetsPage
+// ----------------------------------------------------------------------------
+
+class ChoicebookWidgetsPage : public BookWidgetsPage
+{
+public:
+    ChoicebookWidgetsPage(WidgetsBookCtrl *book, wxImageList *imaglist)
+        : BookWidgetsPage(book, imaglist, choicebk_xpm)
+    {
+        RecreateBook();
+    }
+    virtual ~ChoicebookWidgetsPage() {}
+
+protected:
+
+    // event handlers
+    void OnPageChanging(wxChoicebookEvent& event);
+    void OnPageChanged(wxChoicebookEvent& event);
+
+    // (re)create book
+    virtual wxBookCtrlBase *CreateBook(long flags)
+    {
+        return new wxChoicebook(this, BookPage_Book,
+                                wxDefaultPosition, wxDefaultSize,
+                                flags);
+    }
+
+private:
+    DECLARE_EVENT_TABLE()
+    DECLARE_WIDGETS_PAGE(ChoicebookWidgetsPage)
+};
+
+// ----------------------------------------------------------------------------
+// event table
+// ----------------------------------------------------------------------------
+
+BEGIN_EVENT_TABLE(ChoicebookWidgetsPage, BookWidgetsPage)
+    EVT_CHOICEBOOK_PAGE_CHANGING(wxID_ANY, ChoicebookWidgetsPage::OnPageChanging)
+    EVT_CHOICEBOOK_PAGE_CHANGED(wxID_ANY, ChoicebookWidgetsPage::OnPageChanged)
+END_EVENT_TABLE()
+
+IMPLEMENT_WIDGETS_PAGE(ChoicebookWidgetsPage, wxT("Choicebook"),
+                       GENERIC_CTRLS | BOOK_CTRLS
+                       );
+
+void ChoicebookWidgetsPage::OnPageChanging(wxChoicebookEvent& event)
+{
+    wxLogMessage(wxT("Choicebook page changing from %d to %d (currently %d)."),
+                 event.GetOldSelection(),
+                 event.GetSelection(),
+                 m_book->GetSelection());
+
+    event.Skip();
+}
+
+void ChoicebookWidgetsPage::OnPageChanged(wxChoicebookEvent& event)
+{
+    wxLogMessage(wxT("Choicebook page changed from %d to %d (currently %d)."),
+                 event.GetOldSelection(),
+                 event.GetSelection(),
+                 m_book->GetSelection());
+
+    event.Skip();
+}
+
+#endif // wxUSE_CHOICEBOOK
+
+#endif // wxUSE_BOOKCTRL