added mouse wheel support (patch 1696082)

[wxWidgets.git] / src / aui / auibook.cpp

diff --git a/src/aui/auibook.cpp b/src/aui/auibook.cpp
index dc55f5e98567e948410512a5a7c30df6ca4ca909..8dc1918a7f08bb4609affca66fed03b4399bc5b9 100644 (file)
--- a/src/aui/auibook.cpp
+++ b/src/aui/auibook.cpp
@@ -25,11 +25,15 @@
 #ifndef WX_PRECOMP
     #include "wx/settings.h"
     #include "wx/image.h"
 #ifndef WX_PRECOMP
     #include "wx/settings.h"
     #include "wx/image.h"

+    #include "wx/menu.h"

 #endif
 
 #include "wx/aui/tabmdi.h"
 #include "wx/dcbuffer.h"
 #endif
 
 #include "wx/aui/tabmdi.h"
 #include "wx/dcbuffer.h"

-#include "wx/menu.h"
+
+#ifdef __WXMAC__
+#include "wx/mac/carbon/private.h"
+#endif

 
 #include "wx/arrimpl.cpp"
 WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray)
 
 #include "wx/arrimpl.cpp"
 WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray)


@@ -53,27 +57,15 @@ IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxEvent)
 
 
 
 
 
 

-// This functions are here for this proof of concept
-// and will be factored out later. See dockart.cpp
-static wxColor StepColour(const wxColor& c, int percent)
-{
-    int r = c.Red(), g = c.Green(), b = c.Blue();
-    return wxColour((unsigned char)wxMin((r*percent)/100,255),
-                    (unsigned char)wxMin((g*percent)/100,255),
-                    (unsigned char)wxMin((b*percent)/100,255));
-}
+// these functions live in dockart.cpp -- they'll eventually
+// be moved to a new utility cpp file

 
 

-// This functions are here for this proof of concept
-// and will be factored out later. See dockart.cpp
-static wxBitmap BitmapFromBits(const unsigned char bits[], int w, int h,
-                               const wxColour& color)
-{
-    wxImage img = wxBitmap((const char*)bits, w, h).ConvertToImage();
-    img.Replace(0,0,0,123,123,123);
-    img.Replace(255,255,255,color.Red(),color.Green(),color.Blue());
-    img.SetMaskColour(123,123,123);
-    return wxBitmap(img);
-}
+wxColor wxAuiStepColour(const wxColor& c, int percent);
+
+wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
+                             const wxColour& color);
+
+wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size);

 
 static void DrawButtons(wxDC& dc,
                         const wxRect& _rect,
 
 static void DrawButtons(wxDC& dc,
                         const wxRect& _rect,


@@ -92,8 +84,8 @@ static void DrawButtons(wxDC& dc,
     if (button_state == wxAUI_BUTTON_STATE_HOVER ||
         button_state == wxAUI_BUTTON_STATE_PRESSED)
     {
     if (button_state == wxAUI_BUTTON_STATE_HOVER ||
         button_state == wxAUI_BUTTON_STATE_PRESSED)
     {

-        dc.SetBrush(wxBrush(StepColour(bkcolour, 120)));
-        dc.SetPen(wxPen(StepColour(bkcolour, 70)));
+        dc.SetBrush(wxBrush(wxAuiStepColour(bkcolour, 120)));
+        dc.SetPen(wxPen(wxAuiStepColour(bkcolour, 75)));

 
         // draw the background behind the button
         dc.DrawRectangle(rect.x, rect.y, 15, 15);
 
         // draw the background behind the button
         dc.DrawRectangle(rect.x, rect.y, 15, 15);


@@ -112,36 +104,6 @@ static void IndentPressedBitmap(wxRect* rect, int button_state)
     }
 }
 
     }
 }
 

-// chops the text so that it fits within |max_size| pixels.
-// Also adds an elipsis if necessary
-
-static wxString ChopText(wxDC& dc, const wxString& text, int max_size)
-{
-    wxCoord x,y;
-    
-    // first check if the text fits with no problems
-    dc.GetTextExtent(text, &x, &y);
-    if (x <= max_size)
-        return text;
-        
-    size_t i, len = text.Length();
-    size_t last_good_length = 0;
-    for (i = 0; i < len; ++i)
-    {
-        wxString s = text.Left(i);
-        s += wxT("...");
-        
-        dc.GetTextExtent(s, &x, &y);
-        if (x > max_size)
-            break;
-        
-        last_good_length = i;
-    }
-
-    wxString ret = text.Left(last_good_length);
-    ret += wxT("...");
-    return ret;
-}

 
 
 // -- GUI helper classes and functions --
 
 
 // -- GUI helper classes and functions --


@@ -149,7 +111,7 @@ static wxString ChopText(wxDC& dc, const wxString& text, int max_size)
 class wxAuiCommandCapture : public wxEvtHandler
 {
 public:
 class wxAuiCommandCapture : public wxEvtHandler
 {
 public:

-    
+

     wxAuiCommandCapture() { m_last_id = 0; }
     int GetCommandId() const { return m_last_id; }
 
     wxAuiCommandCapture() { m_last_id = 0; }
     int GetCommandId() const { return m_last_id; }
 


@@ -160,13 +122,13 @@ public:
             m_last_id = evt.GetId();
             return true;
         }
             m_last_id = evt.GetId();
             return true;
         }

-        
+

         if (GetNextHandler())
             return GetNextHandler()->ProcessEvent(evt);
 
         return false;
     }
         if (GetNextHandler())
             return GetNextHandler()->ProcessEvent(evt);
 
         return false;
     }

-    
+

 private:
     int m_last_id;
 };
 private:
     int m_last_id;
 };


@@ -186,9 +148,9 @@ private:
      0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 #else
  static unsigned char close_bits[]={
      0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 #else
  static unsigned char close_bits[]={

-    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0xfb,0xcf,0xf9,
-    0x9f,0xfc,0x3f,0xfe,0x3f,0xfe,0x9f,0xfc,0xcf,0xf9,0xef,0xfb,
-    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
+     0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
+     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};

 #endif
 
 static unsigned char left_bits[] = {
 #endif
 
 static unsigned char left_bits[] = {


@@ -219,34 +181,46 @@ wxAuiDefaultTabArt::wxAuiDefaultTabArt()
     m_selected_font = *wxNORMAL_FONT;
     m_selected_font.SetWeight(wxBOLD);
     m_measuring_font = m_selected_font;
     m_selected_font = *wxNORMAL_FONT;
     m_selected_font.SetWeight(wxBOLD);
     m_measuring_font = m_selected_font;

-    
+

     m_fixed_tab_width = 100;
     m_fixed_tab_width = 100;

+    m_tab_ctrl_height = 0;

 
 

-    wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+#ifdef __WXMAC__
+    wxBrush toolbarbrush;
+    toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
+    wxColor base_colour = toolbarbrush.GetColour();
+#else
+    wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+#endif

 
 

-    wxColour background_colour = base_colour;
-    wxColour normaltab_colour = base_colour;
-    wxColour selectedtab_colour = base_colour;
+    // the base_colour is too pale to use as our base colour,
+    // so darken it a bit --
+    if ((255-base_colour.Red()) +
+        (255-base_colour.Green()) +
+        (255-base_colour.Blue()) < 60)
+    {
+        base_colour = wxAuiStepColour(base_colour, 92);
+    }
+
+    m_base_colour = base_colour;
+    wxColor border_colour = wxAuiStepColour(base_colour, 75);
+
+    m_border_pen = wxPen(border_colour);
+    m_base_colour_pen = wxPen(m_base_colour);
+    m_base_colour_brush = wxBrush(m_base_colour);
+
+    m_active_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
+    m_disabled_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
+
+    m_active_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
+    m_disabled_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
+
+    m_active_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
+    m_disabled_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
+
+    m_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
+    m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));

 
 

-    m_bkbrush = wxBrush(background_colour);
-    m_normal_bkbrush = wxBrush(normaltab_colour);
-    m_normal_bkpen = wxPen(normaltab_colour);
-    m_selected_bkbrush = wxBrush(selectedtab_colour);
-    m_selected_bkpen = wxPen(selectedtab_colour);
-    
-    
-    m_active_close_bmp = BitmapFromBits(close_bits, 16, 16, *wxBLACK);
-    m_disabled_close_bmp = BitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
-    
-    m_active_left_bmp = BitmapFromBits(left_bits, 16, 16, *wxBLACK);
-    m_disabled_left_bmp = BitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
-    
-    m_active_right_bmp = BitmapFromBits(right_bits, 16, 16, *wxBLACK);
-    m_disabled_right_bmp = BitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
-    
-    m_active_windowlist_bmp = BitmapFromBits(list_bits, 16, 16, *wxBLACK);
-    m_disabled_windowlist_bmp = BitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
-    

     m_flags = 0;
 }
 
     m_flags = 0;
 }
 


@@ -268,38 +242,49 @@ void wxAuiDefaultTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
                                        size_t tab_count)
 {
     m_fixed_tab_width = 100;
                                        size_t tab_count)
 {
     m_fixed_tab_width = 100;

-    
-    int tot_width = tab_ctrl_size.x;
+
+    int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
+
+    if (m_flags & wxAUI_NB_CLOSE_BUTTON)
+        tot_width -= m_active_close_bmp.GetWidth();
+    if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
+        tot_width -= m_active_windowlist_bmp.GetWidth();
+

     if (tab_count > 0)
     {
         m_fixed_tab_width = tot_width/(int)tab_count;
     }
     if (tab_count > 0)
     {
         m_fixed_tab_width = tot_width/(int)tab_count;
     }

-    
-    
+
+

     if (m_fixed_tab_width < 100)
         m_fixed_tab_width = 100;
     if (m_fixed_tab_width < 100)
         m_fixed_tab_width = 100;

-        
+

     if (m_fixed_tab_width > tot_width/2)
         m_fixed_tab_width = tot_width/2;
     if (m_fixed_tab_width > tot_width/2)
         m_fixed_tab_width = tot_width/2;

-        
+

     if (m_fixed_tab_width > 220)
         m_fixed_tab_width = 220;
     if (m_fixed_tab_width > 220)
         m_fixed_tab_width = 220;

+
+    m_tab_ctrl_height = tab_ctrl_size.y;

 }
 }

-                       
-                       
+
+

 void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
                                         wxWindow* WXUNUSED(wnd),
                                         const wxRect& rect)
 {
     // draw background
 void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
                                         wxWindow* WXUNUSED(wnd),
                                         const wxRect& rect)
 {
     // draw background

-    dc.SetBrush(m_bkbrush);
-    dc.SetPen(*wxTRANSPARENT_PEN);
-    dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
+    wxRect r(rect.x, rect.y, rect.width+2, rect.height-3);
+    wxColor top_color = wxAuiStepColour(m_base_colour, 90);
+    wxColor bottom_color = wxAuiStepColour(m_base_colour, 170);
+    dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);

 
     // draw base lines
 
     // draw base lines

-    dc.SetPen(*wxGREY_PEN);
-    dc.DrawLine(0, rect.GetHeight()-4, rect.GetWidth(), rect.GetHeight()-4);
-    dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
+    int y = rect.GetHeight();
+    int w = rect.GetWidth();
+    dc.SetPen(m_border_pen);
+    dc.SetBrush(m_base_colour_brush);
+    dc.DrawRectangle(-1, y-4, w+2, 4);

 }
 
 
 }
 
 


@@ -314,9 +299,8 @@ void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
 
 void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
                                  wxWindow* wnd,
 
 void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
                                  wxWindow* wnd,

+                                 const wxAuiNotebookPage& page,

                                  const wxRect& in_rect,
                                  const wxRect& in_rect,

-                                 const wxString& caption_text,
-                                 bool active,

                                  int close_button_state,
                                  wxRect* out_tab_rect,
                                  wxRect* out_button_rect,
                                  int close_button_state,
                                  wxRect* out_tab_rect,
                                  wxRect* out_button_rect,


@@ -325,129 +309,206 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
     wxCoord normal_textx, normal_texty;
     wxCoord selected_textx, selected_texty;
     wxCoord textx, texty;
     wxCoord normal_textx, normal_texty;
     wxCoord selected_textx, selected_texty;
     wxCoord textx, texty;

-    
+

     // if the caption is empty, measure some temporary text
     // if the caption is empty, measure some temporary text

-    wxString caption = caption_text;
-    if (caption_text.empty())
+    wxString caption = page.caption;
+    if (caption.empty())

         caption = wxT("Xj");
         caption = wxT("Xj");

-            
+

     dc.SetFont(m_selected_font);
     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
     dc.SetFont(m_selected_font);
     dc.GetTextExtent(caption, &selected_textx, &selected_texty);

-    
+

     dc.SetFont(m_normal_font);
     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
     dc.SetFont(m_normal_font);
     dc.GetTextExtent(caption, &normal_textx, &normal_texty);

-        
-    // figure out the size of the tab
-    wxSize tab_size = GetTabSize(dc, wnd, caption, active, close_button_state, x_extent);

 
 

-    wxCoord tab_height = tab_size.y;
+    // figure out the size of the tab
+    wxSize tab_size = GetTabSize(dc,
+                                 wnd,
+                                 page.caption,
+                                 page.bitmap,
+                                 page.active,
+                                 close_button_state,
+                                 x_extent);
+
+    wxCoord tab_height = m_tab_ctrl_height - 3;

     wxCoord tab_width = tab_size.x;
     wxCoord tab_x = in_rect.x;
     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
 
 
     wxCoord tab_width = tab_size.x;
     wxCoord tab_x = in_rect.x;
     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
 
 

