]> git.saurik.com Git - wxWidgets.git/blobdiff - demos/dbbrowse/tabpgwin.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
don't steal EVT_RIGHT_UP in rich edit controls for context menu (patch 1143823)
[wxWidgets.git] / demos / dbbrowse / tabpgwin.cpp
diff --git a/demos/dbbrowse/tabpgwin.cpp b/demos/dbbrowse/tabpgwin.cpp
index f0c4ac9970e2fbef74fc4354dc33240e26c897d4..dfd222cac74c4ee8dd8801f9ce61159167039324 100644 (file)
--- a/demos/dbbrowse/tabpgwin.cpp
+++ b/demos/dbbrowse/tabpgwin.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        No names yet.
+// Name:        tabpgwin.cpp
 // Purpose:     Contrib. demo
 // Author:      Aleksandras Gluchovas
 // Modified by: 19990908 : mj
 // Purpose:     Contrib. demo
 // Author:      Aleksandras Gluchovas
 // Modified by: 19990908 : mj
@@ -7,9 +7,9 @@
 //              - restruction of Variable declaration
 //              - to prevent Warnings under MingW32
 // Modified by: 19990909 : mj
 //              - restruction of Variable declaration
 //              - to prevent Warnings under MingW32
 // Modified by: 19990909 : mj
-//              - mNoVertScroll TRUE = no / FALSE = Original Code
+//              - mNoVertScroll true = no / false = Original Code
 //                the Original Code Paints a Vertical Scroll in wxPagedWindow
 //                the Original Code Paints a Vertical Scroll in wxPagedWindow
-//                which is not needed in this Version. Use TRUE for this.
+//                which is not needed in this Version. Use true for this.
 // Created:     07/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Aleksandras Gluchovas
 // Created:     07/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Aleksandras Gluchovas
@@ -18,7 +18,7 @@
 
 #ifdef __GNUG__
 #pragma implementation
 
 #ifdef __GNUG__
 #pragma implementation
-// #pragma interface
+//#pragma interface
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
@@ -32,7 +32,8 @@
 #include "wx/wx.h"
 #endif
 
 #include "wx/wx.h"
 #endif
 
-#include <math.h>
+#include "wx/math.h"
+
 #include <stdlib.h>
 
 #include "wx/string.h"
 #include <stdlib.h>
 
 #include "wx/string.h"
@@ -50,12 +51,6 @@ twTabInfo::twTabInfo()
 : mpContent( 0 )
 {}
 
 : mpContent( 0 )
 {}
 
