interpreting DrawBitmap for mono bitmaps according to the docs : using textfore-...

[wxWidgets.git] / src / generic / notebook.cpp

diff --git a/src/generic/notebook.cpp b/src/generic/notebook.cpp
index a398e2a5467f0d59f6d4134dd8f70300a3c2469e..a77f340b2ecd97d4f6ac69288c3956cae4201e7e 100644 (file)
--- a/src/generic/notebook.cpp
+++ b/src/generic/notebook.cpp
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        notebook.cpp
-// Purpose:     implementation of wxNotebook
+// Name:        src/generic/notebook.cpp
+// Purpose:     generic implementation of wxNotebook

 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98
 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98


@@ -16,54 +16,99 @@
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------

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

 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #endif
 

-#include  "wx/string.h"
-#include  "wx/log.h"
-#include  "wx/settings.h"
-#include  "wx/generic/imaglist.h"
+#if wxUSE_NOTEBOOK
+

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

-#include  "wx/dcclient.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/string.h"
+    #include "wx/log.h"
+    #include  "wx/dcclient.h"
+    #include  "wx/settings.h"
+#endif
+
+#include  "wx/imaglist.h"
+#include  "wx/generic/tabg.h"

 
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 
 // check that the page index is valid
 
 // ----------------------------------------------------------------------------
 // macros
 // ----------------------------------------------------------------------------
 
 // check that the page index is valid

-#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))
+#define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount())

 
 // ----------------------------------------------------------------------------
 // event table
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // event table
 // ----------------------------------------------------------------------------
 

-#if !USE_SHARED_LIBRARIES
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
+

 BEGIN_EVENT_TABLE(wxNotebook, wxControl)
 BEGIN_EVENT_TABLE(wxNotebook, wxControl)

-    EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
+    EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, wxNotebook::OnSelChange)

     EVT_SIZE(wxNotebook::OnSize)
     EVT_PAINT(wxNotebook::OnPaint)
     EVT_MOUSE_EVENTS(wxNotebook::OnMouseEvent)
     EVT_SET_FOCUS(wxNotebook::OnSetFocus)
     EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
     EVT_SIZE(wxNotebook::OnSize)
     EVT_PAINT(wxNotebook::OnPaint)
     EVT_MOUSE_EVENTS(wxNotebook::OnMouseEvent)
     EVT_SET_FOCUS(wxNotebook::OnSetFocus)
     EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)

-//    EVT_IDLE(wxNotebook::OnIdle)

 END_EVENT_TABLE()
 
 IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
 END_EVENT_TABLE()
 
 IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)

-#endif

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

+// ============================================================================
+// Private class
+// ============================================================================
+
+WX_DECLARE_HASH_MAP(int, wxNotebookPage*, wxIntegerHash, wxIntegerEqual,
+                    wxIntToNotebookPageHashMap);
+
+WX_DECLARE_HASH_MAP(wxNotebookPage*, int, wxPointerHash, wxPointerEqual,
+                    wxNotebookPageToIntHashMap);
+
+// This reuses wxTabView to draw the tabs.
+class WXDLLEXPORT wxNotebookTabView: public wxTabView
+{
+DECLARE_DYNAMIC_CLASS(wxNotebookTabView)
+public:
+    wxNotebookTabView(wxNotebook* notebook, long style = wxTAB_STYLE_DRAW_BOX | wxTAB_STYLE_COLOUR_INTERIOR);
+    virtual ~wxNotebookTabView(void);
+
+    // Called when a tab is activated
+    virtual void OnTabActivate(int activateId, int deactivateId);
+    // Allows vetoing
+    virtual bool OnTabPreActivate(int activateId, int deactivateId);
+
+    // map integer ids used by wxTabView to wxNotebookPage pointers
+    int GetId(wxNotebookPage *page);
+    wxNotebookPage *GetPage(int id) { return m_idToPage[id]; }
+
+protected:
+    wxNotebook* m_notebook;
+
+private:
+    wxIntToNotebookPageHashMap m_idToPage;
+    wxNotebookPageToIntHashMap m_pageToId;
+    int m_nextid;
+};
+
+static int GetPageId(wxTabView *tabview, wxNotebookPage *page)
+{
+    return wx_static_cast(wxNotebookTabView*, tabview)->GetId(page);
+}
+

 // ----------------------------------------------------------------------------
 // wxNotebook construction
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxNotebook construction
 // ----------------------------------------------------------------------------


