]> git.saurik.com Git - wxWidgets.git/blobdiff - samples/widgets/notebook.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix handling of help buttons with non-empty label under OS X.
[wxWidgets.git] / samples / widgets / notebook.cpp
diff --git a/samples/widgets/notebook.cpp b/samples/widgets/notebook.cpp
index 170e535864971cf74af2171824307bff0cf02411..71161eea3510a70a5d4a7390533ef681fe8883db 100644 (file)
--- a/samples/widgets/notebook.cpp
+++ b/samples/widgets/notebook.cpp
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Program:     wxWindows Widgets Sample
+// Program:     wxWidgets Widgets Sample
 // Name:        notebook.cpp
 // 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
-// License:     wxWindows license
+// Copyright:   (c) 2001 Vadim Zeitlin, 2006 Wlodzimierz Skiba
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
@@ -24,6 +24,8 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 
+#if wxUSE_BOOKCTRL
+
 // for all others, include the necessary headers
 #ifndef WX_PRECOMP
     #include "wx/app.h"
 // for all others, include the necessary headers
 #ifndef WX_PRECOMP
     #include "wx/app.h"
@@ -40,13 +42,12 @@
 #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
 // ----------------------------------------------------------------------------
@@ -54,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,
@@ -78,26 +79,24 @@ enum Orient
     Orient_Max
 };
 
     Orient_Max
 };
 
-// old versions of wxWindows don't define this style
-#ifndef wxNB_TOP
-    #define wxNB_TOP (0)
-#endif
-
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
-// 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(); }
+
+    // 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);
@@ -116,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,6 +136,10 @@ protected:
     // get the numeric value of text ctrl
     int GetTextValue(wxTextCtrl *text) 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_book->GetPageCount()); }
+
     // the controls
     // ------------
 
     // the controls
     // ------------
 
@@ -146,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)
-
-    EVT_UPDATE_UI(NotebookPage_NumPagesText, NotebookWidgetsPage::OnUpdateUINumPagesText)
-    EVT_UPDATE_UI(NotebookPage_CurSelectText, NotebookWidgetsPage::OnUpdateUICurSelectText)
+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_SelectPage, NotebookWidgetsPage::OnUpdateUISelectButton)
-    EVT_UPDATE_UI(NotebookPage_InsertPage, NotebookWidgetsPage::OnUpdateUIInsertButton)
-    EVT_UPDATE_UI(NotebookPage_RemovePage, NotebookWidgetsPage::OnUpdateUIRemoveButton)
+    EVT_UPDATE_UI(BookPage_NumPagesText, BookWidgetsPage::OnUpdateUINumPagesText)
+    EVT_UPDATE_UI(BookPage_CurSelectText, BookWidgetsPage::OnUpdateUICurSelectText)
 
 
-    EVT_NOTEBOOK_PAGE_CHANGING(-1, NotebookWidgetsPage::OnPageChanging)
-    EVT_NOTEBOOK_PAGE_CHANGED(-1, NotebookWidgetsPage::OnPageChanged)
+    EVT_UPDATE_UI(BookPage_SelectPage, BookWidgetsPage::OnUpdateUISelectButton)
+    EVT_UPDATE_UI(BookPage_InsertPage, BookWidgetsPage::OnUpdateUIInsertButton)
+    EVT_UPDATE_UI(BookPage_RemovePage, BookWidgetsPage::OnUpdateUIRemoveButton)
 
 
-    EVT_CHECKBOX(-1, NotebookWidgetsPage::OnCheckOrRadioBox)
-    EVT_RADIOBOX(-1, 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, -1, _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, -1, _T("Show &images"));
-    m_radioOrient = new wxRadioBox(this, -1, _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);
 
@@ -232,88 +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, -1, _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);
-    text->SetEditable(FALSE);
+    text->SetEditable(false);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 
-    sizerRow = CreateSizerWithTextAndLabel(_T("Current selection: "),
-                                           NotebookPage_CurSelectText,
+    sizerRow = CreateSizerWithTextAndLabel(wxT("Current selection: "),
+                                           BookPage_CurSelectText,
                                            &text);
                                            &text);
-    text->SetEditable(FALSE);
+    text->SetEditable(false);
     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 
     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(250, 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
 
 
-    SetAutoLayout(TRUE);
     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_chkImages->SetValue(true);
     m_radioOrient->SetSelection(Orient_Top);
 }
 
     m_radioOrient->SetSelection(Orient_Top);
 }
 
-void NotebookWidgetsPage::CreateImageList()
+#if USE_ICONS_IN_BOOK
+void BookWidgetsPage::CreateImageList()
 {
     if ( m_chkImages->GetValue() )
     {
 {
     if ( m_chkImages->GetValue() )
     {
@@ -328,218 +330,436 @@ 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
     {
-        if ( m_imageList )
-        {
-            delete m_imageList;
-            m_imageList = NULL;
-        }
+        wxDELETE(m_imageList);
     }
 
     // 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 notebok 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 *notebook = 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 ( notebook )
+    if ( oldBook )
     {
     {
-        int sel = notebook->GetSelection();
+        const int sel = oldBook->GetSelection();
 
 
-        int count = notebook->GetPageCount();
+        const int count = oldBook->GetPageCount();
+
+        // recreate the pages
         for ( int n = 0; n < count; n++ )
         {
         for ( int n = 0; n < count; n++ )
         {
-            wxNotebookPage *page = notebook->GetPage(0);
-            page->Reparent(m_notebook);
-
-            m_notebook->AddPage(page, notebook->GetPageText(0), FALSE,
-                                notebook->GetPageImage(0));
-
-            notebook->RemovePage(0);
+            m_book->AddPage(CreateNewPage(),
+                            oldBook->GetPageText(n),
+                            false,
+                            m_chkImages->GetValue() ?
+                            GetIconIndex() : -1);
         }
 
         }
 
-        m_sizerNotebook->Remove(notebook);
-        delete notebook;
+        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, -1, _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& event)
+void BookWidgetsPage::OnButtonSelectPage(wxCommandEvent& WXUNUSED(event))
 {
     int pos = GetTextValue(m_textSelect);
 {
     int pos = GetTextValue(m_textSelect);
-    wxCHECK_RET( pos >= 0, _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( pos >= 0, _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( pos >= 0, _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( GetTextValue(m_textSelect) >= 0 );
+    event.Enable( IsValidValue(GetTextValue(m_textSelect)) );
 }
 
 }
 
-void NotebookWidgetsPage::OnUpdateUIInsertButton(wxUpdateUIEvent& event)
+void BookWidgetsPage::OnUpdateUIInsertButton(wxUpdateUIEvent& event)
 {
 {
-    event.Enable( GetTextValue(m_textInsert) >= 0 );
+    event.Enable( IsValidValue(GetTextValue(m_textInsert)) );
 }
 
 }
 
-void NotebookWidgetsPage::OnUpdateUIRemoveButton(wxUpdateUIEvent& event)
+void BookWidgetsPage::OnUpdateUIRemoveButton(wxUpdateUIEvent& event)
 {
 {
-    event.Enable( GetTextValue(m_textRemove) >= 0 );
+    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& 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(),
+                 m_book->GetSelection());
+
+    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(),
                  event.GetOldSelection(),
                  event.GetSelection(),
-                 m_notebook->GetSelection());
+                 m_book->GetSelection());
 
     event.Skip();
 }
 
 
     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
wxWidgets (Impactor)