-    //dc.SetClippingRegion(left_buttons_width, 0,
-    //             m_rect.GetWidth() - right_buttons_width - left_buttons_width - 2,
-    //             m_rect.GetHeight());
-
-    dc.SetClippingRegion(in_rect);
-                  
+    caption = page.caption;

 
 
     // select pen, brush and font for the tab to be drawn
 
 
 
     // select pen, brush and font for the tab to be drawn
 

-    if (active)
+    if (page.active)

     {
     {

-        dc.SetPen(m_selected_bkpen);
-        dc.SetBrush(m_selected_bkbrush);

         dc.SetFont(m_selected_font);
         textx = selected_textx;
         texty = selected_texty;
     }
      else
     {
         dc.SetFont(m_selected_font);
         textx = selected_textx;
         texty = selected_texty;
     }
      else
     {

-        dc.SetPen(m_normal_bkpen);
-        dc.SetBrush(m_normal_bkbrush);

         dc.SetFont(m_normal_font);
         textx = normal_textx;
         texty = normal_texty;
     }
 
         dc.SetFont(m_normal_font);
         textx = normal_textx;
         texty = normal_texty;
     }
 

-    
-    // -- create points that will make the tab outline --
-    
-    wxPoint points[6];
-    points[0].x = tab_x;
-    points[0].y = tab_y + tab_height - 4;
-    points[1].x = tab_x;
-    points[1].y = tab_y + 2;
-    points[2].x = tab_x + 2;
-    points[2].y = tab_y;
-    points[3].x = tab_x + tab_width - 2;
-    points[3].y = tab_y;
-    points[4].x = tab_x + tab_width;
-    points[4].y = tab_y + 2;
-    points[5].x = tab_x + tab_width;
-    points[5].y = tab_y + tab_height - 4;

 
 

+    // create points that will make the tab outline

 
 

-    // -- draw gradient background --
-    if (active)
+    int clip_width = tab_width;
+    if (tab_x + clip_width > in_rect.x + in_rect.width)
+        clip_width = (in_rect.x + in_rect.width) - tab_x;
+
+/*
+    wxPoint clip_points[6];
+    clip_points[0] = wxPoint(tab_x,              tab_y+tab_height-3);
+    clip_points[1] = wxPoint(tab_x,              tab_y+2);
+    clip_points[2] = wxPoint(tab_x+2,            tab_y);
+    clip_points[3] = wxPoint(tab_x+clip_width-1, tab_y);
+    clip_points[4] = wxPoint(tab_x+clip_width+1, tab_y+2);
+    clip_points[5] = wxPoint(tab_x+clip_width+1, tab_y+tab_height-3);
+
+    // FIXME: these ports don't provide wxRegion ctor from array of points
+#if !defined(__WXDFB__) && !defined(__WXCOCOA__)
+    // set the clipping region for the tab --
+    wxRegion clipping_region(WXSIZEOF(clip_points), clip_points);
+    dc.SetClippingRegion(clipping_region);
+#endif // !wxDFB && !wxCocoa
+*/
+    // since the above code above doesn't play well with WXDFB or WXCOCOA,
+    // we'll just use a rectangle for the clipping region for now --
+    dc.SetClippingRegion(tab_x, tab_y, clip_width+1, tab_height-3);
+
+
+    wxPoint border_points[6];
+    border_points[0] = wxPoint(tab_x,             tab_y+tab_height-4);
+    border_points[1] = wxPoint(tab_x,             tab_y+2);
+    border_points[2] = wxPoint(tab_x+2,           tab_y);
+    border_points[3] = wxPoint(tab_x+tab_width-2, tab_y);
+    border_points[4] = wxPoint(tab_x+tab_width,   tab_y+2);
+    border_points[5] = wxPoint(tab_x+tab_width,   tab_y+tab_height-4);
+
+
+    int drawn_tab_yoff = border_points[1].y;
+    int drawn_tab_height = border_points[0].y - border_points[1].y;
+
+
+    if (page.active)
+    {
+        // draw active tab
+
+        // draw base background color
+        wxRect r(tab_x, tab_y, tab_width, tab_height);
+        dc.SetPen(m_base_colour_pen);
+        dc.SetBrush(m_base_colour_brush);
+        dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
+
+        // this white helps fill out the gradient at the top of the tab
+        dc.SetPen(*wxWHITE_PEN);
+        dc.SetBrush(*wxWHITE_BRUSH);
+        dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
+
+        // these two points help the rounded corners appear more antialiased
+        dc.SetPen(m_base_colour_pen);
+        dc.DrawPoint(r.x+2, r.y+1);
+        dc.DrawPoint(r.x+r.width-2, r.y+1);
+
+        // set rectangle down a bit for gradient drawing
+        r.SetHeight(r.GetHeight()/2);
+        r.x += 2;
+        r.width -= 2;
+        r.y += r.height;
+        r.y -= 2;
+
+        // draw gradient background
+        wxColor top_color = *wxWHITE;
+        wxColor bottom_color = m_base_colour;
+        dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
+    }
+     else

     {
     {

-        wxColour c = m_bkbrush.GetColour();
-        dc.SetPen(wxPen(c));
-        
-        int x, y, last_y = -1;
-        for (y = points[0].y; y > points[2].y; --y)
-        {
-            if (y < tab_y+(tab_height*3/5) && y != last_y)
-            {
-                last_y = y;
-                c = StepColour(c, 102);
-                dc.SetPen(wxPen(c));
-            }
-            
-            for (x = points[0].x+1; x < points[5].x; ++x)
-            {
-                dc.DrawPoint(x,y);
-            }
-        }
+        // draw inactive tab
+
+        wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
+
+        // start the gradent up a bit and leave the inside border inset
+        // by a pixel for a 3D look.  Only the top half of the inactive
+        // tab will have a slight gradient
+        r.x += 3;
+        r.y++;
+        r.width -= 4;
+        r.height /= 2;
+        r.height--;
+
+        // -- draw top gradient fill for glossy look
+        wxColor top_color = m_base_colour;
+        wxColor bottom_color = wxAuiStepColour(top_color, 160);
+        dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
+
+        r.y += r.height;
+        r.y--;
+
+        // -- draw bottom fill for glossy look
+        top_color = m_base_colour;
+        bottom_color = m_base_colour;
+        dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);

     }
 
     }
 

-    // -- draw tab outline --
-    dc.SetPen(*wxGREY_PEN);
+    // draw tab outline
+    dc.SetPen(m_border_pen);

     dc.SetBrush(*wxTRANSPARENT_BRUSH);
     dc.SetBrush(*wxTRANSPARENT_BRUSH);

-    dc.DrawPolygon(6, points);
+    dc.DrawPolygon(WXSIZEOF(border_points), border_points);

 
 

-    // -- there are two horizontal grey lines at the bottom of the tab control,
-    //    this gets rid of the top one of those lines in the tab control --
-    if (active)
+    // there are two horizontal grey lines at the bottom of the tab control,
+    // this gets rid of the top one of those lines in the tab control
+    if (page.active)

     {
     {

-        wxColour c = m_bkbrush.GetColour();
-        dc.SetPen(wxPen(c));
-        dc.DrawLine(points[0].x+1, points[0].y, points[5].x, points[5].y);
+        wxColor start_color = m_base_colour;
+        dc.SetPen(m_base_colour_pen);
+        dc.DrawLine(border_points[0].x+1,
+                    border_points[0].y,
+                    border_points[5].x,
+                    border_points[5].y);

     }
     }

-    
-    int text_offset;

 
 

+
+    int text_offset = tab_x + 8;

     int close_button_width = 0;
     int close_button_width = 0;

-    

     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {
         close_button_width = m_active_close_bmp.GetWidth();
     }
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {
         close_button_width = m_active_close_bmp.GetWidth();
     }

-    
-    text_offset = tab_x + 8;
-    

 
 

-    wxString draw_text = ChopText(dc,
+
+    if (page.bitmap.IsOk())
+    {
+        int bitmap_offset = tab_x + 8;
+
+        // draw bitmap
+        dc.DrawBitmap(page.bitmap,
+                      bitmap_offset,
+                      drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
+                      true);
+
+        text_offset = bitmap_offset + page.bitmap.GetWidth();
+        text_offset += 3; // bitmap padding
+    }
+     else
+    {
+        text_offset = tab_x + 8;
+    }
+
+
+    wxString draw_text = wxAuiChopText(dc,

                           caption,
                           tab_width - (text_offset-tab_x) - close_button_width);
                           caption,
                           tab_width - (text_offset-tab_x) - close_button_width);

-    
+

     // draw tab text
     dc.DrawText(draw_text,
                 text_offset,
     // draw tab text
     dc.DrawText(draw_text,
                 text_offset,

-                (tab_y + tab_height)/2 - (texty/2));
+                drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);

 
 
 
 
 
 


@@ -462,19 +523,19 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
         {
             bmp = m_active_close_bmp;
         }
         {
             bmp = m_active_close_bmp;
         }

-        
+

         wxRect rect(tab_x + tab_width - close_button_width - 1,
                     tab_y + (tab_height/2) - (bmp.GetHeight()/2),
                     close_button_width,
                     tab_height);
         IndentPressedBitmap(&rect, close_button_state);
         dc.DrawBitmap(bmp, rect.x, rect.y, true);
         wxRect rect(tab_x + tab_width - close_button_width - 1,
                     tab_y + (tab_height/2) - (bmp.GetHeight()/2),
                     close_button_width,
                     tab_height);
         IndentPressedBitmap(&rect, close_button_state);
         dc.DrawBitmap(bmp, rect.x, rect.y, true);

-        
+

         *out_button_rect = rect;
     }
         *out_button_rect = rect;
     }

-    
+

     *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
     *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);

-    
+

     dc.DestroyClippingRegion();
 }
 
     dc.DestroyClippingRegion();
 }
 


@@ -486,31 +547,45 @@ int wxAuiDefaultTabArt::GetIndentSize()
 wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
                                       wxWindow* WXUNUSED(wnd),
                                       const wxString& caption,
 wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
                                       wxWindow* WXUNUSED(wnd),
                                       const wxString& caption,

+                                      const wxBitmap& bitmap,

                                       bool WXUNUSED(active),
                                       int close_button_state,
                                       int* x_extent)
 {
     wxCoord measured_textx, measured_texty, tmp;
                                       bool WXUNUSED(active),
                                       int close_button_state,
                                       int* x_extent)
 {
     wxCoord measured_textx, measured_texty, tmp;

-    
+

     dc.SetFont(m_measuring_font);
     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
     dc.SetFont(m_measuring_font);
     dc.GetTextExtent(caption, &measured_textx, &measured_texty);

-    
+

     dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);
     dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);

-    
-    wxCoord tab_width = measured_textx + 5;
-    wxCoord tab_height = measured_texty + 10;

 
 

+    // add padding around the text
+    wxCoord tab_width = measured_textx;
+    wxCoord tab_height = measured_texty;
+
+    // if the close button is showing, add space for it

     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)

-        tab_width += m_active_close_bmp.GetWidth() + 8;
+        tab_width += m_active_close_bmp.GetWidth() + 3;

 
 

+    // if there's a bitmap, add space for it
+    if (bitmap.IsOk())
+    {
+        tab_width += bitmap.GetWidth();
+        tab_width += 3; // right side bitmap padding
+        tab_height = wxMax(tab_height, bitmap.GetHeight());
+    }
+
+    // add padding
+    tab_width += 16;
+    tab_height += 10;

 
     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
     {
         tab_width = m_fixed_tab_width;
     }
 
     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
     {
         tab_width = m_fixed_tab_width;
     }

-    
+

     *x_extent = tab_width;
     *x_extent = tab_width;

-    
+

     return wxSize(tab_width, tab_height);
 }
 
     return wxSize(tab_width, tab_height);
 }
 


@@ -521,52 +596,45 @@ void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
                                     int bitmap_id,
                                     int button_state,
                                     int orientation,
                                     int bitmap_id,
                                     int button_state,
                                     int orientation,

-                                    const wxBitmap& bitmap_override,

                                     wxRect* out_rect)
 {
     wxBitmap bmp;
     wxRect rect;
                                     wxRect* out_rect)
 {
     wxBitmap bmp;
     wxRect rect;

-    
-    if (bitmap_override.IsOk())
-    {
-        bmp = bitmap_override;
-    }
-     else
+
+    switch (bitmap_id)

     {
     {

-        switch (bitmap_id)
-        {
-            case wxAUI_BUTTON_CLOSE:
-                if (button_state & wxAUI_BUTTON_STATE_DISABLED)
-                    bmp = m_disabled_close_bmp;
-                     else
-                    bmp = m_active_close_bmp;
-                break;
-            case wxAUI_BUTTON_LEFT:
-                if (button_state & wxAUI_BUTTON_STATE_DISABLED)
-                    bmp = m_disabled_left_bmp;
-                     else
-                    bmp = m_active_left_bmp;
-                break;
-            case wxAUI_BUTTON_RIGHT:
-                if (button_state & wxAUI_BUTTON_STATE_DISABLED)
-                    bmp = m_disabled_right_bmp;
-                     else
-                    bmp = m_active_right_bmp;
-                break;
-            case wxAUI_BUTTON_WINDOWLIST:
-                if (button_state & wxAUI_BUTTON_STATE_DISABLED)
-                    bmp = m_disabled_windowlist_bmp;
-                     else
-                    bmp = m_active_windowlist_bmp;
-                break;
-        }
+        case wxAUI_BUTTON_CLOSE:
+            if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+                bmp = m_disabled_close_bmp;
+                 else
+                bmp = m_active_close_bmp;
+            break;
+        case wxAUI_BUTTON_LEFT:
+            if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+                bmp = m_disabled_left_bmp;
+                 else
+                bmp = m_active_left_bmp;
+            break;
+        case wxAUI_BUTTON_RIGHT:
+            if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+                bmp = m_disabled_right_bmp;
+                 else
+                bmp = m_active_right_bmp;
+            break;
+        case wxAUI_BUTTON_WINDOWLIST:
+            if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+                bmp = m_disabled_windowlist_bmp;
+                 else
+                bmp = m_active_windowlist_bmp;
+            break;

     }
 
     }
 

+

     if (!bmp.IsOk())
         return;
     if (!bmp.IsOk())
         return;

-        
+

     rect = in_rect;
     rect = in_rect;

-    
+

     if (orientation == wxLEFT)
     {
         rect.SetX(in_rect.x);
     if (orientation == wxLEFT)
     {
         rect.SetX(in_rect.x);


@@ -580,69 +648,106 @@ void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
                       ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
                       bmp.GetWidth(), bmp.GetHeight());
     }
                       ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
                       bmp.GetWidth(), bmp.GetHeight());
     }