@@ -72,7 +117,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
 void wxNotebook::Init()
 {
     m_tabView = (wxNotebookTabView*) NULL;
 void wxNotebook::Init()
 {
     m_tabView = (wxNotebookTabView*) NULL;

-    m_pImageList = NULL;

     m_nSelection = -1;
 }
 
     m_nSelection = -1;
 }
 


@@ -106,17 +150,19 @@ bool wxNotebook::Create(wxWindow *parent,
     // base init
     SetName(name);
 
     // base init
     SetName(name);
 

-    m_windowId = id == -1 ? NewControlId() : id;
+    if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT )
+        style |= wxBK_TOP;

 
 

-    // It's like a normal window...
-    if (!wxWindow::Create(parent, id, pos, size, style|wxNO_BORDER, name))
-        return FALSE;
+    m_windowId = id == wxID_ANY ? NewControlId() : id;

 
 

-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
+    if (!wxControl::Create(parent, id, pos, size, style|wxNO_BORDER, wxDefaultValidator, name))
+        return false;
+
+    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));

 
     SetTabView(new wxNotebookTabView(this));
 
 
     SetTabView(new wxNotebookTabView(this));
 

-    return TRUE;
+    return true;

 }
 
 // dtor
 }
 
 // dtor


@@ -128,35 +174,31 @@ wxNotebook::~wxNotebook()
 // ----------------------------------------------------------------------------
 // wxNotebook accessors
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxNotebook accessors
 // ----------------------------------------------------------------------------

-int wxNotebook::GetPageCount() const
-{
-    return m_aPages.Count();
-}
-

 int wxNotebook::GetRowCount() const
 {
     // TODO
     return 0;
 }
 
 int wxNotebook::GetRowCount() const
 {
     // TODO
     return 0;
 }
 

-int wxNotebook::SetSelection(int nPage)
+int wxNotebook::SetSelection(size_t nPage)

 {
 {

-    if (nPage == -1)
-      return 0;
-

     wxASSERT( IS_VALID_PAGE(nPage) );
 
     wxASSERT( IS_VALID_PAGE(nPage) );
 

-#if defined (__WIN16__)
-    m_tabView->SetTabSelection(nPage);
-#else

     wxNotebookPage* pPage = GetPage(nPage);
 
     wxNotebookPage* pPage = GetPage(nPage);
 

-    m_tabView->SetTabSelection((int) (long) pPage);
-#endif
+    m_tabView->SetTabSelection(GetPageId(m_tabView, pPage));
+

     // TODO
     return 0;
 }
 
     // TODO
     return 0;
 }
 

+int wxNotebook::ChangeSelection(size_t nPage)
+{
+    // FIXME: currently it does generate events too
+    return SetSelection(nPage);
+}
+
+#if 0

 void wxNotebook::AdvanceSelection(bool bForward)
 {
     int nSel = GetSelection();
 void wxNotebook::AdvanceSelection(bool bForward)
 {
     int nSel = GetSelection();


@@ -166,42 +208,35 @@ void wxNotebook::AdvanceSelection(bool bForward)
     else
         SetSelection(nSel == 0 ? nMax : nSel - 1);
 }
     else
         SetSelection(nSel == 0 ? nMax : nSel - 1);
 }

+#endif

 
 

-bool wxNotebook::SetPageText(int nPage, const wxString& strText)
+bool wxNotebook::SetPageText(size_t nPage, const wxString& strText)

 {
     wxASSERT( IS_VALID_PAGE(nPage) );
 {
     wxASSERT( IS_VALID_PAGE(nPage) );

-#if defined (__WIN16__)
-       m_tabView->SetTabText(nPage, strText);
-    Refresh();
-    return TRUE;
-#else
+

     wxNotebookPage* page = GetPage(nPage);
     if (page)
     {
     wxNotebookPage* page = GetPage(nPage);
     if (page)
     {

-        m_tabView->SetTabText((int) (long) page, strText);
+        m_tabView->SetTabText(GetPageId(m_tabView, page), strText);

         Refresh();
         Refresh();

-        return TRUE;
+        return true;

     }
     }

-#endif
-    return FALSE;
+
+    return false;

 }
 
 }
 