-//---------------------------------------------------------------------------
-twTabInfo::~twTabInfo()
-{
-    // FOR NOW:: nothing
-}
-
 //---------------------------------------------------------------------------
 int twTabInfo::ImgWidth()
 {
 //---------------------------------------------------------------------------
 int twTabInfo::ImgWidth()
 {
@@ -157,72 +152,72 @@ wxTabbedWindow::wxTabbedWindow()
 //---------------------------------------------------------------------------
 wxTabbedWindow::~wxTabbedWindow()
 {
 //---------------------------------------------------------------------------
 wxTabbedWindow::~wxTabbedWindow()
 {
-    wxNode* pTab = mTabs.First();
-    
+    wxObjectList::compatibility_iterator pTab = mTabs.GetFirst();
+
     while( pTab )
     {
     while( pTab )
     {
-        delete ((twTabInfo*)pTab->Data());
-        pTab = pTab->Next();
+        delete ((twTabInfo*)pTab->GetData());
+        pTab = pTab->GetNext();
     }
 }
 
 //---------------------------------------------------------------------------
     }
 }
 
 //---------------------------------------------------------------------------
-void wxTabbedWindow::SizeTabs(int x,int y, int width, int height, bool repant)
+void wxTabbedWindow::SizeTabs(int x,int y, int width, int height, bool WXUNUSED(repant))
 {
 {
-    wxNode* pTabNode = mTabs.First();
-    int n = 0;
-    
+    wxObjectList::compatibility_iterator pTabNode = mTabs.GetFirst();
+    size_t n = 0;
+
     while( pTabNode )
     {
     while( pTabNode )
     {
-        twTabInfo& info = *((twTabInfo*)pTabNode->Data());
-        
+        twTabInfo& info = *((twTabInfo*)pTabNode->GetData());
+
         if ( n == mActiveTab )
         {
             //wxSizeEvent evt;
             //info.mpContent->GetEventHandler()->ProcessEvent( evt );
         if ( n == mActiveTab )
         {
             //wxSizeEvent evt;
             //info.mpContent->GetEventHandler()->ProcessEvent( evt );
-            
+
             info.mpContent->SetSize( x, y, width, height, 0 );
             info.mpContent->SetSize( x, y, width, height, 0 );
-            info.mpContent->Show(TRUE);
+            info.mpContent->Show(true);
             info.mpContent->Refresh();
             info.mpContent->Refresh();
-            
+
         }
         else
         {
         }
         else
         {
-            info.mpContent->Show(FALSE);
+            info.mpContent->Show(false);
         }
         }
-        
-        pTabNode = pTabNode->Next();
+
+        pTabNode = pTabNode->GetNext();
         ++n;
     }
 }
 
 //---------------------------------------------------------------------------
         ++n;
     }
 }
 
 //---------------------------------------------------------------------------
-void wxTabbedWindow::AddTab( wxWindow* pContent,
-                            wxString  tabText,
-                            wxString  imageFileName,
-                            long      imageType )
+void wxTabbedWindow::AddTab( wxWindow*   pContent,
+                            wxString     tabText,
+                            wxString     imageFileName,
+                            wxBitmapType imageType )
 {
     twTabInfo* pTab = new twTabInfo();
 {
     twTabInfo* pTab = new twTabInfo();
-    
+
     pTab->mpContent = pContent;
     pTab->mText     = tabText;
     pTab->mpContent = pContent;
     pTab->mText     = tabText;
-    
+
     if ( wxFileExists( imageFileName ) &&
     if ( wxFileExists( imageFileName ) &&
-        
+
         pTab->mBitMap.LoadFile( imageFileName, imageType ) )
     {
         pTab->mImageFile = imageFileName;
         pTab->mImageType = imageType;
     }
         pTab->mBitMap.LoadFile( imageFileName, imageType ) )
     {
         pTab->mImageFile = imageFileName;
         pTab->mImageType = imageType;
     }
-    
-    
+
+
     if ( pContent->GetParent() == NULL )
     if ( pContent->GetParent() == NULL )
-        pContent->Create( this, -1 );
-    
+        pContent->Create( this, wxID_ANY );
+
     mTabs.Append( (wxObject*)pTab );
     mTabs.Append( (wxObject*)pTab );
-    
-    RecalcLayout(TRUE);
-    
+
+    RecalcLayout(true);
+
     OnTabAdded( pTab );
 }
 
     OnTabAdded( pTab );
 }
 
@@ -231,44 +226,44 @@ void wxTabbedWindow::AddTab( wxWindow* pContent,
                             wxString  tabText, wxBitmap* pImage   )
 {
     twTabInfo* pTab = new twTabInfo();
                             wxString  tabText, wxBitmap* pImage   )
 {
     twTabInfo* pTab = new twTabInfo();
-    
+
     pTab->mpContent = pContent;
     pTab->mText     = tabText;
     pTab->mpContent = pContent;
     pTab->mText     = tabText;
-    
+
     if ( pImage )
         pTab->mBitMap = *pImage;
     if ( pImage )
         pTab->mBitMap = *pImage;
-    
+
     if ( pContent->GetParent() == NULL )
     if ( pContent->GetParent() == NULL )
-        pContent->Create( this, -1 );
-    
+        pContent->Create( this, wxID_ANY );
+
     mTabs.Append( (wxObject*)pTab );
     mTabs.Append( (wxObject*)pTab );
-    RecalcLayout(TRUE);
+    RecalcLayout(true);
     OnTabAdded( pTab );
 }
 
 //---------------------------------------------------------------------------
 void wxTabbedWindow::RemoveTab( int tabNo )
 {
     OnTabAdded( pTab );
 }
 
 //---------------------------------------------------------------------------
 void wxTabbedWindow::RemoveTab( int tabNo )
 {
-    twTabInfo* pTab = ((twTabInfo*)(mTabs.Nth( tabNo )->Data()));
+    twTabInfo* pTab = ((twTabInfo*)(mTabs.Item( tabNo )->GetData()));
     pTab->mpContent->Destroy();
     delete pTab;
     pTab->mpContent->Destroy();
     delete pTab;
-    mTabs.DeleteNode( mTabs.Nth( tabNo ) );
-    // if ( mActiveTab >= mTabs.Number() );
-    if ( mActiveTab >= mTabs.Number() )
-        mActiveTab = mTabs.Number() - 1;
+    mTabs.Erase( mTabs.Item( tabNo ) );
+    // if ( mActiveTab >= mTabs.GetCount() );
+    if ( mActiveTab >= mTabs.GetCount() )
+        mActiveTab = mTabs.GetCount() - 1;
     SetActiveTab( mActiveTab );
 }
 
 //---------------------------------------------------------------------------
 int wxTabbedWindow::GetTabCount()
 {
     SetActiveTab( mActiveTab );
 }
 
 //---------------------------------------------------------------------------
 int wxTabbedWindow::GetTabCount()
 {
-    return mTabs.Number();
+    return mTabs.GetCount();
 }
 
 //---------------------------------------------------------------------------
 wxWindow* wxTabbedWindow::GetTab( int tabNo )
 {
 }
 
 //---------------------------------------------------------------------------
 wxWindow* wxTabbedWindow::GetTab( int tabNo )
 {
-    return ((twTabInfo*)(mTabs.Nth( tabNo )->Data()))->mpContent;
+    return ((twTabInfo*)(mTabs.Item( tabNo )->GetData()))->mpContent;
 }
 
 //---------------------------------------------------------------------------
 }
 
 //---------------------------------------------------------------------------
@@ -282,7 +277,7 @@ wxWindow* wxTabbedWindow::GetActiveTab()
 void wxTabbedWindow::SetActiveTab( int tabNo )
 {
     mActiveTab = tabNo;
 void wxTabbedWindow::SetActiveTab( int tabNo )
 {
     mActiveTab = tabNo;
-    RecalcLayout(TRUE);
+    RecalcLayout(true);
     Refresh();
 }
 
     Refresh();
 }
 
@@ -297,13 +292,13 @@ void wxTabbedWindow::DrawShadedRect( int x, int y, int width, int height,
                                     )
 {
     // darw the lightened upper-left sides of the rectangle
                                     )
 {
     // darw the lightened upper-left sides of the rectangle
-    
+
     dc.SetPen( upperPen );
     dc.DrawLine( x,y, x, y + height - 1 ); // vert
     dc.DrawLine( x,y, x + width - 1,  y ); // horiz
     dc.SetPen( upperPen );
     dc.DrawLine( x,y, x, y + height - 1 ); // vert
     dc.DrawLine( x,y, x + width - 1,  y ); // horiz
-    
+
     // draw the unenlightened lower-right sides of the rectangle
     // draw the unenlightened lower-right sides of the rectangle
-    
+
     dc.SetPen( lowerPen );
     dc.DrawLine( x + width - 1,  y, x + width - 1, y + height - 1 ); // vert
     dc.DrawLine( x, y + height - 1, x + width, y + height - 1 );     // horiz
     dc.SetPen( lowerPen );
     dc.DrawLine( x + width - 1,  y, x + width - 1, y + height - 1 ); // vert
     dc.DrawLine( x, y + height - 1, x + width, y + height - 1 );     // horiz
@@ -316,79 +311,79 @@ void wxTabbedWindow::DrawDecorations( wxDC& dc )
     //                     but not including the point specified by last position.
     //                     This way Windows draws lines, not sure how Motif and Gtk
     //                     prots behave...
     //                     but not including the point specified by last position.
     //                     This way Windows draws lines, not sure how Motif and Gtk
     //                     prots behave...
-    
+
     int width, height;
     GetClientSize( &width, &height );
     int width, height;
     GetClientSize( &width, &height );
-    
+
     // check if there's at least a bit of space to draw things
     // check if there's at least a bit of space to draw things
-    
+
     if ( width  < mHorizGap*2 + BORDER_SZ*2+1 ||
         height < mVertGap*2  + BORDER_SZ*2+1 + mTitleHeight
         )
         return;
     if ( width  < mHorizGap*2 + BORDER_SZ*2+1 ||
         height < mVertGap*2  + BORDER_SZ*2+1 + mTitleHeight
         )
         return;
-    
+
     // step #1 - draw border around the tab content area
     // step #1 - draw border around the tab content area
-    
+
     // setup position for kind of "pencil"
     int curX = mHorizGap;
     int curY = mVertGap;
     // setup position for kind of "pencil"
     int curX = mHorizGap;
     int curY = mVertGap;
-    
+
     int xSize = width  - mHorizGap*2;
     int ySize = height - mVertGap *2  - mTitleHeight;
     int xSize = width  - mHorizGap*2;
     int ySize = height - mVertGap *2  - mTitleHeight;
-    
+
     // layer 1 (upper white)
     DrawShadedRect( curX+0, curY+0, xSize-0, ySize-0,
         mWhitePen, mBlackPen, dc  );
     // layer 1 (upper white)
     DrawShadedRect( curX+0, curY+0, xSize-0, ySize-0,
         mWhitePen, mBlackPen, dc  );
-    
+
     // layer 2 (upper gray)
     DrawShadedRect( curX+1, curY+1, xSize-2-1, ySize-2-1,
         mGrayPen, mGrayPen, dc  );
     // layer 2 (upper gray)
     DrawShadedRect( curX+1, curY+1, xSize-2-1, ySize-2-1,
         mGrayPen, mGrayPen, dc  );
-    
+
     // layer 3 (upper darkGray)
     DrawShadedRect( curX+2, curY+2, xSize-3-2, ySize-3-2,
         mDarkPen, mWhitePen, dc  );
     // layer 3 (upper darkGray)
     DrawShadedRect( curX+2, curY+2, xSize-3-2, ySize-3-2,
         mDarkPen, mWhitePen, dc  );
-    
+
     // layer 4 (upper black)
     DrawShadedRect( curX+3, curY+3, xSize-4-3, ySize-4-3,
         mBlackPen, mGrayPen, dc  );
     // layer 4 (upper black)
     DrawShadedRect( curX+3, curY+3, xSize-4-3, ySize-4-3,
         mBlackPen, mGrayPen, dc  );
-    
+
     // add non-siemtric layer from the lower-right side (confroming to MFC-look)
     // add non-siemtric layer from the lower-right side (confroming to MFC-look)
-    
+
     dc.SetPen( mDarkPen );
     dc.DrawLine( curX+1, curY + ySize - 2, curX + xSize - 1, curY + ySize - 2 );   // horiz
     dc.DrawLine( curX + xSize - 2, curY + 1, curX + xSize - 2, curY + ySize - 2 ); // vert
     dc.SetPen( mDarkPen );
     dc.DrawLine( curX+1, curY + ySize - 2, curX + xSize - 1, curY + ySize - 2 );   // horiz
     dc.DrawLine( curX + xSize - 2, curY + 1, curX + xSize - 2, curY + ySize - 2 ); // vert
-    
+
     // step #2 - draw tab title bars
     // step #2 - draw tab title bars
-    
+
     curX = mFirstTitleGap;
     curY = height - mVertGap - mTitleHeight;
     curX = mFirstTitleGap;
     curY = height - mVertGap - mTitleHeight;
-    
-    int tabNo = 0;
-    wxNode* pNode = mTabs.First();
-    
+
+    size_t tabNo = 0;
+    wxObjectList::compatibility_iterator pNode = mTabs.GetFirst();
+
     while( pNode )
     {
         // "hard-coded metafile" for decorations
     while( pNode )
     {
         // "hard-coded metafile" for decorations
-        
-        twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
-        
+
+        twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
+
         xSize = tab.mDims.x;
         ySize = mTitleHeight;
         xSize = tab.mDims.x;
         ySize = mTitleHeight;
-        
+
         if ( tabNo == mActiveTab )
         {
             dc.SetPen( mGrayPen );
             dc.DrawLine( curX+1, curY-2, curX+xSize-2, curY-2 );
             dc.DrawLine( curX+1, curY-1, curX+xSize-2, curY-1 );
         }
         if ( tabNo == mActiveTab )
         {
             dc.SetPen( mGrayPen );
             dc.DrawLine( curX+1, curY-2, curX+xSize-2, curY-2 );
             dc.DrawLine( curX+1, curY-1, curX+xSize-2, curY-1 );
         }
-        
+
         dc.SetPen( mWhitePen );
         dc.SetPen( mWhitePen );
-        
+
         if ( tabNo == mActiveTab )
             dc.DrawLine( curX, curY-2, curX, curY+ySize-2 );
         else
             dc.DrawLine( curX, curY, curX, curY+ySize-2 );
         if ( tabNo == mActiveTab )
             dc.DrawLine( curX, curY-2, curX, curY+ySize-2 );
         else
             dc.DrawLine( curX, curY, curX, curY+ySize-2 );
-        
+
         dc.SetPen( mDarkPen );
         dc.DrawLine( curX+1, curY+ySize-3, curX+1, curY+ySize-1 ); // to pix down
         dc.DrawLine( curX+2, curY+ySize-2, curX+xSize-2, curY+ySize-2 );
         dc.SetPen( mDarkPen );
         dc.DrawLine( curX+1, curY+ySize-3, curX+1, curY+ySize-1 ); // to pix down
         dc.DrawLine( curX+2, curY+ySize-2, curX+xSize-2, curY+ySize-2 );
@@ -397,23 +392,23 @@ void wxTabbedWindow::DrawDecorations( wxDC& dc )
             dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-3 );
         else
             dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-1 );
             dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-3 );
         else
             dc.DrawLine( curX+xSize-2, curY+ySize-3, curX+xSize-2, curY-1 );
-        
+
         dc.SetPen( mBlackPen );
         dc.DrawLine( curX+xSize-1, curY, curX+xSize-1, curY+ySize-2 );
         dc.DrawLine( curX+xSize-2, curY+ySize-2, curX+xSize-3, curY+ySize-2 );
         dc.DrawLine( curX+xSize-3, curY+ySize-1, curX+1, curY+ySize-1 );
         dc.SetPen( mBlackPen );
         dc.DrawLine( curX+xSize-1, curY, curX+xSize-1, curY+ySize-2 );
         dc.DrawLine( curX+xSize-2, curY+ySize-2, curX+xSize-3, curY+ySize-2 );
         dc.DrawLine( curX+xSize-3, curY+ySize-1, curX+1, curY+ySize-1 );
-        
-        pNode = pNode->Next();
+
+        pNode = pNode->GetNext();
         ++tabNo;
         ++tabNo;
-        
+
         // darw image and (or without) text centered within the
         // title bar rectangle
         // darw image and (or without) text centered within the
         // title bar rectangle
-        
+
         if ( mLayoutType != wxTITLE_BORDER_ONLY && tab.HasImg() )
         {
             wxMemoryDC tmpDc;
             tmpDc.SelectObject( tab.GetImg() );
         if ( mLayoutType != wxTITLE_BORDER_ONLY && tab.HasImg() )
         {
             wxMemoryDC tmpDc;
             tmpDc.SelectObject( tab.GetImg() );
-            
+
             dc.Blit( curX + mTitleHorizGap,
                 curY + ( ySize - tab.ImgHeight() ) / 2,
                 tab.ImgWidth(),
             dc.Blit( curX + mTitleHorizGap,
                 curY + ( ySize - tab.ImgHeight() ) / 2,
                 tab.ImgWidth(),
@@ -421,25 +416,25 @@ void wxTabbedWindow::DrawDecorations( wxDC& dc )
                 &tmpDc, 0, 0, wxCOPY
                 );
         }
                 &tmpDc, 0, 0, wxCOPY
                 );
         }
-        
+
         if ( mLayoutType == wxTITLE_IMG_AND_TEXT && tab.HasText() )
         {
             long x,w,h;
         if ( mLayoutType == wxTITLE_IMG_AND_TEXT && tab.HasText() )
         {
             long x,w,h;
-            
+
             // set select default font of the window into it's device context
             //dc.SetFont( GetLabelingFont() );
             // set select default font of the window into it's device context
             //dc.SetFont( GetLabelingFont() );
-            
+
             dc.SetTextBackground( GetBackgroundColour() );
             dc.SetTextBackground( GetBackgroundColour() );
-            
+
             dc.GetTextExtent(tab.mText, &w, &h );
             dc.GetTextExtent(tab.mText, &w, &h );
-            
+
             x = curX + mTitleHorizGap +
                 tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap);
             x = curX + mTitleHorizGap +
                 tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap);
-            
+
             dc.DrawText( tab.GetText(), x, curY + ( ySize - h ) / 2 );
         }
         curX += xSize;
             dc.DrawText( tab.GetText(), x, curY + ( ySize - h ) / 2 );
         }
         curX += xSize;