-    
+

     IndentPressedBitmap(&rect, button_state);
     dc.DrawBitmap(bmp, rect.x, rect.y, true);
     IndentPressedBitmap(&rect, button_state);
     dc.DrawBitmap(bmp, rect.x, rect.y, true);

-    
+

     *out_rect = rect;
 }
 
 
     *out_rect = rect;
 }
 
 

-int wxAuiDefaultTabArt::ShowWindowList(wxWindow* wnd,
-                                       const wxArrayString& items,
-                                       int active_idx)
+int wxAuiDefaultTabArt::ShowDropDown(wxWindow* wnd,
+                                     const wxAuiNotebookPageArray& pages,
+                                     int active_idx)

 {
 {

-       wxMenu menuPopup;
+    wxMenu menuPopup;

 
 

-    size_t i, count = items.GetCount();
+    size_t i, count = pages.GetCount();

     for (i = 0; i < count; ++i)
     {
     for (i = 0; i < count; ++i)
     {

-        menuPopup.AppendCheckItem(1000+i, items.Item(i));
+        const wxAuiNotebookPage& page = pages.Item(i);
+        wxString caption = page.caption;
+
+        // if there is no caption, make it a space.  This will prevent
+        // an assert in the menu code.
+        if (caption.IsEmpty())
+            caption = wxT(" ");
+
+        menuPopup.AppendCheckItem(1000+i, caption);

     }
     }

-    
+

     if (active_idx != -1)
     {
         menuPopup.Check(1000+active_idx, true);
     }
     if (active_idx != -1)
     {
         menuPopup.Check(1000+active_idx, true);
     }

-    
-    // find out where to put the popup menu of window
-    // items.  Subtract 100 for now to center the menu
-    // a bit, until a better mechanism can be implemented
+
+    // find out where to put the popup menu of window items

     wxPoint pt = ::wxGetMousePosition();
     pt = wnd->ScreenToClient(pt);
     wxPoint pt = ::wxGetMousePosition();
     pt = wnd->ScreenToClient(pt);

-    if (pt.x < 100)
-        pt.x = 0;
-         else
-        pt.x -= 100;
-    
+

     // find out the screen coordinate at the bottom of the tab ctrl
     wxRect cli_rect = wnd->GetClientRect();
     pt.y = cli_rect.y + cli_rect.height;
     // find out the screen coordinate at the bottom of the tab ctrl
     wxRect cli_rect = wnd->GetClientRect();
     pt.y = cli_rect.y + cli_rect.height;

-    
+

     wxAuiCommandCapture* cc = new wxAuiCommandCapture;
     wnd->PushEventHandler(cc);
     wnd->PopupMenu(&menuPopup, pt);
     int command = cc->GetCommandId();
     wnd->PopEventHandler(true);
     wxAuiCommandCapture* cc = new wxAuiCommandCapture;
     wnd->PushEventHandler(cc);
     wnd->PopupMenu(&menuPopup, pt);
     int command = cc->GetCommandId();
     wnd->PopEventHandler(true);

-    
+

     if (command >= 1000)
         return command-1000;
     if (command >= 1000)
         return command-1000;

-        
+

     return -1;
 }
 
     return -1;
 }
 

-int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd)
+int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
+                                           const wxAuiNotebookPageArray& pages,
+                                           const wxSize& required_bmp_size)

 {
     wxClientDC dc(wnd);
     dc.SetFont(m_measuring_font);
 {
     wxClientDC dc(wnd);
     dc.SetFont(m_measuring_font);

-    int x_ext = 0;
-    wxSize s = GetTabSize(dc,
-                          wnd,
-                          wxT("ABCDEFGHIj"),
-                          true,
-                          wxAUI_BUTTON_STATE_HIDDEN,
-                          &x_ext);
-    return s.y+3;
+
+    // sometimes a standard bitmap size needs to be enforced, especially
+    // if some tabs have bitmaps and others don't.  This is important because
+    // it prevents the tab control from resizing when tabs are added.
+    wxBitmap measure_bmp;
+    if (required_bmp_size.IsFullySpecified())
+    {
+        measure_bmp.Create(required_bmp_size.x,
+                           required_bmp_size.y);
+    }
+
+
+    int max_y = 0;
+    size_t i, page_count = pages.GetCount();
+    for (i = 0; i < page_count; ++i)
+    {
+        wxAuiNotebookPage& page = pages.Item(i);
+
+        wxBitmap bmp;
+        if (measure_bmp.IsOk())
+            bmp = measure_bmp;
+             else
+            bmp = page.bitmap;
+
+        // we don't use the caption text because we don't
+        // want tab heights to be different in the case
+        // of a very short piece of text on one tab and a very
+        // tall piece of text on another tab
+        int x_ext = 0;
+        wxSize s = GetTabSize(dc,
+                              wnd,
+                              wxT("ABCDEFGHIj"),
+                              bmp,
+                              true,
+                              wxAUI_BUTTON_STATE_HIDDEN,
+                              &x_ext);
+
+        max_y = wxMax(max_y, s.y);
+    }
+
+    return max_y+2;

 }
 
 void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
 }
 
 void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)


@@ -675,7 +780,7 @@ wxAuiSimpleTabArt::wxAuiSimpleTabArt()
 
     wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 
 
     wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 

-    wxColour background_colour = StepColour(base_colour, 95);
+    wxColour background_colour = base_colour;

     wxColour normaltab_colour = base_colour;
     wxColour selectedtab_colour = *wxWHITE;
 
     wxColour normaltab_colour = base_colour;
     wxColour selectedtab_colour = *wxWHITE;
 


@@ -684,19 +789,19 @@ wxAuiSimpleTabArt::wxAuiSimpleTabArt()
     m_normal_bkpen = wxPen(normaltab_colour);
     m_selected_bkbrush = wxBrush(selectedtab_colour);
     m_selected_bkpen = wxPen(selectedtab_colour);
     m_normal_bkpen = wxPen(normaltab_colour);
     m_selected_bkbrush = wxBrush(selectedtab_colour);
     m_selected_bkpen = wxPen(selectedtab_colour);

-    
-    m_active_close_bmp = BitmapFromBits(close_bits, 16, 16, *wxBLACK);
-    m_disabled_close_bmp = BitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
-    
-    m_active_left_bmp = BitmapFromBits(left_bits, 16, 16, *wxBLACK);
-    m_disabled_left_bmp = BitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
-    
-    m_active_right_bmp = BitmapFromBits(right_bits, 16, 16, *wxBLACK);
-    m_disabled_right_bmp = BitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
-    
-    m_active_windowlist_bmp = BitmapFromBits(list_bits, 16, 16, *wxBLACK);
-    m_disabled_windowlist_bmp = BitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
-    
+
+    m_active_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
+    m_disabled_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
+
+    m_active_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
+    m_disabled_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
+
+    m_active_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
+    m_disabled_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
+
+    m_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
+    m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
+

 }
 
 wxAuiSimpleTabArt::~wxAuiSimpleTabArt()
 }
 
 wxAuiSimpleTabArt::~wxAuiSimpleTabArt()


@@ -718,20 +823,26 @@ void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
                                       size_t tab_count)
 {
     m_fixed_tab_width = 100;
                                       size_t tab_count)
 {
     m_fixed_tab_width = 100;

-    
-    int tot_width = tab_ctrl_size.x;
+
+    int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
+
+    if (m_flags & wxAUI_NB_CLOSE_BUTTON)
+        tot_width -= m_active_close_bmp.GetWidth();
+    if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
+        tot_width -= m_active_windowlist_bmp.GetWidth();
+

     if (tab_count > 0)
     {
         m_fixed_tab_width = tot_width/(int)tab_count;
     }
     if (tab_count > 0)
     {
         m_fixed_tab_width = tot_width/(int)tab_count;
     }

-    
-    
+
+

     if (m_fixed_tab_width < 100)
         m_fixed_tab_width = 100;
     if (m_fixed_tab_width < 100)
         m_fixed_tab_width = 100;

-        
+

     if (m_fixed_tab_width > tot_width/2)
         m_fixed_tab_width = tot_width/2;
     if (m_fixed_tab_width > tot_width/2)
         m_fixed_tab_width = tot_width/2;

-        
+

     if (m_fixed_tab_width > 220)
         m_fixed_tab_width = 220;
 }
     if (m_fixed_tab_width > 220)
         m_fixed_tab_width = 220;
 }


@@ -762,9 +873,8 @@ void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,
 
 void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
                                 wxWindow* wnd,
 
 void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
                                 wxWindow* wnd,

+                                const wxAuiNotebookPage& page,

                                 const wxRect& in_rect,
                                 const wxRect& in_rect,

-                                const wxString& caption_text,
-                                bool active,

                                 int close_button_state,
                                 wxRect* out_tab_rect,
                                 wxRect* out_button_rect,
                                 int close_button_state,
                                 wxRect* out_tab_rect,
                                 wxRect* out_button_rect,


@@ -773,29 +883,37 @@ void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
     wxCoord normal_textx, normal_texty;
     wxCoord selected_textx, selected_texty;
     wxCoord textx, texty;
     wxCoord normal_textx, normal_texty;
     wxCoord selected_textx, selected_texty;
     wxCoord textx, texty;

-    
+

     // if the caption is empty, measure some temporary text
     // if the caption is empty, measure some temporary text

-    wxString caption = caption_text;
-    if (caption_text.empty())
+    wxString caption = page.caption;
+    if (caption.empty())

         caption = wxT("Xj");
         caption = wxT("Xj");

-            
+

     dc.SetFont(m_selected_font);
     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
     dc.SetFont(m_selected_font);
     dc.GetTextExtent(caption, &selected_textx, &selected_texty);

-    
+

     dc.SetFont(m_normal_font);
     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
     dc.SetFont(m_normal_font);
     dc.GetTextExtent(caption, &normal_textx, &normal_texty);

-        
+

     // figure out the size of the tab
     // figure out the size of the tab

-    wxSize tab_size = GetTabSize(dc, wnd, caption, active, close_button_state, x_extent);
+    wxSize tab_size = GetTabSize(dc,
+                                 wnd,
+                                 page.caption,
+                                 page.bitmap,
+                                 page.active,
+                                 close_button_state,
+                                 x_extent);

 
     wxCoord tab_height = tab_size.y;
     wxCoord tab_width = tab_size.x;
     wxCoord tab_x = in_rect.x;
     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
 
 
     wxCoord tab_height = tab_size.y;
     wxCoord tab_width = tab_size.x;
     wxCoord tab_x = in_rect.x;
     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
 

+    caption = page.caption;
+

     // select pen, brush and font for the tab to be drawn
 
     // select pen, brush and font for the tab to be drawn
 

-    if (active)
+    if (page.active)

     {
         dc.SetPen(m_selected_bkpen);
         dc.SetBrush(m_selected_bkbrush);
     {
         dc.SetPen(m_selected_bkpen);
         dc.SetBrush(m_selected_bkbrush);


@@ -832,12 +950,12 @@ void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
 
     dc.SetClippingRegion(in_rect);
 
 
     dc.SetClippingRegion(in_rect);
 

-    dc.DrawPolygon(6, points);
+    dc.DrawPolygon(WXSIZEOF(points) - 1, points);

 
     dc.SetPen(*wxGREY_PEN);
 
 
     dc.SetPen(*wxGREY_PEN);
 

-    //dc.DrawLines(active ? 6 : 7, points);
-    dc.DrawLines(7, points);
+    //dc.DrawLines(active ? WXSIZEOF(points) - 1 : WXSIZEOF(points), points);
+    dc.DrawLines(WXSIZEOF(points), points);

 
 
     int text_offset;
 
 
     int text_offset;


@@ -852,13 +970,13 @@ void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
     {
         text_offset = tab_x + (tab_height/3) + (tab_width/2) - (textx/2);
     }
     {
         text_offset = tab_x + (tab_height/3) + (tab_width/2) - (textx/2);
     }

-    
+

     // set minimum text offset
     if (text_offset < tab_x + tab_height)
         text_offset = tab_x + tab_height;
 
     // chop text if necessary
     // set minimum text offset
     if (text_offset < tab_x + tab_height)
         text_offset = tab_x + tab_height;
 
     // chop text if necessary

-    wxString draw_text = ChopText(dc,
+    wxString draw_text = wxAuiChopText(dc,

                           caption,
                           tab_width - (text_offset-tab_x) - close_button_width);
 
                           caption,
                           tab_width - (text_offset-tab_x) - close_button_width);
 


@@ -872,23 +990,23 @@ void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {
         wxBitmap bmp;
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
     {
         wxBitmap bmp;

-        if (active)
+        if (page.active)

             bmp = m_active_close_bmp;
              else
             bmp = m_disabled_close_bmp;
             bmp = m_active_close_bmp;
              else
             bmp = m_disabled_close_bmp;

-            
+

         wxRect rect(tab_x + tab_width - close_button_width - 1,
                     tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
                     close_button_width,
                     tab_height - 1);
         DrawButtons(dc, rect, bmp, *wxWHITE, close_button_state);
         wxRect rect(tab_x + tab_width - close_button_width - 1,
                     tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
                     close_button_width,
                     tab_height - 1);
         DrawButtons(dc, rect, bmp, *wxWHITE, close_button_state);

-        
+

         *out_button_rect = rect;
     }
 
 
     *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
         *out_button_rect = rect;
     }
 
 
     *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);

-    
+

     dc.DestroyClippingRegion();
 }
 
     dc.DestroyClippingRegion();
 }
 