-wxString wxNotebook::GetPageText(int nPage) const
+wxString wxNotebook::GetPageText(size_t nPage) const

 {
     wxASSERT( IS_VALID_PAGE(nPage) );
 
 {
     wxASSERT( IS_VALID_PAGE(nPage) );
 

-#if defined (__WIN16__)
-    return m_tabView->GetTabText(nPage);
-#else

     wxNotebookPage* page = ((wxNotebook*)this)->GetPage(nPage);
     if (page)
     wxNotebookPage* page = ((wxNotebook*)this)->GetPage(nPage);
     if (page)

-        return m_tabView->GetTabText((int) (long) page);
+        return m_tabView->GetTabText(GetPageId(m_tabView, page));

     else
         return wxEmptyString;
     else
         return wxEmptyString;

-#endif

 }
 
 }
 

-int wxNotebook::GetPageImage(int nPage) const
+int wxNotebook::GetPageImage(size_t WXUNUSED_UNLESS_DEBUG(nPage)) const

 {
     wxASSERT( IS_VALID_PAGE(nPage) );
 
 {
     wxASSERT( IS_VALID_PAGE(nPage) );
 


@@ -209,17 +244,30 @@ int wxNotebook::GetPageImage(int nPage) const
     return 0;
 }
 
     return 0;
 }
 

-bool wxNotebook::SetPageImage(int nPage, int nImage)
+bool wxNotebook::SetPageImage(size_t WXUNUSED_UNLESS_DEBUG(nPage),
+                              int WXUNUSED(nImage))

 {
     wxASSERT( IS_VALID_PAGE(nPage) );
 
     // TODO
 {
     wxASSERT( IS_VALID_PAGE(nPage) );
 
     // TODO

-    return FALSE;
+    return false;
+}
+
+// set the size (the same for all pages)
+void wxNotebook::SetPageSize(const wxSize& WXUNUSED(size))
+{
+    // TODO
+}
+
+// set the padding between tabs (in pixels)
+void wxNotebook::SetPadding(const wxSize& WXUNUSED(padding))
+{
+    // TODO

 }
 
 }
 

-void wxNotebook::SetImageList(wxImageList* imageList)
-{ 
-    m_pImageList = imageList;
+// set the size of the tabs for wxNB_FIXEDWIDTH controls
+void wxNotebook::SetTabSize(const wxSize& WXUNUSED(sz))
+{

     // TODO
 }
 
     // TODO
 }
 


@@ -228,46 +276,41 @@ void wxNotebook::SetImageList(wxImageList* imageList)
 // ----------------------------------------------------------------------------
 
 // remove one page from the notebook and delete it
 // ----------------------------------------------------------------------------
 
 // remove one page from the notebook and delete it