-        
+
     } // end of `while (pNode)'
 }  // wxTabbedWindow::DrawDecorations()
 
     } // end of `while (pNode)'
 }  // wxTabbedWindow::DrawDecorations()
 
@@ -448,20 +443,17 @@ int wxTabbedWindow::HitTest( const wxPoint& pos )
 {
     int width, height;
     GetClientSize( &width, &height );
 {
     int width, height;
     GetClientSize( &width, &height );
-    
+
     int curX = mFirstTitleGap;
     int curY = height - mVertGap - mTitleHeight;
     int curX = mFirstTitleGap;
     int curY = height - mVertGap - mTitleHeight;
-    
+
     int     tabNo = 0;
     int     tabNo = 0;
-    wxNode* pNode = mTabs.First();
-    
+    wxObjectList::compatibility_iterator pNode = mTabs.GetFirst();
+
     while( pNode )
     {
     while( pNode )
     {
-        twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
-        
-        int w,h;
-        w = tab.mDims.x;
-        h = tab.mDims.y;
+        twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
+
         // hit test rectangle of the currnet tab title bar
         if ( pos.x >= curX && pos.x < curX + tab.mDims.x  &&
             pos.y >= curY && pos.y < curY + tab.mDims.y
         // hit test rectangle of the currnet tab title bar
         if ( pos.x >= curX && pos.x < curX + tab.mDims.x  &&
             pos.y >= curY && pos.y < curY + tab.mDims.y
@@ -469,13 +461,13 @@ int wxTabbedWindow::HitTest( const wxPoint& pos )
         {
             return tabNo;
         }
         {
             return tabNo;
         }
-        
+
         curX += tab.mDims.x;
         curX += tab.mDims.x;
-        
-        pNode = pNode->Next();
+
+        pNode = pNode->GetNext();
         ++tabNo;
     }
         ++tabNo;
     }
-    
+
     return -1;
 }  // wxTabbedWindow::HitTest()
 
     return -1;
 }  // wxTabbedWindow::HitTest()
 
@@ -484,19 +476,19 @@ void wxTabbedWindow::HideInactiveTabs( bool andRepaint )
 {
     if ( !andRepaint )
         return;
 {
     if ( !andRepaint )
         return;
-    
-    wxNode* pNode = mTabs.First();
-    int     tabNo = 0;
-    
+
+    wxObjectList::compatibility_iterator pNode = mTabs.GetFirst();
+    size_t  tabNo = 0;
+
     while( pNode )
     {
         if ( tabNo != mActiveTab )
         {
     while( pNode )
     {
         if ( tabNo != mActiveTab )
         {
-            twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
-            tab.mpContent->Show(FALSE);
+            twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
+            tab.mpContent->Show(false);
         }
         }
-        
-        pNode = pNode->Next();
+
+        pNode = pNode->GetNext();
         ++tabNo;
     }
 }  // wxTabbedWindow::HideInactiveTabs()
         ++tabNo;
     }
 }  // wxTabbedWindow::HideInactiveTabs()
@@ -506,19 +498,19 @@ wxFont wxTabbedWindow::GetLabelingFont()
 {
     wxFont font;
 #ifdef __WINDOWS__
 {
     wxFont font;
 #ifdef __WINDOWS__
-    font.SetFaceName("MS Sans Serif");
+    font.SetFaceName(_T("MS Sans Serif"));
 #else
     font.SetFamily( wxSWISS );
 #endif
 #else
     font.SetFamily( wxSWISS );
 #endif
-    
+
     font.SetStyle(40);
     font.SetWeight(40);
     font.SetPointSize( 8 );
     font.SetStyle(40);
     font.SetWeight(40);
     font.SetPointSize( 8 );
-    
+
 #ifdef __WINDOWS__
     font.RealizeResource();
 #endif
 #ifdef __WINDOWS__
     font.RealizeResource();
 #endif
-    
+
     return font;
 }  // wxTabbedWindow::GetLabelingFont()
 
     return font;
 }  // wxTabbedWindow::GetLabelingFont()
 
@@ -526,87 +518,87 @@ wxFont wxTabbedWindow::GetLabelingFont()
 void wxTabbedWindow::RecalcLayout(bool andRepaint)
 {
     HideInactiveTabs(andRepaint);
 void wxTabbedWindow::RecalcLayout(bool andRepaint)
 {
     HideInactiveTabs(andRepaint);
-    
+
     // resetup position of the active tab
     // resetup position of the active tab
-    
+
     int width, height;
     GetClientSize( &width, &height );
     int width, height;
     GetClientSize( &width, &height );
-    
+
     int curX = mHorizGap + BORDER_SZ;
     int curY = mVertGap  + BORDER_SZ;
     int curX = mHorizGap + BORDER_SZ;
     int curY = mVertGap  + BORDER_SZ;
-    
+
     int xSize = width  - mHorizGap*2 - BORDER_SZ*2-1;
     int ySize = height - mVertGap*2  - BORDER_SZ*2-1 - mTitleHeight;
     int xSize = width  - mHorizGap*2 - BORDER_SZ*2-1;
     int ySize = height - mVertGap*2  - BORDER_SZ*2-1 - mTitleHeight;
-    
+
     SizeTabs( curX, curY, xSize, ySize, andRepaint );
     SizeTabs( curX, curY, xSize, ySize, andRepaint );
-    
+
     // pass #1 - try to layout assuming it's wxTITLE_IMG_AND_TEXT
     // pass #1 - try to layout assuming it's wxTITLE_IMG_AND_TEXT
-    
+
     mLayoutType = wxTITLE_IMG_AND_TEXT;
     mLayoutType = wxTITLE_IMG_AND_TEXT;
-    
-    wxNode* pNode = mTabs.First();
-    
+
+    wxObjectList::compatibility_iterator pNode = mTabs.GetFirst();
+
     curX = mFirstTitleGap; // the left-side gap
     mTitleHeight = 0;
     curX = mFirstTitleGap; // the left-side gap
     mTitleHeight = 0;
-    
+
     while( pNode )
     {
     while( pNode )
     {
-        twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
-        
+        twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
+
         wxWindowDC dc(this);
         wxWindowDC dc(this);
-        
+
         long w,h;
         long w,h;
-        
+
         // set select default font of the window into it's device context
         //dc.SetFont( GetLabelingFont() );
         // set select default font of the window into it's device context
         //dc.SetFont( GetLabelingFont() );
-        
+
         dc.GetTextExtent(tab.mText, &w, &h );
         dc.GetTextExtent(tab.mText, &w, &h );
-        
+
         tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) +
             tab.ImgWidth() + mTitleHorizGap*2;
         tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) +
             tab.ImgWidth() + mTitleHorizGap*2;
-        
+
         tab.mDims.y  = wxMax( h, tab.ImgHeight() ) + mTitleVertGap*2;
         mTitleHeight = wxMax( mTitleHeight, tab.mDims.y );
         tab.mDims.y  = wxMax( h, tab.ImgHeight() ) + mTitleVertGap*2;
         mTitleHeight = wxMax( mTitleHeight, tab.mDims.y );
-        
+
         curX += tab.mDims.x;
         curX += tab.mDims.x;
-        
-        pNode = pNode->Next();
+
+        pNode = pNode->GetNext();
     }
     }
-    
+
     curX += mHorizGap; // the right-side gap
     curX += mHorizGap; // the right-side gap
-    
+
     // make all title bars of equel height
     // make all title bars of equel height
-    
-    pNode = mTabs.First();
-    
+
+    pNode = mTabs.GetFirst();
+
     while( pNode )
     {
     while( pNode )
     {
-        ((twTabInfo*)(pNode->Data()))->mDims.y = mTitleHeight;;
-        pNode = pNode->Next();
+        ((twTabInfo*)(pNode->GetData()))->mDims.y = mTitleHeight;;
+        pNode = pNode->GetNext();
     }
     }
-    
+
     // if curX has'nt ran out of bounds, leave TITLE_IMG layout and return
     if ( curX < width - mHorizGap )
         return;
     // if curX has'nt ran out of bounds, leave TITLE_IMG layout and return
     if ( curX < width - mHorizGap )
         return;
-    
+
     // pass #2 - try to layout assuming wxTITLE_IMG_ONLY
     // pass #2 - try to layout assuming wxTITLE_IMG_ONLY
-    
+
     mLayoutType = wxTITLE_IMG_ONLY;
     mLayoutType = wxTITLE_IMG_ONLY;
-    
-    pNode = mTabs.First();
-    
+
+    pNode = mTabs.GetFirst();
+
     curX = mFirstTitleGap; // the left-side gap
     curX = mFirstTitleGap; // the left-side gap
-    
-    int denomiator = mTabs.Number();
+
+    int denomiator = mTabs.GetCount();
     if ( denomiator == 0 )
         ++denomiator;
     if ( denomiator == 0 )
         ++denomiator;
-    
+
     mBorderOnlyWidth = (width - mFirstTitleGap - mHorizGap) / denomiator;
     mBorderOnlyWidth = (width - mFirstTitleGap - mHorizGap) / denomiator;
-    
+
     while( pNode )
     {
     while( pNode )
     {
-        twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
-        
+        twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
+
         if ( tab.HasImg() )
         {
             tab.mDims.x = tab.ImgWidth()  + mTitleHorizGap*2;
         if ( tab.HasImg() )
         {
             tab.mDims.x = tab.ImgWidth()  + mTitleHorizGap*2;
@@ -617,53 +609,53 @@ void wxTabbedWindow::RecalcLayout(bool andRepaint)
             tab.mDims.x = mBorderOnlyWidth;
             tab.mDims.y = mTitleHeight;
         }
             tab.mDims.x = mBorderOnlyWidth;
             tab.mDims.y = mTitleHeight;
         }
-        
+
         curX += tab.mDims.x;
         curX += tab.mDims.x;
-        
-        pNode = pNode->Next();
+
+        pNode = pNode->GetNext();
     }
     }
-    
+
     curX += mHorizGap; // the right-side gap
     curX += mHorizGap; // the right-side gap
-    
+
     // if curX has'nt ran out of bounds, leave IMG_ONLY layout and return
     if ( curX < width  - mHorizGap )
         return;
     // if curX has'nt ran out of bounds, leave IMG_ONLY layout and return
     if ( curX < width  - mHorizGap )
         return;
-    
+
     // pass #3 - set the narrowest layout wxTITLE_BORDER_ONLY
     // pass #3 - set the narrowest layout wxTITLE_BORDER_ONLY
-    
+
     mLayoutType = wxTITLE_BORDER_ONLY;
     mLayoutType = wxTITLE_BORDER_ONLY;
-    
-    pNode = mTabs.First();
-    
+
+    pNode = mTabs.GetFirst();
+
     while( pNode )
     {
     while( pNode )
     {
-        twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
-        
+        twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
+
         tab.mDims.x = mBorderOnlyWidth;
         tab.mDims.y = mTitleHeight;
         tab.mDims.x = mBorderOnlyWidth;
         tab.mDims.y = mTitleHeight;
-        
-        pNode = pNode->Next();
+
+        pNode = pNode->GetNext();
     }
 }  // wxTabbedWindow::RecalcLayout()
 
 //---------------------------------------------------------------------------
 // wx event handlers
 //---------------------------------------------------------------------------
     }
 }  // wxTabbedWindow::RecalcLayout()
 
 //---------------------------------------------------------------------------
 // wx event handlers
 //---------------------------------------------------------------------------