@@ -900,26 +1018,27 @@ int wxAuiSimpleTabArt::GetIndentSize()
 wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
                                      wxWindow* WXUNUSED(wnd),
                                      const wxString& caption,
 wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
                                      wxWindow* WXUNUSED(wnd),
                                      const wxString& caption,

+                                     const wxBitmap& WXUNUSED(bitmap),

                                      bool WXUNUSED(active),
                                      int close_button_state,
                                      int* x_extent)
 {
     wxCoord measured_textx, measured_texty;
                                      bool WXUNUSED(active),
                                      int close_button_state,
                                      int* x_extent)
 {
     wxCoord measured_textx, measured_texty;

-    
+

     dc.SetFont(m_measuring_font);
     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
     dc.SetFont(m_measuring_font);
     dc.GetTextExtent(caption, &measured_textx, &measured_texty);

-    
+

     wxCoord tab_height = measured_texty + 4;
     wxCoord tab_width = measured_textx + tab_height + 5;
 
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
         tab_width += m_active_close_bmp.GetWidth();
     wxCoord tab_height = measured_texty + 4;
     wxCoord tab_width = measured_textx + tab_height + 5;
 
     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
         tab_width += m_active_close_bmp.GetWidth();

-        
+

     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
     {
         tab_width = m_fixed_tab_width;
     }
     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
     {
         tab_width = m_fixed_tab_width;
     }

-    
+

     *x_extent = tab_width - (tab_height/2) - 1;
 
     return wxSize(tab_width, tab_height);
     *x_extent = tab_width - (tab_height/2) - 1;
 
     return wxSize(tab_width, tab_height);


@@ -932,52 +1051,44 @@ void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
                                    int bitmap_id,
                                    int button_state,
                                    int orientation,
                                    int bitmap_id,
                                    int button_state,
                                    int orientation,

-                                   const wxBitmap& bitmap_override,

                                    wxRect* out_rect)
 {
     wxBitmap bmp;
     wxRect rect;
                                    wxRect* out_rect)
 {
     wxBitmap bmp;
     wxRect rect;

-    
-    if (bitmap_override.IsOk())
-    {
-        bmp = bitmap_override;
-    }
-     else
+
+    switch (bitmap_id)

     {
     {

-        switch (bitmap_id)
-        {
-            case wxAUI_BUTTON_CLOSE:
-                if (button_state & wxAUI_BUTTON_STATE_DISABLED)
-                    bmp = m_disabled_close_bmp;
-                     else
-                    bmp = m_active_close_bmp;
-                break;
-            case wxAUI_BUTTON_LEFT:
-                if (button_state & wxAUI_BUTTON_STATE_DISABLED)
-                    bmp = m_disabled_left_bmp;
-                     else
-                    bmp = m_active_left_bmp;
-                break;
-            case wxAUI_BUTTON_RIGHT:
-                if (button_state & wxAUI_BUTTON_STATE_DISABLED)
-                    bmp = m_disabled_right_bmp;
-                     else
-                    bmp = m_active_right_bmp;
-                break;
-            case wxAUI_BUTTON_WINDOWLIST:
-                if (button_state & wxAUI_BUTTON_STATE_DISABLED)
-                    bmp = m_disabled_windowlist_bmp;
-                     else
-                    bmp = m_active_windowlist_bmp;
-                break;
-        }
+        case wxAUI_BUTTON_CLOSE:
+            if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+                bmp = m_disabled_close_bmp;
+                 else
+                bmp = m_active_close_bmp;
+            break;
+        case wxAUI_BUTTON_LEFT:
+            if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+                bmp = m_disabled_left_bmp;
+                 else
+                bmp = m_active_left_bmp;
+            break;
+        case wxAUI_BUTTON_RIGHT:
+            if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+                bmp = m_disabled_right_bmp;
+                 else
+                bmp = m_active_right_bmp;
+            break;
+        case wxAUI_BUTTON_WINDOWLIST:
+            if (button_state & wxAUI_BUTTON_STATE_DISABLED)
+                bmp = m_disabled_windowlist_bmp;
+                 else
+                bmp = m_active_windowlist_bmp;
+            break;

     }
 
     if (!bmp.IsOk())
         return;
     }
 
     if (!bmp.IsOk())
         return;

-        
+

     rect = in_rect;
     rect = in_rect;

-    
+

     if (orientation == wxLEFT)
     {
         rect.SetX(in_rect.x);
     if (orientation == wxLEFT)
     {
         rect.SetX(in_rect.x);


@@ -991,31 +1102,32 @@ void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
                       ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
                       bmp.GetWidth(), bmp.GetHeight());
     }
                       ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
                       bmp.GetWidth(), bmp.GetHeight());
     }

-    
-        
+
+

     DrawButtons(dc, rect, bmp, *wxWHITE, button_state);
     DrawButtons(dc, rect, bmp, *wxWHITE, button_state);

-    
+

     *out_rect = rect;
 }
 
 
     *out_rect = rect;
 }
 
 

-int wxAuiSimpleTabArt::ShowWindowList(wxWindow* wnd,
-                                      const wxArrayString& items,
-                                      int active_idx)
+int wxAuiSimpleTabArt::ShowDropDown(wxWindow* wnd,
+                                    const wxAuiNotebookPageArray& pages,
+                                    int active_idx)

 {
 {

-       wxMenu menuPopup;
+    wxMenu menuPopup;

 
 

-    size_t i, count = items.GetCount();
+    size_t i, count = pages.GetCount();

     for (i = 0; i < count; ++i)
     {
     for (i = 0; i < count; ++i)
     {

-        menuPopup.AppendCheckItem(1000+i, items.Item(i));
+        const wxAuiNotebookPage& page = pages.Item(i);
+        menuPopup.AppendCheckItem(1000+i, page.caption);

     }
     }

-    
+

     if (active_idx != -1)
     {
         menuPopup.Check(1000+active_idx, true);
     }
     if (active_idx != -1)
     {
         menuPopup.Check(1000+active_idx, true);
     }

-    
+

     // find out where to put the popup menu of window
     // items.  Subtract 100 for now to center the menu
     // a bit, until a better mechanism can be implemented
     // find out where to put the popup menu of window
     // items.  Subtract 100 for now to center the menu
     // a bit, until a better mechanism can be implemented


@@ -1025,24 +1137,26 @@ int wxAuiSimpleTabArt::ShowWindowList(wxWindow* wnd,
         pt.x = 0;
          else
         pt.x -= 100;
         pt.x = 0;
          else
         pt.x -= 100;

-    
+

     // find out the screen coordinate at the bottom of the tab ctrl
     wxRect cli_rect = wnd->GetClientRect();
     pt.y = cli_rect.y + cli_rect.height;
     // find out the screen coordinate at the bottom of the tab ctrl
     wxRect cli_rect = wnd->GetClientRect();
     pt.y = cli_rect.y + cli_rect.height;

-    
+

     wxAuiCommandCapture* cc = new wxAuiCommandCapture;
     wnd->PushEventHandler(cc);
     wnd->PopupMenu(&menuPopup, pt);
     int command = cc->GetCommandId();
     wnd->PopEventHandler(true);
     wxAuiCommandCapture* cc = new wxAuiCommandCapture;
     wnd->PushEventHandler(cc);
     wnd->PopupMenu(&menuPopup, pt);
     int command = cc->GetCommandId();
     wnd->PopEventHandler(true);

-    
+

     if (command >= 1000)
         return command-1000;
     if (command >= 1000)
         return command-1000;

-        
+

     return -1;
 }
 
     return -1;
 }
 

-int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd)
+int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
+                                          const wxAuiNotebookPageArray& WXUNUSED(pages),
+                                          const wxSize& WXUNUSED(required_bmp_size))

 {
     wxClientDC dc(wnd);
     dc.SetFont(m_measuring_font);
 {
     wxClientDC dc(wnd);
     dc.SetFont(m_measuring_font);


@@ -1050,6 +1164,7 @@ int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd)
     wxSize s = GetTabSize(dc,
                           wnd,
                           wxT("ABCDEFGHIj"),
     wxSize s = GetTabSize(dc,
                           wnd,
                           wxT("ABCDEFGHIj"),

+                          wxNullBitmap,

                           true,
                           wxAUI_BUTTON_STATE_HIDDEN,
                           &x_ext);
                           true,
                           wxAUI_BUTTON_STATE_HIDDEN,
                           &x_ext);


@@ -1092,8 +1207,8 @@ wxAuiTabContainer::wxAuiTabContainer()
     m_tab_offset = 0;
     m_flags = 0;
     m_art = new wxAuiDefaultTabArt;
     m_tab_offset = 0;
     m_flags = 0;
     m_art = new wxAuiDefaultTabArt;

-    
-    AddButton(wxAUI_BUTTON_LEFT, wxLEFT);       
+
+    AddButton(wxAUI_BUTTON_LEFT, wxLEFT);

     AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
     AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
     AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
     AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
     AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
     AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);


@@ -1108,14 +1223,14 @@ void wxAuiTabContainer::SetArtProvider(wxAuiTabArt* art)
 {
     delete m_art;
     m_art = art;
 {
     delete m_art;
     m_art = art;

-    
+

     if (m_art)
     {
         m_art->SetFlags(m_flags);
     }
 }
 
     if (m_art)
     {
         m_art->SetFlags(m_flags);
     }
 }
 

-wxAuiTabArt* wxAuiTabContainer::GetArtProvider()
+wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const

 {
     return m_art;
 }
 {
     return m_art;
 }


@@ -1123,17 +1238,17 @@ wxAuiTabArt* wxAuiTabContainer::GetArtProvider()
 void wxAuiTabContainer::SetFlags(unsigned int flags)
 {
     m_flags = flags;
 void wxAuiTabContainer::SetFlags(unsigned int flags)
 {
     m_flags = flags;

-    
+

     // check for new close button settings
     // check for new close button settings

-    RemoveButton(wxAUI_BUTTON_LEFT);       
+    RemoveButton(wxAUI_BUTTON_LEFT);

     RemoveButton(wxAUI_BUTTON_RIGHT);
     RemoveButton(wxAUI_BUTTON_WINDOWLIST);
     RemoveButton(wxAUI_BUTTON_CLOSE);
     RemoveButton(wxAUI_BUTTON_RIGHT);
     RemoveButton(wxAUI_BUTTON_WINDOWLIST);
     RemoveButton(wxAUI_BUTTON_CLOSE);

-    
-    
+
+

     if (flags & wxAUI_NB_SCROLL_BUTTONS)
     {
     if (flags & wxAUI_NB_SCROLL_BUTTONS)
     {

-        AddButton(wxAUI_BUTTON_LEFT, wxLEFT);       
+        AddButton(wxAUI_BUTTON_LEFT, wxLEFT);

         AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
     }
 
         AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
     }
 


@@ -1141,12 +1256,12 @@ void wxAuiTabContainer::SetFlags(unsigned int flags)
     {
         AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
     }
     {
         AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
     }

-    
+

     if (flags & wxAUI_NB_CLOSE_BUTTON)
     {
         AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
     }
     if (flags & wxAUI_NB_CLOSE_BUTTON)
     {
         AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
     }

-    
+

     if (m_art)
     {
         m_art->SetFlags(m_flags);
     if (m_art)
     {
         m_art->SetFlags(m_flags);


@@ -1177,7 +1292,7 @@ void wxAuiTabContainer::SetMeasuringFont(const wxFont& font)
 void wxAuiTabContainer::SetRect(const wxRect& rect)
 {
     m_rect = rect;
 void wxAuiTabContainer::SetRect(const wxRect& rect)
 {
     m_rect = rect;

-    
+

     if (m_art)
     {
         m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());
     if (m_art)
     {
         m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());


@@ -1198,7 +1313,7 @@ bool wxAuiTabContainer::AddPage(wxWindow* page,
     {
         m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
     }
     {
         m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
     }

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -1220,7 +1335,7 @@ bool wxAuiTabContainer::InsertPage(wxWindow* page,
     {
         m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
     }
     {
         m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
     }

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -1230,16 +1345,16 @@ bool wxAuiTabContainer::MovePage(wxWindow* page,
     int idx = GetIdxFromWindow(page);
     if (idx == -1)
         return false;
     int idx = GetIdxFromWindow(page);
     if (idx == -1)
         return false;

-    
+

     // get page entry, make a copy of it
     wxAuiNotebookPage p = GetPage(idx);
     // get page entry, make a copy of it
     wxAuiNotebookPage p = GetPage(idx);

-    
+

     // remove old page entry
     RemovePage(page);
     // remove old page entry
     RemovePage(page);

-    
+

     // insert page where it should be
     InsertPage(page, p, new_idx);
     // insert page where it should be
     InsertPage(page, p, new_idx);

-        
+

     return true;
 }
 
     return true;
 }
 


@@ -1252,13 +1367,13 @@ bool wxAuiTabContainer::RemovePage(wxWindow* wnd)
         if (page.window == wnd)
         {
             m_pages.RemoveAt(i);
         if (page.window == wnd)
         {
             m_pages.RemoveAt(i);

-            
+

             // let the art provider know how many pages we have
             if (m_art)
             {
                 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
             }
             // let the art provider know how many pages we have
             if (m_art)
             {
                 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
             }

-             
+

             return true;
         }
     }
             return true;
         }
     }


@@ -1329,14 +1444,14 @@ wxWindow* wxAuiTabContainer::GetWindowFromIdx(size_t idx) const
 
 int wxAuiTabContainer::GetIdxFromWindow(wxWindow* wnd) const
 {
 
 int wxAuiTabContainer::GetIdxFromWindow(wxWindow* wnd) const
 {

-    size_t i, page_count = m_pages.GetCount();
-    for (i = 0; i < page_count; ++i)
+    const size_t page_count = m_pages.GetCount();
+    for ( size_t i = 0; i < page_count; ++i )

     {
         wxAuiNotebookPage& page = m_pages.Item(i);
         if (page.window == wnd)
             return i;
     }
     {
         wxAuiNotebookPage& page = m_pages.Item(i);
         if (page.window == wnd)
             return i;
     }

-    return -1;
+    return wxNOT_FOUND;

 }
 
 wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx)
 }
 
 wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx)


@@ -1346,6 +1461,13 @@ wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx)
     return m_pages[idx];
 }
 
     return m_pages[idx];
 }
 