-bool wxNotebook::DeletePage(int nPage)
+bool wxNotebook::DeletePage(size_t nPage)

 {
 {

-    wxCHECK( IS_VALID_PAGE(nPage), FALSE );
+    wxCHECK( IS_VALID_PAGE(nPage), false );

 
     if (m_nSelection != -1)
     {
 
     if (m_nSelection != -1)
     {

-        m_aPages[m_nSelection]->Show(FALSE);
-        m_aPages[m_nSelection]->Lower();
+        m_pages[m_nSelection]->Show(false);
+        m_pages[m_nSelection]->Lower();

     }
 
     wxNotebookPage* pPage = GetPage(nPage);
     }
 
     wxNotebookPage* pPage = GetPage(nPage);

-#if defined (__WIN16__)
-    m_tabView->RemoveTab(nPage);
-#else
-    m_tabView->RemoveTab((int) (long) pPage);
-#endif

 
 

-    delete m_aPages[nPage];
-    m_aPages.Remove(nPage);
+    m_tabView->RemoveTab(GetPageId(m_tabView, pPage));
+
+    m_pages.Remove(pPage);
+    delete pPage;

 
 

-    if (m_aPages.GetCount() == 0)
+    if (m_pages.GetCount() == 0)

     {
     {

-      m_nSelection = -1;
-      m_tabView->SetTabSelection(-1, FALSE);
+        m_nSelection = -1;
+        m_tabView->SetTabSelection(-1, false);

     }
     else if (m_nSelection > -1)
     {
     }
     else if (m_nSelection > -1)
     {

-      m_nSelection = -1;
-#if defined (__WIN16__)
-      m_tabView->SetTabSelection(0, FALSE);
-#else
-      m_tabView->SetTabSelection((int) (long) GetPage(0), FALSE);
-#endif
-      if (m_nSelection != 0)
-        ChangePage(-1, 0);
+        m_nSelection = -1;
+
+        m_tabView->SetTabSelection(GetPageId(m_tabView, GetPage(0)), false);
+
+        if (m_nSelection != 0)
+            ChangePage(-1, 0);

     }
 
     }
 

-    RefreshLayout(FALSE);
+    RefreshLayout(false);

 
 

-    return TRUE;
+    return true;

 }
 
 bool wxNotebook::DeletePage(wxNotebookPage* page)
 }
 
 bool wxNotebook::DeletePage(wxNotebookPage* page)


@@ -276,54 +319,56 @@ bool wxNotebook::DeletePage(wxNotebookPage* page)
     if (pagePos > -1)
         return DeletePage(pagePos);
     else
     if (pagePos > -1)
         return DeletePage(pagePos);
     else

-        return FALSE;
+        return false;
+}
+
+bool wxNotebook::RemovePage(size_t nPage)
+{
+    return DoRemovePage(nPage) != NULL;

 }
 
 // remove one page from the notebook
 }
 
 // remove one page from the notebook

-bool wxNotebook::RemovePage(int nPage)
+wxWindow* wxNotebook::DoRemovePage(size_t nPage)

 {
 {

-    wxCHECK( IS_VALID_PAGE(nPage), FALSE );
+    wxCHECK( IS_VALID_PAGE(nPage), NULL );

 
 

-    m_aPages[nPage]->Show(FALSE);
-    //    m_aPages[nPage]->Lower();
+    m_pages[nPage]->Show(false);
+    //    m_pages[nPage]->Lower();

 
     wxNotebookPage* pPage = GetPage(nPage);
 
     wxNotebookPage* pPage = GetPage(nPage);

-#if defined (__WIN16__)
-    m_tabView->RemoveTab(nPage);
-#else
-    m_tabView->RemoveTab((int) (long) pPage);
-#endif

 
 

-    m_aPages.Remove(nPage);
+    m_tabView->RemoveTab(GetPageId(m_tabView, pPage));

 
 

-    if (m_aPages.GetCount() == 0)
+    m_pages.Remove(pPage);
+
+    if (m_pages.GetCount() == 0)

     {
       m_nSelection = -1;
     {
       m_nSelection = -1;

-      m_tabView->SetTabSelection(-1, TRUE);
+      m_tabView->SetTabSelection(-1, true);

     }
     else if (m_nSelection > -1)
     {
       // Only change the selection if the page we
       // deleted was the selection.
     }
     else if (m_nSelection > -1)
     {
       // Only change the selection if the page we
       // deleted was the selection.

-      if (nPage == m_nSelection)
+      if (nPage == (size_t)m_nSelection)

       {
          m_nSelection = -1;
          // Select the first tab. Generates a ChangePage.
       {
          m_nSelection = -1;
          // Select the first tab. Generates a ChangePage.

-         m_tabView->SetTabSelection((int) (long) GetPage(0), TRUE);
+         m_tabView->SetTabSelection(0, true);

       }
       else
       {
       }
       else
       {

-       // We must adjust which tab we think is selected.
+        // We must adjust which tab we think is selected.

         // If greater than the page we deleted, it must be moved down
         // a notch.
         // If greater than the page we deleted, it must be moved down
         // a notch.

-        if (m_nSelection > nPage)
+        if (size_t(m_nSelection) > nPage)

           m_nSelection -- ;
       }
     }
 
           m_nSelection -- ;
       }
     }
 

-    RefreshLayout(FALSE);
+    RefreshLayout(false);

 
 

-    return TRUE;
+    return pPage;

 }
 
 bool wxNotebook::RemovePage(wxNotebookPage* page)
 }
 
 bool wxNotebook::RemovePage(wxNotebookPage* page)