-void wxTabbedWindow::OnPaint( wxPaintEvent& event )
+void wxTabbedWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
 {
     wxPaintDC dc(this);
     DrawDecorations( dc );
 }
 
 //---------------------------------------------------------------------------
 {
     wxPaintDC dc(this);
     DrawDecorations( dc );
 }
 
 //---------------------------------------------------------------------------
-void wxTabbedWindow::OnSize ( wxSizeEvent& event )
+void wxTabbedWindow::OnSize ( wxSizeEvent& WXUNUSED(event) )
 {
     SetBackgroundColour( wxColour( 192,192,192 ) );
 {
     SetBackgroundColour( wxColour( 192,192,192 ) );
-    RecalcLayout(TRUE);
+    RecalcLayout(true);
 }
 
 //---------------------------------------------------------------------------
 }
 
 //---------------------------------------------------------------------------
-void wxTabbedWindow::OnBkErase( wxEraseEvent& event )
+void wxTabbedWindow::OnBkErase( wxEraseEvent& WXUNUSED(event) )
 {
     // do nothing
 }
 {
     // do nothing
 }
@@ -674,9 +666,9 @@ void wxTabbedWindow::OnLButtonDown( wxMouseEvent& event )
     // floats, why?
     int x = (int)event.m_x;
     int y = (int)event.m_y;
     // floats, why?
     int x = (int)event.m_x;
     int y = (int)event.m_y;