+const wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx) const
+{
+    wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
+
+    return m_pages[idx];
+}
+

 wxAuiNotebookPageArray& wxAuiTabContainer::GetPages()
 {
     return m_pages;
 wxAuiNotebookPageArray& wxAuiTabContainer::GetPages()
 {
     return m_pages;


@@ -1405,6 +1527,9 @@ void wxAuiTabContainer::SetTabOffset(size_t offset)
 // provide custom drawing capabilities
 void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 {
 // provide custom drawing capabilities
 void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 {

+    if (!raw_dc || !raw_dc->IsOk())
+        return;
+

     wxMemoryDC dc;
     wxBitmap bmp;
     size_t i;
     wxMemoryDC dc;
     wxBitmap bmp;
     size_t i;


@@ -1415,6 +1540,8 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
     bmp.Create(m_rect.GetWidth(), m_rect.GetHeight());
     dc.SelectObject(bmp);
 
     bmp.Create(m_rect.GetWidth(), m_rect.GetHeight());
     dc.SelectObject(bmp);
 

+    if (!dc.IsOk())
+        return;

 
     // find out if size of tabs is larger than can be
     // afforded on screen
 
     // find out if size of tabs is larger than can be
     // afforded on screen


@@ -1423,7 +1550,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
     for (i = 0; i < page_count; ++i)
     {
         wxAuiNotebookPage& page = m_pages.Item(i);
     for (i = 0; i < page_count; ++i)
     {
         wxAuiNotebookPage& page = m_pages.Item(i);

-        
+

         // determine if a close button is on this tab
         bool close_button = false;
         if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
         // determine if a close button is on this tab
         bool close_button = false;
         if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||


@@ -1431,23 +1558,24 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         {
             close_button = true;
         }
         {
             close_button = true;
         }

-        
-    
+
+

         int x_extent = 0;
         wxSize size = m_art->GetTabSize(dc,
                             wnd,
                             page.caption,
         int x_extent = 0;
         wxSize size = m_art->GetTabSize(dc,
                             wnd,
                             page.caption,

+                            page.bitmap,

                             page.active,
                             close_button ?
                               wxAUI_BUTTON_STATE_NORMAL :
                               wxAUI_BUTTON_STATE_HIDDEN,
                             &x_extent);
                             page.active,
                             close_button ?
                               wxAUI_BUTTON_STATE_NORMAL :
                               wxAUI_BUTTON_STATE_HIDDEN,
                             &x_extent);

-        
+

         if (i+1 < page_count)
             total_width += x_extent;
              else
             total_width += size.x;
         if (i+1 < page_count)
             total_width += x_extent;
              else
             total_width += size.x;

-            
+

         if (i >= m_tab_offset)
         {
             if (i+1 < page_count)
         if (i >= m_tab_offset)
         {
             if (i+1 < page_count)


@@ -1456,7 +1584,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                 visible_width += size.x;
         }
     }
                 visible_width += size.x;
         }
     }

-    
+

     if (total_width > m_rect.GetWidth() || m_tab_offset != 0)
     {
         // show left/right buttons
     if (total_width > m_rect.GetWidth() || m_tab_offset != 0)
     {
         // show left/right buttons


@@ -1512,7 +1640,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
     // draw buttons
     int left_buttons_width = 0;
     int right_buttons_width = 0;
     // draw buttons
     int left_buttons_width = 0;
     int right_buttons_width = 0;

-    
+

     int offset = 0;
 
     // draw the buttons on the right side
     int offset = 0;
 
     // draw the buttons on the right side


@@ -1520,12 +1648,12 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
     for (i = 0; i < button_count; ++i)
     {
         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
     for (i = 0; i < button_count; ++i)
     {
         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);

-        
+

         if (button.location != wxRIGHT)
             continue;
         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
             continue;
         if (button.location != wxRIGHT)
             continue;
         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
             continue;

-                
+

         wxRect button_rect = m_rect;
         button_rect.SetY(1);
         button_rect.SetWidth(offset);
         wxRect button_rect = m_rect;
         button_rect.SetY(1);
         button_rect.SetWidth(offset);


@@ -1536,7 +1664,6 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                           button.id,
                           button.cur_state,
                           wxRIGHT,
                           button.id,
                           button.cur_state,
                           wxRIGHT,

-                          wxNullBitmap,

                           &button.rect);
 
         offset -= button.rect.GetWidth();
                           &button.rect);
 
         offset -= button.rect.GetWidth();


@@ -1546,18 +1673,18 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 
 
     offset = 0;
 
 
     offset = 0;

-    
+

     // draw the buttons on the left side
 
     for (i = 0; i < button_count; ++i)
     {
         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
     // draw the buttons on the left side
 
     for (i = 0; i < button_count; ++i)
     {
         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);

-        
+

         if (button.location != wxLEFT)
             continue;
         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
             continue;
         if (button.location != wxLEFT)
             continue;
         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
             continue;

-   
+

         wxRect button_rect(offset, 1, 1000, m_rect.height);
 
         m_art->DrawButton(dc,
         wxRect button_rect(offset, 1, 1000, m_rect.height);
 
         m_art->DrawButton(dc,


@@ -1566,19 +1693,24 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                           button.id,
                           button.cur_state,
                           wxLEFT,
                           button.id,
                           button.cur_state,
                           wxLEFT,

-                          wxNullBitmap,

                           &button.rect);
                           &button.rect);

-                          
+

         offset += button.rect.GetWidth();
         left_buttons_width += button.rect.GetWidth();
     }
 
     offset = left_buttons_width;
         offset += button.rect.GetWidth();
         left_buttons_width += button.rect.GetWidth();
     }
 
     offset = left_buttons_width;

-    
+

     if (offset == 0)
     if (offset == 0)

-        offset += m_art->GetIndentSize();     
-    
+        offset += m_art->GetIndentSize();
+
+

     // prepare the tab-close-button array
     // prepare the tab-close-button array

+    // make sure tab button entries which aren't used are marked as hidden
+    for (i = page_count; i < m_tab_close_buttons.GetCount(); ++i)
+        m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+
+    // make sure there are enough tab button entries to accommodate all tabs

     while (m_tab_close_buttons.GetCount() < page_count)
     {
         wxAuiTabContainerButton tempbtn;
     while (m_tab_close_buttons.GetCount() < page_count)
     {
         wxAuiTabContainerButton tempbtn;


@@ -1587,14 +1719,15 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         tempbtn.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
         m_tab_close_buttons.Add(tempbtn);
     }
         tempbtn.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
         m_tab_close_buttons.Add(tempbtn);
     }

-    
+
+
+    // buttons before the tab offset must be set to hidden

     for (i = 0; i < m_tab_offset; ++i)
     {
     for (i = 0; i < m_tab_offset; ++i)
     {

-        // buttons before the tab offset must be set to hidden

         m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
     }
         m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
     }

-        
-                         
+
+

     // draw the tabs
 
     size_t active = 999;
     // draw the tabs
 
     size_t active = 999;


@@ -1632,13 +1765,13 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         rect.x = offset;
         rect.width = m_rect.width - right_buttons_width - offset - 2;
 
         rect.x = offset;
         rect.width = m_rect.width - right_buttons_width - offset - 2;
 

-
+        if (rect.width <= 0)
+            break;

 
         m_art->DrawTab(dc,
                        wnd,
 
         m_art->DrawTab(dc,
                        wnd,

+                       page,

                        rect,
                        rect,

-                       page.caption,
-                       page.active,

                        tab_button.cur_state,
                        &page.rect,
                        &tab_button.rect,
                        tab_button.cur_state,
                        &page.rect,
                        &tab_button.rect,


@@ -1650,10 +1783,18 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
             active_offset = offset;
             active_rect = rect;
         }
             active_offset = offset;
             active_rect = rect;
         }

-        
+

         offset += x_extent;
     }
 
         offset += x_extent;
     }
 

+
+    // make sure to deactivate buttons which are off the screen to the right
+    for (++i; i < m_tab_close_buttons.GetCount(); ++i)
+    {
+        m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
+    }
+
+

     // draw the active tab again so it stands in the foreground
     if (active >= m_tab_offset && active < m_pages.GetCount())
     {
     // draw the active tab again so it stands in the foreground
     if (active >= m_tab_offset && active < m_pages.GetCount())
     {


@@ -1672,16 +1813,15 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         rect.x = active_offset;
         m_art->DrawTab(dc,
                        wnd,
         rect.x = active_offset;
         m_art->DrawTab(dc,
                        wnd,

+                       page,

                        active_rect,
                        active_rect,

-                       page.caption,
-                       page.active,

                        tab_button.cur_state,
                        &page.rect,
                        &tab_button.rect,
                        &x_extent);
     }
 
                        tab_button.cur_state,
                        &page.rect,
                        &tab_button.rect,
                        &x_extent);
     }
 

-    
+

     raw_dc->Blit(m_rect.x, m_rect.y,
                  m_rect.GetWidth(), m_rect.GetHeight(),
                  &dc, 0, 0);
     raw_dc->Blit(m_rect.x, m_rect.y,
                  m_rect.GetWidth(), m_rect.GetHeight(),
                  &dc, 0, 0);


@@ -1695,7 +1835,7 @@ bool wxAuiTabContainer::TabHitTest(int x, int y, wxWindow** hit) const
 {
     if (!m_rect.Contains(x,y))
         return false;
 {
     if (!m_rect.Contains(x,y))
         return false;

-    
+

     wxAuiTabContainerButton* btn = NULL;
     if (ButtonHitTest(x, y, &btn))
     {
     wxAuiTabContainerButton* btn = NULL;
     if (ButtonHitTest(x, y, &btn))
     {


@@ -1728,32 +1868,36 @@ bool wxAuiTabContainer::ButtonHitTest(int x, int y,
         return false;
 
     size_t i, button_count;
         return false;
 
     size_t i, button_count;

-    
-    
+
+

     button_count = m_buttons.GetCount();
     for (i = 0; i < button_count; ++i)
     {
         wxAuiTabContainerButton& button = m_buttons.Item(i);
     button_count = m_buttons.GetCount();
     for (i = 0; i < button_count; ++i)
     {
         wxAuiTabContainerButton& button = m_buttons.Item(i);

-        if (button.rect.Contains(x,y))
+        if (button.rect.Contains(x,y) &&
+            !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
+                                   wxAUI_BUTTON_STATE_DISABLED)))

         {
             if (hit)
                 *hit = &button;
             return true;
         }
     }
         {
             if (hit)
                 *hit = &button;
             return true;
         }
     }

-    
+

     button_count = m_tab_close_buttons.GetCount();
     for (i = 0; i < button_count; ++i)
     {
         wxAuiTabContainerButton& button = m_tab_close_buttons.Item(i);
     button_count = m_tab_close_buttons.GetCount();
     for (i = 0; i < button_count; ++i)
     {
         wxAuiTabContainerButton& button = m_tab_close_buttons.Item(i);

-        if (button.rect.Contains(x,y))
+        if (button.rect.Contains(x,y) &&
+            !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
+                                   wxAUI_BUTTON_STATE_DISABLED)))

         {
             if (hit)
                 *hit = &button;
             return true;
         }
     }
         {
             if (hit)
                 *hit = &button;
             return true;
         }
     }

-    
+

     return false;
 }
 
     return false;
 }
 


@@ -1798,7 +1942,8 @@ void wxAuiTabContainer::DoShowHide()
     for (i = 0; i < page_count; ++i)
     {
         wxAuiNotebookPage& page = pages.Item(i);
     for (i = 0; i < page_count; ++i)
     {
         wxAuiNotebookPage& page = pages.Item(i);

-        ShowWnd(page.window, page.active);
+        if (!page.active)
+            ShowWnd(page.window, false);

     }
 }
 
     }
 }
 


@@ -1816,10 +1961,11 @@ BEGIN_EVENT_TABLE(wxAuiTabCtrl, wxControl)
     EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
     EVT_SIZE(wxAuiTabCtrl::OnSize)
     EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
     EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
     EVT_SIZE(wxAuiTabCtrl::OnSize)
     EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)

+    EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDown)

     EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
     EVT_MOTION(wxAuiTabCtrl::OnMotion)
     EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
     EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
     EVT_MOTION(wxAuiTabCtrl::OnMotion)
     EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)

-    EVT_AUINOTEBOOK_BUTTON(-1, wxAuiTabCtrl::OnButton)
+    EVT_AUINOTEBOOK_BUTTON(wxID_ANY, wxAuiTabCtrl::OnButton)

 END_EVENT_TABLE()
 
 
 END_EVENT_TABLE()
 
 