@@ -332,16 +377,16 @@ bool wxNotebook::RemovePage(wxNotebookPage* page)
     if (pagePos > -1)
         return RemovePage(pagePos);
     else
     if (pagePos > -1)
         return RemovePage(pagePos);
     else

-        return FALSE;
+        return false;

 }
 
 // Find the position of the wxNotebookPage, -1 if not found.
 int wxNotebook::FindPagePosition(wxNotebookPage* page) const
 {
 }
 
 // Find the position of the wxNotebookPage, -1 if not found.
 int wxNotebook::FindPagePosition(wxNotebookPage* page) const
 {

-    int nPageCount = GetPageCount();
-    int nPage;
+    size_t nPageCount = GetPageCount();
+    size_t nPage;

     for ( nPage = 0; nPage < nPageCount; nPage++ )
     for ( nPage = 0; nPage < nPageCount; nPage++ )

-        if (m_aPages[nPage] == page)
+        if (m_pages[nPage] == page)

             return nPage;
     return -1;
 }
             return nPage;
     return -1;
 }


@@ -349,57 +394,41 @@ int wxNotebook::FindPagePosition(wxNotebookPage* page) const
 // remove all pages
 bool wxNotebook::DeleteAllPages()
 {
 // remove all pages
 bool wxNotebook::DeleteAllPages()
 {

-    m_tabView->ClearTabs(TRUE);
+    m_tabView->ClearTabs(true);

 
 

-    int nPageCount = GetPageCount();
-    int nPage;
+    size_t nPageCount = GetPageCount();
+    size_t nPage;

     for ( nPage = 0; nPage < nPageCount; nPage++ )
     for ( nPage = 0; nPage < nPageCount; nPage++ )

-        delete m_aPages[nPage];
-
-    m_aPages.Clear();
+        delete m_pages[nPage];

 
 

-    return TRUE;
-}
+    m_pages.Clear();

 
 

-// add a page to the notebook
-bool wxNotebook::AddPage(wxNotebookPage *pPage,
-                         const wxString& strText,
-                         bool bSelect,
-                         int imageId)
-{
-    return InsertPage(GetPageCount(), pPage, strText, bSelect, imageId);
+    return true;

 }
 
 // same as AddPage() but does it at given position
 }
 
 // same as AddPage() but does it at given position

-bool wxNotebook::InsertPage(int nPage,
+bool wxNotebook::InsertPage(size_t nPage,

                             wxNotebookPage *pPage,
                             const wxString& strText,
                             bool bSelect,
                             wxNotebookPage *pPage,
                             const wxString& strText,
                             bool bSelect,

-                            int imageId)
+                            int WXUNUSED(imageId))

 {
     wxASSERT( pPage != NULL );
 {
     wxASSERT( pPage != NULL );

-    wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), FALSE );
+    wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false );
+
+    m_tabView->AddTab(GetPageId(m_tabView, pPage), strText);

 
 

-// For 16 bit integers (tabs limited to 32768)
-#if defined (__WIN16__)
-    m_tabView->AddTab(nPage, strText);
-#else
-    m_tabView->AddTab((int) (long) pPage, strText);
-#endif

     if (!bSelect)
     if (!bSelect)

-      pPage->Show(FALSE);
+      pPage->Show(false);

 
     // save the pointer to the page
 
     // save the pointer to the page

-    m_aPages.Insert(pPage, nPage);
+    m_pages.Insert(pPage, nPage);

 
     if (bSelect)
     {
         // This will cause ChangePage to be called, via OnSelPage
 
     if (bSelect)
     {
         // This will cause ChangePage to be called, via OnSelPage

-#if defined (__WIN16__)
-        m_tabView->SetTabSelection(nPage, TRUE);
-#else
-        m_tabView->SetTabSelection((int) (long) pPage, TRUE);
-#endif
+
+        m_tabView->SetTabSelection(GetPageId(m_tabView, pPage), true);

     }
 
     // some page must be selected: either this one or the first one if there is
     }
 
     // some page must be selected: either this one or the first one if there is