-    
+
     int tabNo = HitTest( wxPoint(x,y) );
     int tabNo = HitTest( wxPoint(x,y) );
-    
+
     if ( tabNo != -1 )
     {
         SetActiveTab( tabNo );
     if ( tabNo != -1 )
     {
         SetActiveTab( tabNo );
@@ -707,53 +699,47 @@ END_EVENT_TABLE()
 //---------------------------------------------------------------------------
 wxPagedWindow::wxPagedWindow()
 
 //---------------------------------------------------------------------------
 wxPagedWindow::wxPagedWindow()
 
-:   mScrollEventInProgress( FALSE ),
+:   mScrollEventInProgress( false ),
     mTabTrianGap(4),
     mWhiteBrush( wxColour(255,255,255), wxSOLID ),
     mGrayBrush ( wxColour(192,192,192), wxSOLID ),
     mCurentRowOfs( 0 ),
     mAdjustableTitleRowLen( 300 ),
     mTabTrianGap(4),
     mWhiteBrush( wxColour(255,255,255), wxSOLID ),
     mGrayBrush ( wxColour(192,192,192), wxSOLID ),
     mCurentRowOfs( 0 ),
     mAdjustableTitleRowLen( 300 ),
-    mIsDragged    ( FALSE ),
+    mIsDragged    ( false ),
     mDagOrigin    ( 0 ),
     mDagOrigin    ( 0 ),
-    mCursorChanged( FALSE ),
+    mCursorChanged( false ),
     mResizeCursor ( wxCURSOR_SIZEWE ),
     mNormalCursor ( wxCURSOR_ARROW  )
 {
     mTitleVertGap = 2;
     mTitleHorizGap = 10;
     mResizeCursor ( wxCURSOR_SIZEWE ),
     mNormalCursor ( wxCURSOR_ARROW  )
 {
     mTitleVertGap = 2;
     mTitleHorizGap = 10;
-    mNoVertScroll = TRUE;       // Horizontale Scroll abschalten
-}
-
-//---------------------------------------------------------------------------
-wxPagedWindow::~wxPagedWindow()
-{
-    // nothing (base class handles destruction)
+    mNoVertScroll = true;       // Horizontale Scroll abschalten
 }
 
 //---------------------------------------------------------------------------
 wxFont wxPagedWindow::GetLabelingFont()
 {
     wxFont font;
 }
 
 //---------------------------------------------------------------------------
 wxFont wxPagedWindow::GetLabelingFont()
 {
     wxFont font;
-    
+
 #ifdef __WINDOWS__
 #ifdef __WINDOWS__
-    font.SetFaceName("Comic Sans MS");
+    font.SetFaceName(_T("Comic Sans MS"));
 #else
     font.SetFamily( wxSWISS );
 #endif
 #else
     font.SetFamily( wxSWISS );
 #endif
-    
+
     font.SetStyle(40);
     font.SetWeight(40);
     font.SetPointSize( 8 );
     font.SetStyle(40);
     font.SetWeight(40);
     font.SetPointSize( 8 );
-    
+
     return font;
 }
 
 //---------------------------------------------------------------------------
     return font;
 }
 
 //---------------------------------------------------------------------------
-void wxPagedWindow::OnTabAdded( twTabInfo* pInfo )
+void wxPagedWindow::OnTabAdded( twTabInfo* WXUNUSED(pInfo) )
 {
     int units = GetWholeTabRowLen() / 20;
 {
     int units = GetWholeTabRowLen() / 20;
-    
-    mpTabScroll->SetScrollbar( 0, 1, units, 1, FALSE );
+
+    mpTabScroll->SetScrollbar( 0, 1, units, 1, false );
 }
 
 //---------------------------------------------------------------------------
 }
 
 //---------------------------------------------------------------------------
@@ -771,18 +757,18 @@ wxScrollBar& wxPagedWindow::GetHorizontalScrollBar()
 //---------------------------------------------------------------------------
 int wxPagedWindow::GetWholeTabRowLen()
 {
 //---------------------------------------------------------------------------
 int wxPagedWindow::GetWholeTabRowLen()
 {
-    wxNode* pNode = mTabs.First();
-    
+    wxObjectList::compatibility_iterator pNode = mTabs.GetFirst();
+
     int len = 0;
     int len = 0;
-    
+
     while( pNode )
     {
     while( pNode )
     {
-        twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
-        
+        twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
+
         len += tab.mDims.x;
         len += tab.mDims.x;
-        pNode = pNode->Next();
+        pNode = pNode->GetNext();
     }
     }
-    
+
     return len;
 }  // wxPagedWindow::GetWholeTabRowLen()
 
     return len;
 }  // wxPagedWindow::GetWholeTabRowLen()
 
@@ -791,40 +777,40 @@ void wxPagedWindow::DrawPaperBar( twTabInfo& tab, int x, int y,
                                   wxBrush& brush, wxPen& pen, wxDC& dc )
 {
     wxPoint poly[4];
                                   wxBrush& brush, wxPen& pen, wxDC& dc )
 {
     wxPoint poly[4];
-    
+
     // draw organizer-style paper outlet
     // draw organizer-style paper outlet
-    
+
     poly[0].x = x - mTabTrianGap;
     poly[0].y = y;
     poly[0].x = x - mTabTrianGap;
     poly[0].y = y;
-    
+
     poly[1].x = x + mTabTrianGap;
     poly[1].y = y + tab.mDims.y-1;
     poly[1].x = x + mTabTrianGap;
     poly[1].y = y + tab.mDims.y-1;
-    
+
     poly[2].x = x + tab.mDims.x - mTabTrianGap;
     poly[2].y = y + tab.mDims.y-1;
     poly[2].x = x + tab.mDims.x - mTabTrianGap;
     poly[2].y = y + tab.mDims.y-1;
-    
+
     poly[3].x = x + tab.mDims.x + mTabTrianGap;
     poly[3].y = y;
     poly[3].x = x + tab.mDims.x + mTabTrianGap;
     poly[3].y = y;
-    
+
     dc.SetPen( pen );
     dc.SetBrush( brush );
     dc.SetPen( pen );
     dc.SetBrush( brush );
-    
+
     dc.DrawPolygon( 4, poly );
     dc.DrawPolygon( 4, poly );
-    
+
     long w,h;
     long w,h;
-    
+
     // set select default font of the window into it's device context
     //dc.SetFont( GetLabelingFont() );
     // set select default font of the window into it's device context
     //dc.SetFont( GetLabelingFont() );
-    
+
     dc.SetTextBackground( brush.GetColour() );
     dc.SetTextBackground( brush.GetColour() );
-    
+
     dc.GetTextExtent(tab.mText, &w, &h );
     dc.GetTextExtent(tab.mText, &w, &h );
-    
+
     if ( tab.HasImg() )
     {
         wxMemoryDC tmpDc;
         tmpDc.SelectObject( tab.GetImg() );
     if ( tab.HasImg() )
     {
         wxMemoryDC tmpDc;
         tmpDc.SelectObject( tab.GetImg() );
-        
+
         dc.Blit( x + mTitleHorizGap,
             y + ( tab.mDims.y - tab.ImgHeight() ) / 2,
             tab.ImgWidth(),
         dc.Blit( x + mTitleHorizGap,
             y + ( tab.mDims.y - tab.ImgHeight() ) / 2,
             tab.ImgWidth(),
@@ -832,12 +818,12 @@ void wxPagedWindow::DrawPaperBar( twTabInfo& tab, int x, int y,
             &tmpDc, 0, 0, wxCOPY
             );
     }
             &tmpDc, 0, 0, wxCOPY
             );
     }
-    
+
     if ( tab.HasText() )
     {
         int tx = x + mTitleHorizGap +
             tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap);
     if ( tab.HasText() )
     {
         int tx = x + mTitleHorizGap +
             tab.ImgWidth() + tab.ImageToTxtGap(mImageTextGap);
-        
+
         dc.DrawText( tab.GetText(), tx, y + ( tab.mDims.y - h ) / 2 );
     }
 }  // wxPagedWindow::DrawPaperBar()
         dc.DrawText( tab.GetText(), tx, y + ( tab.mDims.y - h ) / 2 );
     }
 }  // wxPagedWindow::DrawPaperBar()
@@ -864,8 +850,8 @@ void wxPagedWindow::DrawDecorations( wxDC& dc )
 
     // draw inactive tab title bars frist (left-to-right)
 
 
     // draw inactive tab title bars frist (left-to-right)
 
-    wxNode* pNode = mTabs.First();
-    int     tabNo = 0;
+    wxObjectList::compatibility_iterator pNode = mTabs.GetFirst();
+    size_t  tabNo = 0;
 
     /* OLD STUFF::
     curX = mTitleRowStart;
 
     /* OLD STUFF::
     curX = mTitleRowStart;
@@ -892,58 +878,58 @@ void wxPagedWindow::DrawDecorations( wxDC& dc )
 
     while( pNode )
     {
 
     while( pNode )
     {
-        twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
+        twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
 
         if ( tabNo != mActiveTab )
             DrawPaperBar( tab, curX, curY, mGrayBrush, mBlackPen, tmpDc );
 
         curX += tab.mDims.x;
 
 
         if ( tabNo != mActiveTab )
             DrawPaperBar( tab, curX, curY, mGrayBrush, mBlackPen, tmpDc );
 
         curX += tab.mDims.x;
 
-        pNode = pNode->Next();
+        pNode = pNode->GetNext();
         ++tabNo;
     }
         ++tabNo;
     }
-    
+
     // finally, draw the active tab (white-filled)
     // finally, draw the active tab (white-filled)
-    
-    pNode = mTabs.First();
+
+    pNode = mTabs.GetFirst();
     tabNo = 0;
     tabNo = 0;
-    
+
     curX = mTabTrianGap;
     curX = mTabTrianGap;
-    
+
     while( pNode )
     {
     while( pNode )
     {
-        twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
-        
+        twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
+
         if ( tabNo == mActiveTab )
         {
             DrawPaperBar( tab, curX, curY, mWhiteBrush, mBlackPen, tmpDc );
         if ( tabNo == mActiveTab )
         {
             DrawPaperBar( tab, curX, curY, mWhiteBrush, mBlackPen, tmpDc );
-            
+
             tmpDc.SetPen( mWhitePen );
             tmpDc.SetPen( mWhitePen );
-            
+
             tmpDc.DrawLine( curX - mTabTrianGap+1, curY,
                 curX + tab.mDims.x + mTabTrianGap, curY );
             break;
         }
         curX += tab.mDims.x;
             tmpDc.DrawLine( curX - mTabTrianGap+1, curY,
                 curX + tab.mDims.x + mTabTrianGap, curY );
             break;
         }
         curX += tab.mDims.x;
-        
-        pNode = pNode->Next();
+
+        pNode = pNode->GetNext();
         ++tabNo;
     }
         ++tabNo;
     }
-    
+
     // back to initial device origin
     // back to initial device origin
-    
+
     tmpDc.SetDeviceOrigin( 0, 0 );
     tmpDc.SetDeviceOrigin( 0, 0 );
-    
+
     // draw resize-hint-stick
     // draw resize-hint-stick
-    
+
     curX = mTitleRowLen - 6;
     curX = mTitleRowLen - 6;
-    
+
     DrawShadedRect( curX+0, 0+0, 6,   mTitleHeight,   mGrayPen,  mBlackPen, tmpDc );
     DrawShadedRect( curX+1, 0+1, 6-2, mTitleHeight-2, mWhitePen, mDarkPen,  tmpDc );
     DrawShadedRect( curX+2, 0+2, 6-4, mTitleHeight-4, mGrayPen,  mGrayPen,  tmpDc );
     DrawShadedRect( curX+0, 0+0, 6,   mTitleHeight,   mGrayPen,  mBlackPen, tmpDc );
     DrawShadedRect( curX+1, 0+1, 6-2, mTitleHeight-2, mWhitePen, mDarkPen,  tmpDc );
     DrawShadedRect( curX+2, 0+2, 6-4, mTitleHeight-4, mGrayPen,  mGrayPen,  tmpDc );
-    
-    
-    
+
+
+
     dc.Blit( mTitleRowStart,
         height - mVertGap - BORDER_SZ - mTitleHeight,
         mTitleRowLen, mTitleHeight,
     dc.Blit( mTitleRowStart,
         height - mVertGap - BORDER_SZ - mTitleHeight,
         mTitleRowLen, mTitleHeight,
@@ -960,71 +946,71 @@ int wxPagedWindow::HitTest( const wxPoint& pos )
 void wxPagedWindow::RecalcLayout(bool andRepaint)
 {
     mTitleRowLen = mAdjustableTitleRowLen;
 void wxPagedWindow::RecalcLayout(bool andRepaint)
 {
     mTitleRowLen = mAdjustableTitleRowLen;
-    
+
     if ( int(mpTabScroll) == -1 ) return;
     if ( int(mpTabScroll) == -1 ) return;
-    
+
     // scroll bars should be created after Create() for this window is called
     if ( !mpTabScroll )
     {
         mpTabScroll   =
     // scroll bars should be created after Create() for this window is called
     if ( !mpTabScroll )
     {
         mpTabScroll   =
-            new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL );
-        
+            new wxScrollBar( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL );
+
         mpHorizScroll =
         mpHorizScroll =
-            new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL );
+            new wxScrollBar( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSB_HORIZONTAL );
         if (!mNoVertScroll)       // Vertical Scroll (Original)
         if (!mNoVertScroll)       // Vertical Scroll (Original)
-            mpVertScroll = new wxScrollBar( this, -1, wxDefaultPosition, wxDefaultSize, wxSB_VERTICAL );
+            mpVertScroll = new wxScrollBar( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSB_VERTICAL );
     }
     }
-    
+
     {
         int units = GetWholeTabRowLen() / 20;
     {
         int units = GetWholeTabRowLen() / 20;
-        
-        mpTabScroll->SetScrollbar( 0, 1, units, 1, FALSE );
+
+        mpTabScroll->SetScrollbar( 0, 1, units, 1, false );
     }
     }
-    
+
     // resetup position of the active tab
     // resetup position of the active tab
-    
+
     int thumbLen = 16; // FOR NOW:: hardcoded
     int thumbLen = 16; // FOR NOW:: hardcoded
-    
+
     int width, height;
     GetClientSize( &width, &height );
     int width, height;
     GetClientSize( &width, &height );
-    
+
     mTitleHeight = thumbLen;
     mTitleHeight = thumbLen;
-    
+
     int curX = mHorizGap + BORDER_SZ;
     int curY = mVertGap  + BORDER_SZ;
     int curX = mHorizGap + BORDER_SZ;
     int curY = mVertGap  + BORDER_SZ;
-    
+
     int xSize;
     if (!mNoVertScroll)       // Vertical Scroll (Original)
         xSize = width  - mHorizGap*2 - BORDER_SZ*2 - thumbLen;
     else
         xSize = width  - mHorizGap*2 - BORDER_SZ*2;
     int xSize;
     if (!mNoVertScroll)       // Vertical Scroll (Original)
         xSize = width  - mHorizGap*2 - BORDER_SZ*2 - thumbLen;
     else
         xSize = width  - mHorizGap*2 - BORDER_SZ*2;
-    
+
     int ySize = height - mVertGap*2  - BORDER_SZ*2 - mTitleHeight;
     int ySize = height - mVertGap*2  - BORDER_SZ*2 - mTitleHeight;
-    
+
     SizeTabs( curX, curY, xSize, ySize, andRepaint );
     SizeTabs( curX, curY, xSize, ySize, andRepaint );
-    
+
     // setup title bar LINES's horizontal scroll bar
     // setup title bar LINES's horizontal scroll bar
-    
+
     curY = height - mVertGap - BORDER_SZ - thumbLen;
     curY = height - mVertGap - BORDER_SZ - thumbLen;
-    
+
     mpTabScroll->SetSize( curX, curY, thumbLen*2, thumbLen );
     mpTabScroll->SetSize( curX, curY, thumbLen*2, thumbLen );
-    
+
     // setup view's HORIZONTAL scroll bar
     curX += thumbLen*2;
     // setup view's HORIZONTAL scroll bar
     curX += thumbLen*2;
-    
+
     mTitleRowStart = curX;
     mFirstTitleGap = curX + mCurentRowOfs + mTabTrianGap;
     mTitleRowStart = curX;
     mFirstTitleGap = curX + mCurentRowOfs + mTabTrianGap;
-    
+
     mTitleRowLen = wxMin( mAdjustableTitleRowLen,
         width - mHorizGap - BORDER_SZ - thumbLen*4 - curX );
     mTitleRowLen = wxMin( mAdjustableTitleRowLen,
         width - mHorizGap - BORDER_SZ - thumbLen*4 - curX );
-    
+
     curX += mTitleRowLen;
     curX += mTitleRowLen;
-    
+
     if (!mNoVertScroll)       // Vertical Scroll (Original)
         mpHorizScroll->SetSize( curX, curY,width - curX - mHorizGap - BORDER_SZ - thumbLen, thumbLen );
     else
         mpHorizScroll->SetSize( curX, curY,width - curX - mHorizGap - BORDER_SZ-4, thumbLen );
     if (!mNoVertScroll)       // Vertical Scroll (Original)
         mpHorizScroll->SetSize( curX, curY,width - curX - mHorizGap - BORDER_SZ - thumbLen, thumbLen );
     else
         mpHorizScroll->SetSize( curX, curY,width - curX - mHorizGap - BORDER_SZ-4, thumbLen );
-    
+
     // setup view's VERTICAL scroll bar
     if (!mNoVertScroll)       // Vertical Scroll (Original)
     {
     // setup view's VERTICAL scroll bar
     if (!mNoVertScroll)       // Vertical Scroll (Original)
     {
@@ -1033,40 +1019,40 @@ void wxPagedWindow::RecalcLayout(bool andRepaint)
         mpVertScroll->SetSize( curX, curY, thumbLen,height - curY - mVertGap - BORDER_SZ - thumbLen);
     }
     // layout tab title bars
         mpVertScroll->SetSize( curX, curY, thumbLen,height - curY - mVertGap - BORDER_SZ - thumbLen);
     }
     // layout tab title bars
-    
+
     mLayoutType = wxTITLE_IMG_AND_TEXT;
     mLayoutType = wxTITLE_IMG_AND_TEXT;
-    
-    wxNode* pNode = mTabs.First();
-    
+
+    wxObjectList::compatibility_iterator pNode = mTabs.GetFirst();
+
     while( pNode )
     {
     while( pNode )
     {
-        twTabInfo& tab = *((twTabInfo*)(pNode->Data()));
-        
+        twTabInfo& tab = *((twTabInfo*)(pNode->GetData()));
+
         wxWindowDC dc(this);
         wxWindowDC dc(this);
-        
+
         long w,h;
         long w,h;
-        
+
         // set select default font of the window into it's device context
         //dc.SetFont( GetLabelingFont() );
         dc.GetTextExtent(tab.mText, &w, &h );
         // set select default font of the window into it's device context
         //dc.SetFont( GetLabelingFont() );
         dc.GetTextExtent(tab.mText, &w, &h );
-        
+
         tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) +
             tab.ImgWidth() + mTitleHorizGap*2;
         tab.mDims.x = w + tab.ImageToTxtGap(mImageTextGap) +
             tab.ImgWidth() + mTitleHorizGap*2;
-        
+
         tab.mDims.y  = mTitleHeight;
         tab.mDims.y  = mTitleHeight;
-        
-        pNode = pNode->Next();
+
+        pNode = pNode->GetNext();
     }
     }
-    
+
     // disable title-bar scroller if there's nowhere to scroll to
     // disable title-bar scroller if there's nowhere to scroll to
-    
+
     mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0  );
 }
 
 //---------------------------------------------------------------------------
 // event handlers
 //---------------------------------------------------------------------------
     mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0  );
 }
 
 //---------------------------------------------------------------------------
 // event handlers
 //---------------------------------------------------------------------------
-void wxPagedWindow::OnPaint( wxPaintEvent& event )
+void wxPagedWindow::OnPaint( wxPaintEvent& WXUNUSED(event) )
 {
     wxPaintDC dc(this);
     DrawDecorations( dc );
 {
     wxPaintDC dc(this);
     DrawDecorations( dc );
@@ -1083,11 +1069,11 @@ void wxPagedWindow::OnLButtonDown( wxMouseEvent& event )
 {
     if ( mCursorChanged )
     {
 {
     if ( mCursorChanged )
     {
-        mIsDragged = TRUE;
+        mIsDragged = true;
         mDagOrigin = event.m_x;
         mDagOrigin = event.m_x;
-        
+
         mOriginalTitleRowLen = mAdjustableTitleRowLen;
         mOriginalTitleRowLen = mAdjustableTitleRowLen;
-        
+
         CaptureMouse();
     }
     else
         CaptureMouse();
     }
     else
@@ -1097,14 +1083,14 @@ void wxPagedWindow::OnLButtonDown( wxMouseEvent& event )
 }  // wxPagedWindow::OnLButtonDown()
 
 //---------------------------------------------------------------------------
 }  // wxPagedWindow::OnLButtonDown()
 
 //---------------------------------------------------------------------------
-void wxPagedWindow::OnLButtonUp( wxMouseEvent& event )
+void wxPagedWindow::OnLButtonUp( wxMouseEvent& WXUNUSED(event) )
 {
     if ( mIsDragged )
     {
 {
     if ( mIsDragged )
     {
-        mIsDragged     = FALSE;
-        mCursorChanged = FALSE;
+        mIsDragged     = false;
+        mCursorChanged = false;
         SetCursor( mNormalCursor );
         SetCursor( mNormalCursor );
-        
+
         ReleaseMouse();
     }
 } // wxPagedWindow::OnLButtonUp()
         ReleaseMouse();
     }
 } // wxPagedWindow::OnLButtonUp()
@@ -1114,12 +1100,12 @@ void wxPagedWindow::OnMouseMove( wxMouseEvent& event )
 {
     int width, height;
     GetClientSize( &width, &height );
 {
     int width, height;
     GetClientSize( &width, &height );
-    
+
     if ( !mIsDragged )
     {
         int y = height - mVertGap - BORDER_SZ - mTitleHeight;
         int x = mTitleRowStart + mTitleRowLen - 6;
     if ( !mIsDragged )
     {
         int y = height - mVertGap - BORDER_SZ - mTitleHeight;
         int x = mTitleRowStart + mTitleRowLen - 6;
-        
+
         if ( event.m_x >= x && event.m_y >= y &&
             event.m_x <  x + 6               &&
             event.m_y <  y + mTitleHeight
         if ( event.m_x >= x && event.m_y >= y &&
             event.m_x <  x + 6               &&
             event.m_y <  y + mTitleHeight
@@ -1128,16 +1114,16 @@ void wxPagedWindow::OnMouseMove( wxMouseEvent& event )
             if ( !mCursorChanged )
             {
                 SetCursor( mResizeCursor );
             if ( !mCursorChanged )
             {
                 SetCursor( mResizeCursor );
-                
-                mCursorChanged = TRUE;
+
+                mCursorChanged = true;
             }
         }
         else
             if ( mCursorChanged )
             {
                 SetCursor( mNormalCursor );
             }
         }
         else
             if ( mCursorChanged )
             {
                 SetCursor( mNormalCursor );
-                
-                mCursorChanged = FALSE;
+
+                mCursorChanged = false;
             }
     }
     else
             }
     }
     else
@@ -1145,15 +1131,15 @@ void wxPagedWindow::OnMouseMove( wxMouseEvent& event )
         if ( mIsDragged )
         {
             mAdjustableTitleRowLen = mOriginalTitleRowLen + ( event.m_x - mDagOrigin );
         if ( mIsDragged )
         {
             mAdjustableTitleRowLen = mOriginalTitleRowLen + ( event.m_x - mDagOrigin );
-            
+
             // FOR NOW:: fixed
             if ( mAdjustableTitleRowLen < 6 ) mAdjustableTitleRowLen = 6;
             // FOR NOW:: fixed
             if ( mAdjustableTitleRowLen < 6 ) mAdjustableTitleRowLen = 6;
-            
+
             wxWindowDC dc(this);
             DrawDecorations( dc );
             wxWindowDC dc(this);
             DrawDecorations( dc );
-            
-            RecalcLayout(FALSE);
-            
+
+            RecalcLayout(false);
+
             //Refresh();
         }
     }
             //Refresh();
         }
     }
@@ -1166,16 +1152,16 @@ void wxPagedWindow::OnScroll( wxScrollEvent& event )
     // wxMessageBox("wxPagedWindow::OnScroll","-I->");
     if ( pSender == mpTabScroll )
     {
     // wxMessageBox("wxPagedWindow::OnScroll","-I->");
     if ( pSender == mpTabScroll )
     {
-        
+
         int maxUnits = GetWholeTabRowLen() / 20;
         int maxUnits = GetWholeTabRowLen() / 20;
-        
+
         mCurentRowOfs = -event.GetPosition()*maxUnits;
         mCurentRowOfs = -event.GetPosition()*maxUnits;
-        
+
         mFirstTitleGap = mTitleRowStart + mCurentRowOfs + mTabTrianGap;
         mFirstTitleGap = mTitleRowStart + mCurentRowOfs + mTabTrianGap;
-        
+
         // let' it automatically disable itself if it's time
         mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0 );
         // let' it automatically disable itself if it's time
         mpTabScroll->Enable( mTitleRowLen < GetWholeTabRowLen() || mCurentRowOfs < 0 );
-        
+
         // repaint title bars
         wxWindowDC dc(this);
         DrawDecorations( dc );
         // repaint title bars
         wxWindowDC dc(this);
         DrawDecorations( dc );
@@ -1184,16 +1170,16 @@ void wxPagedWindow::OnScroll( wxScrollEvent& event )
     {
         if ( !mScrollEventInProgress )
         {
     {
         if ( !mScrollEventInProgress )
         {
-            mScrollEventInProgress = TRUE;
-            
+            mScrollEventInProgress = true;
+
             GetActiveTab()->GetEventHandler()->ProcessEvent( event );
         }
         else
         {
             // event bounced back to us, from here we
             // know that it has traveled the loop - thus it's processed!
             GetActiveTab()->GetEventHandler()->ProcessEvent( event );
         }
         else
         {
             // event bounced back to us, from here we
             // know that it has traveled the loop - thus it's processed!
-            
-            mScrollEventInProgress = FALSE;
+
+            mScrollEventInProgress = false;
         }
     }
 }  // wxPagedWindow::OnScroll()
         }
     }
 }  // wxPagedWindow::OnScroll()
wxWidgets (Impactor)