@@ -1832,6 +1978,7 @@ wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent,
     m_click_pt = wxDefaultPosition;
     m_is_dragging = false;
     m_hover_button = NULL;
     m_click_pt = wxDefaultPosition;
     m_is_dragging = false;
     m_hover_button = NULL;

+    m_pressed_button = NULL;

 }
 
 wxAuiTabCtrl::~wxAuiTabCtrl()
 }
 
 wxAuiTabCtrl::~wxAuiTabCtrl()


@@ -1865,15 +2012,26 @@ void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
     m_click_pt = wxDefaultPosition;
     m_is_dragging = false;
     m_click_tab = NULL;
     m_click_pt = wxDefaultPosition;
     m_is_dragging = false;
     m_click_tab = NULL;

+    m_pressed_button = NULL;
+

 
     wxWindow* wnd;
     if (TabHitTest(evt.m_x, evt.m_y, &wnd))
     {
 
     wxWindow* wnd;
     if (TabHitTest(evt.m_x, evt.m_y, &wnd))
     {

-        wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
-        e.SetSelection(GetIdxFromWindow(wnd));
-        e.SetOldSelection(GetActivePage());
-        e.SetEventObject(this);
-        GetEventHandler()->ProcessEvent(e);
+        int new_selection = GetIdxFromWindow(wnd);
+
+        // wxAuiNotebooks always want to receive this event
+        // even if the tab is already active, because they may
+        // have multiple tab controls
+        if (new_selection != GetActivePage() ||
+            GetParent()->IsKindOf(CLASSINFO(wxAuiNotebook)))
+        {
+            wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
+            e.SetSelection(new_selection);
+            e.SetOldSelection(GetActivePage());
+            e.SetEventObject(this);
+            GetEventHandler()->ProcessEvent(e);
+        }

 
         m_click_pt.x = evt.m_x;
         m_click_pt.y = evt.m_y;
 
         m_click_pt.x = evt.m_x;
         m_click_pt.y = evt.m_y;


@@ -1882,13 +2040,14 @@ void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
 
     if (m_hover_button)
     {
 
     if (m_hover_button)
     {

-        m_hover_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
+        m_pressed_button = m_hover_button;
+        m_pressed_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;

         Refresh();
         Update();
     }
 }
 
         Refresh();
         Update();
     }
 }
 

-void wxAuiTabCtrl::OnLeftUp(wxMouseEvent&)
+void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)

 {
     if (GetCapture() == this)
         ReleaseMouse();
 {
     if (GetCapture() == this)
         ReleaseMouse();


@@ -1903,19 +2062,31 @@ void wxAuiTabCtrl::OnLeftUp(wxMouseEvent&)
         return;
     }
 
         return;
     }
 

-    if (m_hover_button)
+    if (m_pressed_button)

     {
     {

-        m_hover_button->cur_state = wxAUI_BUTTON_STATE_HOVER;
+        // make sure we're still clicking the button
+        wxAuiTabContainerButton* button = NULL;
+        if (!ButtonHitTest(evt.m_x, evt.m_y, &button))
+            return;
+
+        if (button != m_pressed_button)
+        {
+            m_pressed_button = NULL;
+            return;
+        }
+

         Refresh();
         Update();
 
         Refresh();
         Update();
 

-        if (!(m_hover_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
+        if (!(m_pressed_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))

         {
             wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
         {
             wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);

-            evt.SetInt(m_hover_button->id);
+            evt.SetInt(m_pressed_button->id);

             evt.SetEventObject(this);
             GetEventHandler()->ProcessEvent(evt);
         }
             evt.SetEventObject(this);
             GetEventHandler()->ProcessEvent(evt);
         }

+
+        m_pressed_button = NULL;

     }
 
     m_click_pt = wxDefaultPosition;
     }
 
     m_click_pt = wxDefaultPosition;


@@ -1938,7 +2109,7 @@ void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
             Refresh();
             Update();
         }
             Refresh();
             Update();
         }

-        
+

         if (button->cur_state != wxAUI_BUTTON_STATE_HOVER)
         {
             button->cur_state = wxAUI_BUTTON_STATE_HOVER;
         if (button->cur_state != wxAUI_BUTTON_STATE_HOVER)
         {
             button->cur_state = wxAUI_BUTTON_STATE_HOVER;


@@ -2004,7 +2175,7 @@ void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
 void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
 {
     int button = event.GetInt();
 void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
 {
     int button = event.GetInt();

-    
+

     if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
     {
         if (button == wxAUI_BUTTON_LEFT)
     if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
     {
         if (button == wxAUI_BUTTON_LEFT)


@@ -2025,17 +2196,8 @@ void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
     }
      else if (button == wxAUI_BUTTON_WINDOWLIST)
     {
     }
      else if (button == wxAUI_BUTTON_WINDOWLIST)
     {

-        wxArrayString as;
-        
-        size_t i, page_count = m_pages.GetCount();
-        for (i = 0; i < page_count; ++i)
-        {
-            wxAuiNotebookPage& page = m_pages.Item(i);
-            as.Add(page.caption);
-        }
+        int idx = GetArtProvider()->ShowDropDown(this, m_pages, GetActivePage());

 
 

-        int idx = GetArtProvider()->ShowWindowList(this, as, GetActivePage());
-        

         if (idx != -1)
         {
             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
         if (idx != -1)
         {
             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);


@@ -2141,29 +2303,27 @@ public:
 };
 
 
 };
 
 

-
+const int wxAuiBaseTabCtrlId = 5380;

 
 
 // -- wxAuiNotebook class implementation --
 
 BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
 
 
 // -- wxAuiNotebook class implementation --
 
 BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)

-    //EVT_ERASE_BACKGROUND(wxAuiNotebook::OnEraseBackground)
-    //EVT_SIZE(wxAuiNotebook::OnSize)
-    //EVT_LEFT_DOWN(wxAuiNotebook::OnLeftDown)
+    EVT_SIZE(wxAuiNotebook::OnSize)

     EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus)
     EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus)

-    EVT_COMMAND_RANGE(10000, 10100,
+    EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,

                       wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
                       wxAuiNotebook::OnTabClicked)
                       wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
                       wxAuiNotebook::OnTabClicked)

-    EVT_COMMAND_RANGE(10000, 10100,
+    EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,

                       wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
                       wxAuiNotebook::OnTabBeginDrag)
                       wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
                       wxAuiNotebook::OnTabBeginDrag)

-    EVT_COMMAND_RANGE(10000, 10100,
+    EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,

                       wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
                       wxAuiNotebook::OnTabEndDrag)
                       wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
                       wxAuiNotebook::OnTabEndDrag)

-    EVT_COMMAND_RANGE(10000, 10100,
+    EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,

                       wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
                       wxAuiNotebook::OnTabDragMotion)
                       wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
                       wxAuiNotebook::OnTabDragMotion)

-    EVT_COMMAND_RANGE(10000, 10100,
+    EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,

                       wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
                       wxAuiNotebook::OnTabButton)
 END_EVENT_TABLE()
                       wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
                       wxAuiNotebook::OnTabButton)
 END_EVENT_TABLE()


@@ -2171,9 +2331,11 @@ END_EVENT_TABLE()
 wxAuiNotebook::wxAuiNotebook()
 {
     m_curpage = -1;
 wxAuiNotebook::wxAuiNotebook()
 {
     m_curpage = -1;

-    m_tab_id_counter = 10000;
+    m_tab_id_counter = wxAuiBaseTabCtrlId;

     m_dummy_wnd = NULL;
     m_tab_ctrl_height = 20;
     m_dummy_wnd = NULL;
     m_tab_ctrl_height = 20;

+    m_requested_bmp_size = wxDefaultSize;
+    m_requested_tabctrl_height = -1;

 }
 
 wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
 }
 
 wxAuiNotebook::wxAuiNotebook(wxWindow *parent,


@@ -2182,6 +2344,9 @@ wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
                              const wxSize& size,
                              long style) : wxControl(parent, id, pos, size, style)
 {
                              const wxSize& size,
                              long style) : wxControl(parent, id, pos, size, style)
 {

+    m_dummy_wnd = NULL;
+    m_requested_bmp_size = wxDefaultSize;
+    m_requested_tabctrl_height = -1;

     InitNotebook(style);
 }
 
     InitNotebook(style);
 }
 


@@ -2204,11 +2369,11 @@ bool wxAuiNotebook::Create(wxWindow* parent,
 void wxAuiNotebook::InitNotebook(long style)
 {
     m_curpage = -1;
 void wxAuiNotebook::InitNotebook(long style)
 {
     m_curpage = -1;

-    m_tab_id_counter = 10000;
+    m_tab_id_counter = wxAuiBaseTabCtrlId;

     m_dummy_wnd = NULL;
     m_dummy_wnd = NULL;

-    m_tab_ctrl_height = 20;

     m_flags = (unsigned int)style;
     m_flags = (unsigned int)style;

-    
+    m_tab_ctrl_height = 20;
+

     m_normal_font = *wxNORMAL_FONT;
     m_selected_font = *wxNORMAL_FONT;
     m_selected_font.SetWeight(wxBOLD);
     m_normal_font = *wxNORMAL_FONT;
     m_selected_font = *wxNORMAL_FONT;
     m_selected_font.SetWeight(wxBOLD);


@@ -2220,9 +2385,11 @@ void wxAuiNotebook::InitNotebook(long style)
     m_dummy_wnd->Show(false);
 
     m_mgr.SetManagedWindow(this);
     m_dummy_wnd->Show(false);
 
     m_mgr.SetManagedWindow(this);

+    m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
+    m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint

 
     m_mgr.AddPane(m_dummy_wnd,
 
     m_mgr.AddPane(m_dummy_wnd,

-              wxAuiPaneInfo().Name(wxT("dummy")).Bottom().Show(false));
+              wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));

 
     m_mgr.Update();
 }
 
     m_mgr.Update();
 }


@@ -2235,10 +2402,98 @@ wxAuiNotebook::~wxAuiNotebook()
 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
 {
     m_tabs.SetArtProvider(art);
 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
 {
     m_tabs.SetArtProvider(art);

-    
-    // choose a default for the tab height
-    m_tab_ctrl_height = art->GetBestTabCtrlSize(this);
-    
+
+    UpdateTabCtrlHeight();
+}
+
+// SetTabCtrlHeight() is the highest-level override of the
+// tab height.  A call to this function effectively enforces a
+// specified tab ctrl height, overriding all other considerations,
+// such as text or bitmap height.  It overrides any call to
+// SetUniformBitmapSize().  Specifying a height of -1 reverts
+// any previous call and returns to the default behavior
+
+void wxAuiNotebook::SetTabCtrlHeight(int height)
+{
+    m_requested_tabctrl_height = height;
+
+    // if window is already initialized, recalculate the tab height
+    if (m_dummy_wnd)
+    {
+        UpdateTabCtrlHeight();
+    }
+}
+
+
+// SetUniformBitmapSize() ensures that all tabs will have
+// the same height, even if some tabs don't have bitmaps
+// Passing wxDefaultSize to this function will instruct
+// the control to use dynamic tab height-- so when a tab
+// with a large bitmap is added, the tab ctrl's height will
+// automatically increase to accommodate the bitmap
+
+void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
+{
+    m_requested_bmp_size = size;
+
+    // if window is already initialized, recalculate the tab height
+    if (m_dummy_wnd)
+    {
+        UpdateTabCtrlHeight();
+    }
+}
+
+// UpdateTabCtrlHeight() does the actual tab resizing. It's meant
+// to be used interally
+void wxAuiNotebook::UpdateTabCtrlHeight()
+{
+    // get the tab ctrl height we will use
+    int height = CalculateTabCtrlHeight();
+
+    // if the tab control height needs to change, update
+    // all of our tab controls with the new height
+    if (m_tab_ctrl_height != height)
+    {
+        wxAuiTabArt* art = m_tabs.GetArtProvider();
+
+        m_tab_ctrl_height = height;
+
+        wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
+        size_t i, pane_count = all_panes.GetCount();
+        for (i = 0; i < pane_count; ++i)
+        {
+            wxAuiPaneInfo& pane = all_panes.Item(i);
+            if (pane.name == wxT("dummy"))
+                continue;
+            wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
+            wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
+            tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
+            tabctrl->SetArtProvider(art->Clone());
+            tab_frame->DoSizing();
+        }
+    }
+}
+
+void wxAuiNotebook::UpdateHintWindowSize()
+{
+    wxSize size = CalculateNewSplitSize();
+
+    // the placeholder hint window should be set to this size
+    wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
+    if (info.IsOk())
+    {
+        info.MinSize(size);
+        info.BestSize(size);
+        m_dummy_wnd->SetSize(size);
+    }
+}
+
+
+// calculates the size of the new split
+wxSize wxAuiNotebook::CalculateNewSplitSize()
+{
+    // count number of tab controls
+    int tab_ctrl_count = 0;

     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
     size_t i, pane_count = all_panes.GetCount();
     for (i = 0; i < pane_count; ++i)
     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
     size_t i, pane_count = all_panes.GetCount();
     for (i = 0; i < pane_count; ++i)


@@ -2246,16 +2501,47 @@ void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
         wxAuiPaneInfo& pane = all_panes.Item(i);
         if (pane.name == wxT("dummy"))
             continue;
         wxAuiPaneInfo& pane = all_panes.Item(i);
         if (pane.name == wxT("dummy"))
             continue;

-        wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
-        wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
-        tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
-        tabctrl->SetArtProvider(art->Clone());
-        tab_frame->DoSizing();
+        tab_ctrl_count++;
+    }
+
+    wxSize new_split_size;
+
+    // if there is only one tab control, the first split
+    // should happen around the middle
+    if (tab_ctrl_count < 2)
+    {
+        new_split_size = GetClientSize();
+        new_split_size.x /= 2;
+        new_split_size.y /= 2;
+    }
+     else
+    {
+        // this is in place of a more complicated calculation
+        // that needs to be implemented
+        new_split_size = wxSize(180,180);

     }
     }