@@ -407,9 +436,9 @@ bool wxNotebook::InsertPage(int nPage,
     if ( m_nSelection == -1 )
       ChangePage(-1, 0);
 
     if ( m_nSelection == -1 )
       ChangePage(-1, 0);
 

-    RefreshLayout(FALSE);
+    RefreshLayout(false);

 
 

-    return TRUE;
+    return true;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -420,10 +449,10 @@ bool wxNotebook::InsertPage(int nPage,
 //     time because doing it in ::Create() doesn't work (for unknown reasons)
 void wxNotebook::OnSize(wxSizeEvent& event)
 {
 //     time because doing it in ::Create() doesn't work (for unknown reasons)
 void wxNotebook::OnSize(wxSizeEvent& event)
 {

-    static bool s_bFirstTime = TRUE;
+    static bool s_bFirstTime = true;

     if ( s_bFirstTime ) {
         // TODO: any first-time-size processing.
     if ( s_bFirstTime ) {
         // TODO: any first-time-size processing.

-        s_bFirstTime = FALSE;
+        s_bFirstTime = false;

     }
 
     RefreshLayout();
     }
 
     RefreshLayout();


@@ -435,9 +464,12 @@ void wxNotebook::OnSize(wxSizeEvent& event)
 // This was supposed to cure the non-display of the notebook
 // until the user resizes the window.
 // What's going on?
 // This was supposed to cure the non-display of the notebook
 // until the user resizes the window.
 // What's going on?

-void wxNotebook::OnIdle(wxIdleEvent& event)
+void wxNotebook::OnInternalIdle()

 {
 {

-    static bool s_bFirstTime = TRUE;
+    wxWindow::OnInternalIdle();
+
+#if 0
+    static bool s_bFirstTime = true;

     if ( s_bFirstTime ) {
       /*
       wxSize sz(GetSize());
     if ( s_bFirstTime ) {
       /*
       wxSize sz(GetSize());


@@ -454,9 +486,9 @@ void wxNotebook::OnIdle(wxIdleEvent& event)
       GetEventHandler()->ProcessEvent(sizeEvent);
       Refresh();
       */
       GetEventHandler()->ProcessEvent(sizeEvent);
       Refresh();
       */

-      s_bFirstTime = FALSE;
+      s_bFirstTime = false;

     }
     }

-    event.Skip();
+#endif

 }
 
 // Implementation: calculate the layout of the view rect
 }
 
 // Implementation: calculate the layout of the view rect


@@ -476,7 +508,7 @@ bool wxNotebook::RefreshLayout(bool force)
         rect.y = tabHeight + 4;
         rect.width = cw - 8;
         rect.height = ch - 4 - rect.y ;
         rect.y = tabHeight + 4;
         rect.width = cw - 8;
         rect.height = ch - 4 - rect.y ;

-  
+

         m_tabView->SetViewRect(rect);
 
         m_tabView->LayoutTabs();
         m_tabView->SetViewRect(rect);
 
         m_tabView->LayoutTabs();


@@ -489,22 +521,22 @@ bool wxNotebook::RefreshLayout(bool force)
         rect.y = tabHeight + 4;
         rect.width = cw - 8;
         rect.height = ch - 4 - rect.y ;
         rect.y = tabHeight + 4;
         rect.width = cw - 8;
         rect.height = ch - 4 - rect.y ;

-  
+

         m_tabView->SetViewRect(rect);
 
         m_tabView->LayoutTabs();
 
         if (!force && (rect == oldRect))
         m_tabView->SetViewRect(rect);
 
         m_tabView->LayoutTabs();
 
         if (!force && (rect == oldRect))

-          return FALSE;
+          return false;

 
         // fit the notebook page to the tab control's display area
 
 
         // fit the notebook page to the tab control's display area
 

-        unsigned int nCount = m_aPages.Count();
-        for ( unsigned int nPage = 0; nPage < nCount; nPage++ ) {
-            wxNotebookPage *pPage = m_aPages[nPage];
+        size_t nCount = m_pages.Count();
+        for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
+            wxNotebookPage *pPage = m_pages[nPage];
+            wxRect clientRect = GetAvailableClientSize();

             if (pPage->IsShown())
             {
             if (pPage->IsShown())
             {

-                wxRect clientRect = GetAvailableClientSize();

                 pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);
                 if ( pPage->GetAutoLayout() )
                    pPage->Layout();
                 pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);
                 if ( pPage->GetAutoLayout() )
                    pPage->Layout();


@@ -512,7 +544,7 @@ bool wxNotebook::RefreshLayout(bool force)
         }
         Refresh();
     }
         }
         Refresh();
     }