-    
+
+    return new_split_size;

 }
 
 }
 

-wxAuiTabArt* wxAuiNotebook::GetArtProvider()
+int wxAuiNotebook::CalculateTabCtrlHeight()
+{
+    // if a fixed tab ctrl height is specified,
+    // just return that instead of calculating a
+    // tab height
+    if (m_requested_tabctrl_height != -1)
+        return m_requested_tabctrl_height;
+
+    // find out new best tab height
+    wxAuiTabArt* art = m_tabs.GetArtProvider();
+
+    return art->GetBestTabCtrlSize(this,
+                                   m_tabs.GetPages(),
+                                   m_requested_bmp_size);
+}
+
+
+wxAuiTabArt* wxAuiNotebook::GetArtProvider() const

 {
     return m_tabs.GetArtProvider();
 }
 {
     return m_tabs.GetArtProvider();
 }


@@ -2263,14 +2549,14 @@ wxAuiTabArt* wxAuiNotebook::GetArtProvider()
 void wxAuiNotebook::SetWindowStyleFlag(long style)
 {
     wxControl::SetWindowStyleFlag(style);
 void wxAuiNotebook::SetWindowStyleFlag(long style)
 {
     wxControl::SetWindowStyleFlag(style);

-    
+

     m_flags = (unsigned int)style;
     m_flags = (unsigned int)style;

-    
+

     // if the control is already initialized
     if (m_mgr.GetManagedWindow() == (wxWindow*)this)
     {
         // let all of the tab children know about the new style
     // if the control is already initialized
     if (m_mgr.GetManagedWindow() == (wxWindow*)this)
     {
         // let all of the tab children know about the new style

-        
+

         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
         size_t i, pane_count = all_panes.GetCount();
         for (i = 0; i < pane_count; ++i)
         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
         size_t i, pane_count = all_panes.GetCount();
         for (i = 0; i < pane_count; ++i)


@@ -2278,8 +2564,10 @@ void wxAuiNotebook::SetWindowStyleFlag(long style)
             wxAuiPaneInfo& pane = all_panes.Item(i);
             if (pane.name == wxT("dummy"))
                 continue;
             wxAuiPaneInfo& pane = all_panes.Item(i);
             if (pane.name == wxT("dummy"))
                 continue;

-            wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
+            wxTabFrame* tabframe = (wxTabFrame*)pane.window;
+            wxAuiTabCtrl* tabctrl = tabframe->m_tabs;

             tabctrl->SetFlags(m_flags);
             tabctrl->SetFlags(m_flags);

+            tabframe->DoSizing();

             tabctrl->Refresh();
             tabctrl->Update();
         }
             tabctrl->Refresh();
             tabctrl->Update();
         }


@@ -2314,21 +2602,26 @@ bool wxAuiNotebook::InsertPage(size_t page_idx,
 
     m_tabs.InsertPage(page, info, page_idx);
 
 
     m_tabs.InsertPage(page, info, page_idx);
 

+    // if that was the first page added, even if
+    // select is false, it must become the "current page"
+    // (though no select events will be fired)
+    if (!select && m_tabs.GetPageCount() == 1)
+        select = true;
+        //m_curpage = GetPageIndex(page);
+

     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
     if (page_idx >= active_tabctrl->GetPageCount())
         active_tabctrl->AddPage(page, info);
          else
         active_tabctrl->InsertPage(page, info, page_idx);
 
     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
     if (page_idx >= active_tabctrl->GetPageCount())
         active_tabctrl->AddPage(page, info);
          else
         active_tabctrl->InsertPage(page, info, page_idx);
 

+    UpdateTabCtrlHeight();

     DoSizing();
     active_tabctrl->DoShowHide();
 
     if (select)
     {
     DoSizing();
     active_tabctrl->DoShowHide();
 
     if (select)
     {

-        int idx = m_tabs.GetIdxFromWindow(page);
-        wxASSERT_MSG(idx != -1, wxT("Invalid Page index returned on wxAuiNotebook::InsertPage()"));
-
-        SetSelection(idx);
+        SetSelectionToWindow(page);

     }
 
     return true;
     }
 
     return true;


@@ -2338,13 +2631,12 @@ bool wxAuiNotebook::InsertPage(size_t page_idx,
 // DeletePage() removes a tab from the multi-notebook,
 // and destroys the window as well
 bool wxAuiNotebook::DeletePage(size_t page_idx)
 // DeletePage() removes a tab from the multi-notebook,
 // and destroys the window as well
 bool wxAuiNotebook::DeletePage(size_t page_idx)

-{    
+{

     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
 
     if (!RemovePage(page_idx))
         return false;
 
     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
 
     if (!RemovePage(page_idx))
         return false;
 

-

     // actually destroy the window now
     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
     {
     // actually destroy the window now
     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
     {


@@ -2357,11 +2649,16 @@ bool wxAuiNotebook::DeletePage(size_t page_idx)
     {
         wnd->Destroy();
     }
     {
         wnd->Destroy();
     }

-    
+

     return true;
     return true;

-    
-/*
+}
+

 
 

+
+// RemovePage() removes a tab from the multi-notebook,
+// but does not destroy the window
+bool wxAuiNotebook::RemovePage(size_t page_idx)
+{

     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
     wxWindow* new_active = NULL;
 
     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
     wxWindow* new_active = NULL;
 


@@ -2403,18 +2700,6 @@ bool wxAuiNotebook::DeletePage(size_t page_idx)
     // remove the tab from the onscreen tab ctrl
     ctrl->RemovePage(wnd);
 
     // remove the tab from the onscreen tab ctrl
     ctrl->RemovePage(wnd);
 

-    // actually destroy the window now
-    if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
-    {
-        // delete the child frame with pending delete, as is
-        // customary with frame windows
-        if (!wxPendingDelete.Member(wnd))
-            wxPendingDelete.Append(wnd);
-    }
-     else
-    {
-        wnd->Destroy();
-    }

 
     RemoveEmptyTabFrames();
 
 
     RemoveEmptyTabFrames();
 


@@ -2422,82 +2707,67 @@ bool wxAuiNotebook::DeletePage(size_t page_idx)
     if (new_active)
     {
         m_curpage = -1;
     if (new_active)
     {
         m_curpage = -1;

-        SetSelection(m_tabs.GetIdxFromWindow(new_active));
+        SetSelectionToWindow(new_active);

     }
     }

-    
+

     return true;
     return true;

-    */

 }
 
 }
 

+// GetPageIndex() returns the index of the page, or -1 if the
+// page could not be located in the notebook
+int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
+{
+    return m_tabs.GetIdxFromWindow(page_wnd);
+}

 
 
 
 

-// RemovePage() removes a tab from the multi-notebook,
-// but does not destroy the window
-bool wxAuiNotebook::RemovePage(size_t page_idx)
-{
-    wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
-    wxWindow* new_active = NULL;

 
 

-    // find out which onscreen tab ctrl owns this tab
-    wxAuiTabCtrl* ctrl;
-    int ctrl_idx;
-    if (!FindTab(wnd, &ctrl, &ctrl_idx))
+// SetPageText() changes the tab caption of the specified page
+bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
+{
+    if (page_idx >= m_tabs.GetPageCount())

         return false;
 
         return false;
 

-    // find a new page and set it as active
-    int new_idx = ctrl_idx+1;
-    if (new_idx >= (int)ctrl->GetPageCount())
-        new_idx = ctrl_idx-1;
+    // update our own tab catalog
+    wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
+    page_info.caption = text;

 
 

-    if (new_idx >= 0 && new_idx < (int)ctrl->GetPageCount())
-    {
-        new_active = ctrl->GetWindowFromIdx(new_idx);
-    }
-     else
+    // update what's on screen
+    wxAuiTabCtrl* ctrl;
+    int ctrl_idx;
+    if (FindTab(page_info.window, &ctrl, &ctrl_idx))

     {
     {

-        // set the active page to the first page that
-        // isn't the one being deleted
-        size_t i, page_count = m_tabs.GetPageCount();
-        for (i = 0; i < page_count; ++i)
-        {
-            wxWindow* w = m_tabs.GetWindowFromIdx(i);
-            if (wnd != w)
-            {
-                new_active = m_tabs.GetWindowFromIdx(i);
-                break;
-            }
-        }
+        wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
+        info.caption = text;
+        ctrl->Refresh();
+        ctrl->Update();

     }
 
     }
 

-    // remove the tab from main catalog
-    if (!m_tabs.RemovePage(wnd))
-        return false;
-
-    // remove the tab from the onscreen tab ctrl
-    ctrl->RemovePage(wnd);
-
+    return true;
+}

 
 

-    RemoveEmptyTabFrames();
+// returns the page caption
+wxString wxAuiNotebook::GetPageText(size_t page_idx) const
+{
+    if (page_idx >= m_tabs.GetPageCount())
+        return wxEmptyString;

 
 

-    // set new active pane
-    if (new_active)
-    {
-        m_curpage = -1;
-        SetSelection(m_tabs.GetIdxFromWindow(new_active));
-    }
-    
-    return true;
+    // update our own tab catalog
+    const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
+    return page_info.caption;

 }
 
 }
 

-// SetPageText() changes the tab caption of the specified page
-bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
+bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)

 {
     if (page_idx >= m_tabs.GetPageCount())
         return false;
 
     // update our own tab catalog
     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
 {
     if (page_idx >= m_tabs.GetPageCount())
         return false;
 
     // update our own tab catalog
     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);

-    page_info.caption = text;
+    page_info.bitmap = bitmap;
+
+    // tab height might have changed
+    UpdateTabCtrlHeight();

 
     // update what's on screen
     wxAuiTabCtrl* ctrl;
 
     // update what's on screen
     wxAuiTabCtrl* ctrl;


@@ -2505,7 +2775,7 @@ bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
     {
         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
     {
         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);

-        info.caption = text;
+        info.bitmap = bitmap;

         ctrl->Refresh();
         ctrl->Update();
     }
         ctrl->Refresh();
         ctrl->Update();
     }


@@ -2513,6 +2783,17 @@ bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
     return true;
 }
 
     return true;
 }
 

+// returns the page bitmap
+wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
+{
+    if (page_idx >= m_tabs.GetPageCount())
+        return wxBitmap();
+
+    // update our own tab catalog
+    const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
+    return page_info.bitmap;
+}
+

 // GetSelection() returns the index of the currently active page
 int wxAuiNotebook::GetSelection() const
 {
 // GetSelection() returns the index of the currently active page
 int wxAuiNotebook::GetSelection() const
 {


@@ -2522,6 +2803,10 @@ int wxAuiNotebook::GetSelection() const
 // SetSelection() sets the currently active page
 size_t wxAuiNotebook::SetSelection(size_t new_page)
 {
 // SetSelection() sets the currently active page
 size_t wxAuiNotebook::SetSelection(size_t new_page)
 {

+    // don't change the page unless necessary
+    if ((int)new_page == m_curpage)
+        return m_curpage;
+

     wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
     if (!wnd)
         return m_curpage;
     wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
     if (!wnd)
         return m_curpage;


@@ -2532,12 +2817,14 @@ size_t wxAuiNotebook::SetSelection(size_t new_page)
     evt.SetEventObject(this);
     if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
     {
     evt.SetEventObject(this);
     if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
     {

+        int old_curpage = m_curpage;
+        m_curpage = new_page;
+

         // program allows the page change
         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
         (void)GetEventHandler()->ProcessEvent(evt);
 
 
         // program allows the page change
         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
         (void)GetEventHandler()->ProcessEvent(evt);
 
 

-

         wxAuiTabCtrl* ctrl;
         int ctrl_idx;
         if (FindTab(wnd, &ctrl, &ctrl_idx))
         wxAuiTabCtrl* ctrl;
         int ctrl_idx;
         if (FindTab(wnd, &ctrl, &ctrl_idx))


@@ -2548,8 +2835,6 @@ size_t wxAuiNotebook::SetSelection(size_t new_page)
             DoSizing();
             ctrl->DoShowHide();
 
             DoSizing();
             ctrl->DoShowHide();
 

-            int old_curpage = m_curpage;
-            m_curpage = new_page;

 
 
             // set fonts
 
 
             // set fonts


@@ -2577,6 +2862,14 @@ size_t wxAuiNotebook::SetSelection(size_t new_page)
     return m_curpage;
 }
 
     return m_curpage;
 }
 

+void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
+{
+    const int idx = m_tabs.GetIdxFromWindow(win);
+    wxCHECK_RET( idx != wxNOT_FOUND, _T("invalid notebook page") );
+
+    SetSelection(idx);
+}
+

 // GetPageCount() returns the total number of
 // pages managed by the multi-notebook
 size_t wxAuiNotebook::GetPageCount() const
 // GetPageCount() returns the total number of
 // pages managed by the multi-notebook
 size_t wxAuiNotebook::GetPageCount() const


@@ -2681,13 +2974,125 @@ bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
     return false;
 }
 
     return false;
 }
 

-
-void wxAuiNotebook::OnEraseBackground(wxEraseEvent&)
+void wxAuiNotebook::Split(size_t page, int direction)

 {
 {

+    wxSize cli_size = GetClientSize();
+
+    // get the page's window pointer
+    wxWindow* wnd = GetPage(page);
+    if (!wnd)
+        return;
+
+    // notebooks with 1 or less pages can't be split
+    if (GetPageCount() < 2)
+        return;
+
+    // find out which tab control the page currently belongs to
+    wxAuiTabCtrl *src_tabs, *dest_tabs;
+    int src_idx = -1;
+    src_tabs = NULL;
+    if (!FindTab(wnd, &src_tabs, &src_idx))
+        return;
+    if (!src_tabs || src_idx == -1)
+        return;
+
+    // choose a split size
+    wxSize split_size;
+    if (GetPageCount() > 2)
+    {
+        split_size = CalculateNewSplitSize();
+    }
+     else
+    {
+        // because there are two panes, always split them
+        // equally
+        split_size = GetClientSize();
+        split_size.x /= 2;
+        split_size.y /= 2;
+    }
+
+
+    // create a new tab frame
+    wxTabFrame* new_tabs = new wxTabFrame;
+    new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
+    new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
+    new_tabs->m_tabs = new wxAuiTabCtrl(this,
+                                        m_tab_id_counter++,
+                                        wxDefaultPosition,
+                                        wxDefaultSize,
+                                        wxNO_BORDER);
+    new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
+    new_tabs->m_tabs->SetFlags(m_flags);
+    dest_tabs = new_tabs->m_tabs;
+
+    // create a pane info structure with the information
+    // about where the pane should be added
+    wxAuiPaneInfo pane_info = wxAuiPaneInfo().Bottom().CaptionVisible(false);
+    wxPoint mouse_pt;
+
+    if (direction == wxLEFT)
+    {
+        pane_info.Left();
+        mouse_pt = wxPoint(0, cli_size.y/2);
+    }
+     else if (direction == wxRIGHT)
+    {
+        pane_info.Right();
+        mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
+    }
+     else if (direction == wxTOP)
+    {
+        pane_info.Top();
+        mouse_pt = wxPoint(cli_size.x/2, 0);
+    }
+     else if (direction == wxBOTTOM)
+    {
+        pane_info.Bottom();
+        mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
+    }
+
+    m_mgr.AddPane(new_tabs, pane_info, mouse_pt);
+    m_mgr.Update();
+
+    // remove the page from the source tabs
+    wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
+    page_info.active = false;
+    src_tabs->RemovePage(page_info.window);
+    if (src_tabs->GetPageCount() > 0)
+    {
+        src_tabs->SetActivePage((size_t)0);
+        src_tabs->DoShowHide();
+        src_tabs->Refresh();
+    }
+
+
+    // add the page to the destination tabs
+    dest_tabs->InsertPage(page_info.window, page_info, 0);
+
+    if (src_tabs->GetPageCount() == 0)
+    {
+        RemoveEmptyTabFrames();
+    }
+
+    DoSizing();
+    dest_tabs->DoShowHide();
+    dest_tabs->Refresh();
+
+    // force the set selection function reset the selection
+    m_curpage = -1;
+
+    // set the active page to the one we just split off
+    SetSelectionToPage(page_info);
+
+    UpdateHintWindowSize();

 }
 
 }
 

-void wxAuiNotebook::OnSize(wxSizeEvent&)
+
+void wxAuiNotebook::OnSize(wxSizeEvent& evt)

 {
 {

+    UpdateHintWindowSize();
+
+    evt.Skip();

 }
 
 void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
 }
 
 void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)


@@ -2700,10 +3105,7 @@ void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
     wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
     wxASSERT(wnd != NULL);
 
     wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
     wxASSERT(wnd != NULL);
 

-    int idx = m_tabs.GetIdxFromWindow(wnd);
-    wxASSERT(idx != -1);
-
-    SetSelection(idx);
+    SetSelectionToWindow(wnd);

 }
 
 void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
 }
 
 void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)


@@ -2719,32 +3121,32 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
 
     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
 
     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);