-    return TRUE;
+    return true;

 }
 
 void wxNotebook::OnSelChange(wxNotebookEvent& event)
 }
 
 void wxNotebook::OnSelChange(wxNotebookEvent& event)


@@ -532,7 +564,7 @@ void wxNotebook::OnSetFocus(wxFocusEvent& event)
 {
     // set focus to the currently selected page if any
     if ( m_nSelection != -1 )
 {
     // set focus to the currently selected page if any
     if ( m_nSelection != -1 )

-        m_aPages[m_nSelection]->SetFocus();
+        m_pages[m_nSelection]->SetFocus();

 
     event.Skip();
 }
 
     event.Skip();
 }


@@ -561,17 +593,17 @@ void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
 void wxNotebook::SetConstraintSizes(bool /* recurse */)
 {
     // don't set the sizes of the pages - their correct size is not yet known
 void wxNotebook::SetConstraintSizes(bool /* recurse */)
 {
     // don't set the sizes of the pages - their correct size is not yet known

-    wxControl::SetConstraintSizes(FALSE);
+    wxControl::SetConstraintSizes(false);

 }
 
 bool wxNotebook::DoPhase(int /* nPhase */)
 {
 }
 
 bool wxNotebook::DoPhase(int /* nPhase */)
 {

-    return TRUE;
+    return true;

 }
 
 }
 

-void wxNotebook::Command(wxCommandEvent& event)
+void wxNotebook::Command(wxCommandEvent& WXUNUSED(event))

 {
 {

-    wxFAIL_MSG("wxNotebook::Command not implemented");
+    wxFAIL_MSG(wxT("wxNotebook::Command not implemented"));

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -585,21 +617,21 @@ void wxNotebook::ChangePage(int nOldSel, int nSel)
     wxASSERT( nOldSel != nSel ); // impossible
 
     if ( nOldSel != -1 ) {
     wxASSERT( nOldSel != nSel ); // impossible
 
     if ( nOldSel != -1 ) {

-        m_aPages[nOldSel]->Show(FALSE);
-        m_aPages[nOldSel]->Lower();
+        m_pages[nOldSel]->Show(false);
+        m_pages[nOldSel]->Lower();

     }
 
     }
 

-    wxNotebookPage *pPage = m_aPages[nSel];
+    wxNotebookPage *pPage = m_pages[nSel];

 
     wxRect clientRect = GetAvailableClientSize();
     pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);
 
 
     wxRect clientRect = GetAvailableClientSize();
     pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);
 

-    pPage->Show(TRUE);
+    Refresh();
+
+    pPage->Show(true);

     pPage->Raise();
     pPage->SetFocus();
 
     pPage->Raise();
     pPage->SetFocus();
 

-    Refresh();
-

     m_nSelection = nSel;
 }
 
     m_nSelection = nSel;
 }
 


@@ -616,6 +648,17 @@ void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event) )
         m_tabView->Draw(dc);
 }
 
         m_tabView->Draw(dc);
 }
 

+wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
+{
+    // MBN: since the total tab height is really a function of the
+    // width, this should really call
+    // GetTotalTabHeightPretendingWidthIs(), but the current
+    // implementation will suffice, provided the wxNotebook has been
+    // created with a sensible initial width.
+    return wxSize( sizePage.x + 12,
+                   sizePage.y + m_tabView->GetTotalTabHeight() + 6 + 4 );
+}
+

 wxRect wxNotebook::GetAvailableClientSize()
 {
     int cw, ch;
 wxRect wxNotebook::GetAvailableClientSize()
 {
     int cw, ch;


@@ -636,10 +679,11 @@ wxRect wxNotebook::GetAvailableClientSize()
 /*
  * wxNotebookTabView
  */
 /*
  * wxNotebookTabView
  */

- 
+

 IMPLEMENT_CLASS(wxNotebookTabView, wxTabView)
 
 IMPLEMENT_CLASS(wxNotebookTabView, wxTabView)
 

-wxNotebookTabView::wxNotebookTabView(wxNotebook *notebook, long style): wxTabView(style)
+wxNotebookTabView::wxNotebookTabView(wxNotebook *notebook, long style)
+    : wxTabView(style), m_nextid(1)

 {
   m_notebook = notebook;
 
 {
   m_notebook = notebook;
 


@@ -652,36 +696,67 @@ wxNotebookTabView::~wxNotebookTabView(void)
 {
 }
 
 {
 }
 

+int wxNotebookTabView::GetId(wxNotebookPage *page)
+{
+    int& id = m_pageToId[page];
+
+    if (!id)
+    {
+        id = m_nextid++;
+        m_idToPage[id] = page;
+    }
+
+    return id;
+}
+

 // Called when a tab is activated
 void wxNotebookTabView::OnTabActivate(int activateId, int deactivateId)
 {
   if (!m_notebook)
     return;
 
 // Called when a tab is activated
 void wxNotebookTabView::OnTabActivate(int activateId, int deactivateId)
 {
   if (!m_notebook)
     return;
 

-// Because of name truncation!
-#if defined(__BORLANDC__) && defined(__WIN16__)
-  wxNotebookEvent event(wxEVT_COMMAND_NB_PAGE_CHANGED, m_notebook->GetId());
-#else

   wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_notebook->GetId());
   wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_notebook->GetId());

-#endif

 
 

-#if defined (__WIN16__)
-  int activatePos = activateId;
-  int deactivatePos = deactivateId;
-#else

   // Translate from wxTabView's ids (which aren't position-dependent)
   // to wxNotebook's (which are).
   // Translate from wxTabView's ids (which aren't position-dependent)
   // to wxNotebook's (which are).

-  wxNotebookPage* pActive = (wxNotebookPage*) activateId;
-  wxNotebookPage* pDeactive = (wxNotebookPage*) deactivateId;
+  wxNotebookPage* pActive = GetPage(activateId);
+  wxNotebookPage* pDeactive = GetPage(deactivateId);

 
   int activatePos = m_notebook->FindPagePosition(pActive);
   int deactivatePos = m_notebook->FindPagePosition(pDeactive);
 
 
   int activatePos = m_notebook->FindPagePosition(pActive);
   int deactivatePos = m_notebook->FindPagePosition(pDeactive);
 

-#endif

   event.SetEventObject(m_notebook);
   event.SetSelection(activatePos);
   event.SetOldSelection(deactivatePos);
   m_notebook->GetEventHandler()->ProcessEvent(event);
 }
 
   event.SetEventObject(m_notebook);
   event.SetSelection(activatePos);
   event.SetOldSelection(deactivatePos);
   m_notebook->GetEventHandler()->ProcessEvent(event);
 }
 

+// Allows Vetoing
+bool wxNotebookTabView::OnTabPreActivate(int activateId, int deactivateId)
+{
+  bool retval = true;
+
+  if (m_notebook)
+  {
+    wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_notebook->GetId());
+
+    // Translate from wxTabView's ids (which aren't position-dependent)
+    // to wxNotebook's (which are).
+    wxNotebookPage* pActive = GetPage(activateId);
+    wxNotebookPage* pDeactive = GetPage(deactivateId);
+
+    int activatePos = m_notebook->FindPagePosition(pActive);
+    int deactivatePos = m_notebook->FindPagePosition(pDeactive);
+
+    event.SetEventObject(m_notebook);
+    event.SetSelection(activatePos);
+    event.SetOldSelection(deactivatePos);
+    if (m_notebook->GetEventHandler()->ProcessEvent(event))
+    {
+      retval = event.IsAllowed();
+    }
+  }
+  return retval;
+}

 
 

+#endif // wxUSE_NOTEBOOK