-    
+

     if (dest_tabs == src_tabs)
     {
         if (src_tabs)
         {
             src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
         }
     if (dest_tabs == src_tabs)
     {
         if (src_tabs)
         {
             src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
         }

-        
+

         // always hide the hint for inner-tabctrl drag
         m_mgr.HideHint();
         // always hide the hint for inner-tabctrl drag
         m_mgr.HideHint();

-        
+

         // if tab moving is not allowed, leave
         if (!(m_flags & wxAUI_NB_TAB_MOVE))
         {
             return;
         }
         // if tab moving is not allowed, leave
         if (!(m_flags & wxAUI_NB_TAB_MOVE))
         {
             return;
         }

-                
+

         wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
         wxWindow* dest_location_tab;
         wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
         wxWindow* dest_location_tab;

-        
+

         // this is an inner-tab drag/reposition
         if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
         {
             int src_idx = evt.GetSelection();
             int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
         // this is an inner-tab drag/reposition
         if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
         {
             int src_idx = evt.GetSelection();
             int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);

-            
+

             // prevent jumpy drag
             if ((src_idx == dest_idx) || dest_idx == -1 ||
                 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
             // prevent jumpy drag
             if ((src_idx == dest_idx) || dest_idx == -1 ||
                 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||


@@ -2763,7 +3165,7 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
             m_last_drag_x = pt.x;
 
         }
             m_last_drag_x = pt.x;
 
         }

-        
+

         return;
     }
 
         return;
     }
 


@@ -2773,9 +3175,13 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
     {
         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
     {
         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);

-        
+
+        // if we aren't over any window, stop here
+        if (!tab_ctrl)
+            return;
+

         // make sure we are not over the hint window
         // make sure we are not over the hint window

-        if (tab_ctrl && !tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
+        if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))

         {
             while (tab_ctrl)
             {
         {
             while (tab_ctrl)
             {


@@ -2783,37 +3189,47 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
                     break;
                 tab_ctrl = tab_ctrl->GetParent();
             }
                     break;
                 tab_ctrl = tab_ctrl->GetParent();
             }

-            
+

             if (tab_ctrl)
             {
                 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
             if (tab_ctrl)
             {
                 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();

-                
+

                 if (nb != this)
                 {
                 if (nb != this)
                 {

-                    wxRect hint_rect = tab_ctrl->GetRect();
+                    wxRect hint_rect = tab_ctrl->GetClientRect();

                     tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
                     m_mgr.ShowHint(hint_rect);
                     return;
                 }
                     tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
                     m_mgr.ShowHint(hint_rect);
                     return;
                 }

-                
+            }
+        }
+         else
+        {
+            if (!dest_tabs)
+            {
+                // we are either over a hint window, or not over a tab
+                // window, and there is no where to drag to, so exit
+                return;

             }
         }
     }
 
 
             }
         }
     }
 
 

+    // if there are less than two panes, split can't happen, so leave
+    if (m_tabs.GetPageCount() < 2)
+        return;
+

     // if tab moving is not allowed, leave
     if (!(m_flags & wxAUI_NB_TAB_SPLIT))
     // if tab moving is not allowed, leave
     if (!(m_flags & wxAUI_NB_TAB_SPLIT))

-    {

         return;
         return;

-    }

 
 
     if (src_tabs)
     {
         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
     }
 
 
     if (src_tabs)
     {
         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
     }

-    
-    
+
+

     if (dest_tabs)
     {
         wxRect hint_rect = dest_tabs->GetRect();
     if (dest_tabs)
     {
         wxRect hint_rect = dest_tabs->GetRect();


@@ -2834,15 +3250,12 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
 
     m_mgr.HideHint();
 
 
     m_mgr.HideHint();
 

-    
+

     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();

-    wxAuiTabCtrl* dest_tabs = NULL;
-    if (src_tabs)
-    {
-        // set cursor back to an arrow
-        src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
-    }
-    
+    wxCHECK_RET( src_tabs, _T("no source object?") );
+
+    src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
+

     // get the mouse position, which will be used to determine the drop point
     wxPoint mouse_screen_pt = ::wxGetMousePosition();
     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
     // get the mouse position, which will be used to determine the drop point
     wxPoint mouse_screen_pt = ::wxGetMousePosition();
     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);


@@ -2853,18 +3266,18 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
     {
         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
     {
         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);

-        
+

         while (tab_ctrl)
         {
             if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
                 break;
             tab_ctrl = tab_ctrl->GetParent();
         }
         while (tab_ctrl)
         {
             if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
                 break;
             tab_ctrl = tab_ctrl->GetParent();
         }

-        
+

         if (tab_ctrl)
         {
             wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
         if (tab_ctrl)
         {
             wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();

-            
+

             if (nb != this)
             {
                 // find out from the destination control
             if (nb != this)
             {
                 // find out from the destination control


@@ -2875,33 +3288,35 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
                 e.SetEventObject(this);
                 e.SetDragSource(this);
                 e.Veto(); // dropping must be explicitly approved by control owner
                 e.SetEventObject(this);
                 e.SetDragSource(this);
                 e.Veto(); // dropping must be explicitly approved by control owner

-                
+

                 nb->GetEventHandler()->ProcessEvent(e);
                 nb->GetEventHandler()->ProcessEvent(e);

-                
+

                 if (!e.IsAllowed())
                 {
                     // no answer or negative answer
                     m_mgr.HideHint();
                     return;
                 }
                 if (!e.IsAllowed())
                 {
                     // no answer or negative answer
                     m_mgr.HideHint();
                     return;
                 }

-                
+

                 // drop was allowed
                 int src_idx = evt.GetSelection();
                 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
                 // drop was allowed
                 int src_idx = evt.GetSelection();
                 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);

-                
+

                 // get main index of the page
                 int main_idx = m_tabs.GetIdxFromWindow(src_page);
                 // get main index of the page
                 int main_idx = m_tabs.GetIdxFromWindow(src_page);

-                
+                wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no source page?") );
+
+

                 // make a copy of the page info
                 // make a copy of the page info

-                wxAuiNotebookPage page_info = m_tabs.GetPage((size_t)main_idx);
-                
+                wxAuiNotebookPage page_info = m_tabs.GetPage(main_idx);
+

                 // remove the page from the source notebook
                 RemovePage(main_idx);
                 // remove the page from the source notebook
                 RemovePage(main_idx);

-                
+

                 // reparent the page
                 src_page->Reparent(nb);
                 // reparent the page
                 src_page->Reparent(nb);

-                
-                
+
+

                 // found out the insert idx
                 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
                 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
                 // found out the insert idx
                 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
                 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);


@@ -2914,7 +3329,7 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
                     insert_idx = dest_tabs->GetIdxFromWindow(target);
                 }
 
                     insert_idx = dest_tabs->GetIdxFromWindow(target);
                 }
 

-                
+

                 // add the page to the new notebook
                 if (insert_idx == -1)
                     insert_idx = dest_tabs->GetPageCount();
                 // add the page to the new notebook
                 if (insert_idx == -1)
                     insert_idx = dest_tabs->GetPageCount();


@@ -2924,9 +3339,9 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
                 nb->DoSizing();
                 dest_tabs->DoShowHide();
                 dest_tabs->Refresh();
                 nb->DoSizing();
                 dest_tabs->DoShowHide();
                 dest_tabs->Refresh();

-        
+

                 // set the selection in the destination tab control
                 // set the selection in the destination tab control

-                nb->SetSelection(nb->m_tabs.GetIdxFromWindow(page_info.window));
+                nb->SetSelectionToPage(page_info);

 
                 return;
             }
 
                 return;
             }


@@ -2937,7 +3352,9 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
 
 
     // only perform a tab split if it's allowed
 
 
     // only perform a tab split if it's allowed

-    if (m_flags & wxAUI_NB_TAB_SPLIT)
+    wxAuiTabCtrl* dest_tabs = NULL;
+
+    if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)

     {
         // If the pointer is in an existing tab frame, do a tab insert
         wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
     {
         // If the pointer is in an existing tab frame, do a tab insert
         wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);


@@ -2949,8 +3366,8 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
 
             if (dest_tabs == src_tabs)
                 return;
 
             if (dest_tabs == src_tabs)
                 return;

-            
-                
+
+

             wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
             wxWindow* target = NULL;
             dest_tabs->TabHitTest(pt.x, pt.y, &target);
             wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
             wxWindow* target = NULL;
             dest_tabs->TabHitTest(pt.x, pt.y, &target);


@@ -2959,10 +3376,21 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
                 insert_idx = dest_tabs->GetIdxFromWindow(target);
             }
         }
                 insert_idx = dest_tabs->GetIdxFromWindow(target);
             }
         }

-         else
+        else

         {
         {

+            wxPoint zero(0,0);
+            wxRect rect = m_mgr.CalculateHintRect(m_dummy_wnd,
+                                                  mouse_client_pt,
+                                                  zero);
+            if (rect.IsEmpty())
+            {
+                // there is no suitable drop location here, exit out
+                return;
+            }
+

             // If there is no tabframe at all, create one
             wxTabFrame* new_tabs = new wxTabFrame;
             // If there is no tabframe at all, create one
             wxTabFrame* new_tabs = new wxTabFrame;

+            new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());

             new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
             new_tabs->m_tabs = new wxAuiTabCtrl(this,
                                                 m_tab_id_counter++,
             new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
             new_tabs->m_tabs = new wxAuiTabCtrl(this,
                                                 m_tab_id_counter++,


@@ -3008,7 +3436,13 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
         dest_tabs->DoShowHide();
         dest_tabs->Refresh();
 
         dest_tabs->DoShowHide();
         dest_tabs->Refresh();
 

-        SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
+        // force the set selection function reset the selection
+        m_curpage = -1;
+
+        // set the active page to the one we just split off
+        SetSelectionToPage(page_info);
+
+        UpdateHintWindowSize();

     }
 }
 
     }
 }
 


@@ -3145,9 +3579,11 @@ void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
             {
                 close_wnd->Close();
             }
             {
                 close_wnd->Close();
             }

-             else
+            else

             {
                 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
             {
                 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);

+                wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no page to delete?") );
+

                 DeletePage(main_idx);
             }
         }
                 DeletePage(main_idx);
             }
         }