prep flags, code indentation

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

diff --git a/src/aui/auibook.cpp b/src/aui/auibook.cpp
index 6aa541bfa9b4b8d8e974e666b291d4620e19180f..da29d085e807d6c2bbb6bd6480fcd24e8d68d338 100644 (file)
--- a/src/aui/auibook.cpp
+++ b/src/aui/auibook.cpp
@@ -57,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,


@@ -96,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);


@@ -116,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 --


@@ -153,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; }
 


@@ -164,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;
 };


@@ -183,11 +141,11 @@ private:
      0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
      0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
      0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
      0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
      0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
      0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };

-#elif defined( __WXGTK__)       
- static unsigned char close_bits[]={    
-     0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,    
-     0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,    
-     0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };          
+#elif defined( __WXGTK__)
+ static unsigned char close_bits[]={
+     0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
+     0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
+     0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

 #else
  static unsigned char close_bits[]={
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
 #else
  static unsigned char close_bits[]={
      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,


@@ -223,7 +181,7 @@ 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_tab_ctrl_height = 0;
 
     m_fixed_tab_width = 100;
     m_tab_ctrl_height = 0;
 


@@ -235,25 +193,34 @@ wxAuiDefaultTabArt::wxAuiDefaultTabArt()
     wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 #endif
 
     wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 #endif
 

-    m_base_colour = base_colour;
-    wxColor darker2_colour = StepColour(base_colour, 70);
+    // 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_border_pen = wxPen(darker2_colour);
+    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_base_colour_pen = wxPen(m_base_colour);
     m_base_colour_brush = wxBrush(m_base_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));
+

     m_flags = 0;
 }
 
     m_flags = 0;
 }
 


@@ -275,46 +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 = (int)tab_ctrl_size.x - GetIndentSize() - 4;
     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;
 }
     m_tab_ctrl_height = tab_ctrl_size.y;
 }

-                       
-                       
+
+

 void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
                                         wxWindow* WXUNUSED(wnd),
                                         const wxRect& rect)
 {
     // draw background
     wxRect r(rect.x, rect.y, rect.width+2, rect.height-3);
 void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
                                         wxWindow* WXUNUSED(wnd),
                                         const wxRect& rect)
 {
     // draw background
     wxRect r(rect.x, rect.y, rect.width+2, rect.height-3);

-    wxColor start_colour = StepColour(m_base_colour, 90);
-    wxColor end_colour = StepColour(m_base_colour, 110);
-    dc.GradientFillLinear(r, start_colour, end_colour, wxSOUTH);
-    
+    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
     int y = rect.GetHeight();
     int w = rect.GetWidth();
     dc.SetPen(m_border_pen);
     // draw base lines
     int y = rect.GetHeight();
     int w = rect.GetWidth();
     dc.SetPen(m_border_pen);

-    dc.DrawLine(0, y-4, w, y-4);
-    dc.DrawLine(0, y-1, w, y-1);
-    dc.SetPen(wxPen(start_colour));
-    dc.DrawLine(0, y-3, w, y-3);
-    dc.DrawLine(0, y-2, w, y-2);
+    dc.SetBrush(m_base_colour_brush);
+    dc.DrawRectangle(-1, y-4, w+2, 4);

 }
 
 
 }
 
 


@@ -341,18 +311,18 @@ 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
     wxString caption = caption_text;
     if (caption_text.empty())
         caption = wxT("Xj");
     // if the caption is empty, measure some temporary text
     wxString caption = caption_text;
     if (caption_text.empty())
         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,
     // figure out the size of the tab
     wxSize tab_size = GetTabSize(dc,
                                  wnd,


@@ -386,13 +356,14 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
         texty = normal_texty;
     }
 
         texty = normal_texty;
     }
 

-    
+

     // create points that will make the tab outline
     // create points that will make the tab outline

-    
+

     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;
     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);
     wxPoint clip_points[6];
     clip_points[0] = wxPoint(tab_x,              tab_y+tab_height-3);
     clip_points[1] = wxPoint(tab_x,              tab_y+2);


@@ -401,10 +372,18 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
     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);
 
     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 --
     // set the clipping region for the tab --

-    wxRegion clipping_region(6, clip_points);
+    wxRegion clipping_region(WXSIZEOF(clip_points), clip_points);

     dc.SetClippingRegion(clipping_region);
     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);
     wxPoint border_points[6];
     border_points[0] = wxPoint(tab_x,             tab_y+tab_height-4);
     border_points[1] = wxPoint(tab_x,             tab_y+2);


@@ -413,83 +392,89 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
     border_points[4] = wxPoint(tab_x+tab_width,   tab_y+2);
     border_points[5] = wxPoint(tab_x+tab_width,   tab_y+tab_height-4);
 
     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 (active)
     {
     int drawn_tab_yoff = border_points[1].y;
     int drawn_tab_height = border_points[0].y - border_points[1].y;
 
 
     if (active)
     {

-        // draw active tab   
-        
+        // 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);
         // 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, r.y, r.width, r.height);
-        
+        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);
         // 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+2, r.width-3, r.height);
-        
+        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);
         // these two points help the rounded corners appear more antialiased
         dc.SetPen(m_base_colour_pen);

-        dc.DrawPoint(r.x+2, r.y+2);
-        dc.DrawPoint(r.x+r.width-2, r.y+2);
-        
+        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;
         // 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
         // draw gradient background

-        wxColor start_color = StepColour(m_base_colour, 95);
-        wxColor end_color = *wxWHITE;
-        dc.GradientFillLinear(r, start_color, end_color, wxNORTH);
+        wxColor top_color = *wxWHITE;
+        wxColor bottom_color = m_base_colour;
+        dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);

     }
      else
     {
         // draw inactive tab
     }
      else
     {
         // draw inactive tab

-        
+

         wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
         wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);

-        
-        // draw base background color for inactive tabs
-        dc.SetPen(m_base_colour_pen);
-        dc.SetBrush(m_base_colour_brush);
-        dc.DrawRectangle(r.x, r.y, r.width, r.height);

 
         // 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
 
         // 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 += 2;
-        r.width -= 2;
+        r.x += 3;
+        r.y++;
+        r.width -= 4;

         r.height /= 2;
         r.height /= 2;

+        r.height--;

         
         

-        // -- draw bottom gradient fill for glossy look
+        // -- draw top gradient fill for glossy look

         wxColor top_color = m_base_colour;
         wxColor top_color = m_base_colour;

-        wxColor bottom_color = StepColour(top_color, 106);
+        wxColor bottom_color = wxAuiStepColour(top_color, 160);

         dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
         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 
+
+    // draw tab outline

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

-    dc.DrawPolygon(6, border_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 (active)
     {

-        wxColor start_color = StepColour(m_base_colour, 93);
-        dc.SetPen(wxPen(start_color));
-        dc.DrawLine(border_points[0].x,
+        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[0].y,

-                    border_points[5].x+1,
+                    border_points[5].x,

                     border_points[5].y);
     }
                     border_points[5].y);
     }

-    
+

 
     int text_offset = tab_x + 8;
     int close_button_width = 0;
 
     int text_offset = tab_x + 8;
     int close_button_width = 0;


@@ -497,18 +482,18 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
     {
         close_button_width = m_active_close_bmp.GetWidth();
     }
     {
         close_button_width = m_active_close_bmp.GetWidth();
     }

-    
-    
+
+

     if (bitmap.IsOk())
     {
         int bitmap_offset = tab_x + 8;
     if (bitmap.IsOk())
     {
         int bitmap_offset = tab_x + 8;

-        
+

         // draw bitmap
         dc.DrawBitmap(bitmap,
                       bitmap_offset,
         // draw bitmap
         dc.DrawBitmap(bitmap,
                       bitmap_offset,

-                      drawn_tab_yoff + (drawn_tab_height/2) - (bitmap.GetHeight()/2) + 1,
+                      drawn_tab_yoff + (drawn_tab_height/2) - (bitmap.GetHeight()/2),

                       true);
                       true);

-        
+

         text_offset = bitmap_offset + bitmap.GetWidth();
         text_offset += 3; // bitmap padding
     }
         text_offset = bitmap_offset + bitmap.GetWidth();
         text_offset += 3; // bitmap padding
     }


@@ -516,12 +501,12 @@ void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
     {
         text_offset = tab_x + 8;
     }
     {
         text_offset = tab_x + 8;
     }

-        

 
 

-    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);

-    
+

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


@@ -540,19 +525,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();
 }
 


@@ -570,12 +555,12 @@ wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
                                       int* x_extent)
 {
     wxCoord measured_textx, measured_texty, tmp;
                                       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);

-    
+

     // add padding around the text
     wxCoord tab_width = measured_textx;
     wxCoord tab_height = measured_texty;
     // add padding around the text
     wxCoord tab_width = measured_textx;
     wxCoord tab_height = measured_texty;


@@ -600,9 +585,9 @@ wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
     {
         tab_width = m_fixed_tab_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);
 }
 


@@ -618,7 +603,7 @@ void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
 {
     wxBitmap bmp;
     wxRect rect;
 {
     wxBitmap bmp;
     wxRect rect;

-    
+

     if (bitmap_override.IsOk())
     {
         bmp = bitmap_override;
     if (bitmap_override.IsOk())
     {
         bmp = bitmap_override;


@@ -656,9 +641,9 @@ void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
 
     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);


@@ -672,10 +657,10 @@ 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;
 }
 


@@ -691,50 +676,62 @@ int wxAuiDefaultTabArt::ShowWindowList(wxWindow* wnd,
     {
         menuPopup.AppendCheckItem(1000+i, items.Item(i));
     }
     {
         menuPopup.AppendCheckItem(1000+i, items.Item(i));
     }

-    
+

     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;
 }
 
 int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
     return -1;
 }
 
 int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,

-                                           wxAuiNotebookPageArray& pages)
+                                           wxAuiNotebookPageArray& pages,
+                                           const wxSize& required_bmp_size)

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

+
+    // 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);
 
     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
         // 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


@@ -743,13 +740,14 @@ int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
         wxSize s = GetTabSize(dc,
                               wnd,
                               wxT("ABCDEFGHIj"),
         wxSize s = GetTabSize(dc,
                               wnd,
                               wxT("ABCDEFGHIj"),

-                              page.bitmap,
+                              bmp,

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

+                              

         max_y = wxMax(max_y, s.y);
     }
         max_y = wxMax(max_y, s.y);
     }

-    
+

     return max_y+2;
 }
 
     return max_y+2;
 }
 


@@ -783,7 +781,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;
 


@@ -792,19 +790,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()


@@ -826,20 +824,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 = (int)tab_ctrl_size.x - GetIndentSize() - 4;
     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;
 }


@@ -882,18 +886,18 @@ 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
     wxString caption = caption_text;
     if (caption_text.empty())
         caption = wxT("Xj");
     // if the caption is empty, measure some temporary text
     wxString caption = caption_text;
     if (caption_text.empty())
         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,
     // figure out the size of the tab
     wxSize tab_size = GetTabSize(dc,
                                  wnd,


@@ -949,12 +953,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;


@@ -969,13 +973,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);
 


@@ -993,19 +997,19 @@ void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
             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();
 }
 


@@ -1023,21 +1027,21 @@ wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
                                      int* x_extent)
 {
     wxCoord measured_textx, measured_texty;
                                      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);


@@ -1055,7 +1059,7 @@ void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
 {
     wxBitmap bmp;
     wxRect rect;
 {
     wxBitmap bmp;
     wxRect rect;

-    
+

     if (bitmap_override.IsOk())
     {
         bmp = bitmap_override;
     if (bitmap_override.IsOk())
     {
         bmp = bitmap_override;


@@ -1093,9 +1097,9 @@ void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
 
     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);


@@ -1109,10 +1113,10 @@ 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;
 }
 


@@ -1128,12 +1132,12 @@ int wxAuiSimpleTabArt::ShowWindowList(wxWindow* wnd,
     {
         menuPopup.AppendCheckItem(1000+i, items.Item(i));
     }
     {
         menuPopup.AppendCheckItem(1000+i, items.Item(i));
     }

-    
+

     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


@@ -1143,25 +1147,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;
 }
 
 int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
     return -1;
 }
 
 int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,

-                                          wxAuiNotebookPageArray& WXUNUSED(pages))
+                                          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);


@@ -1212,8 +1217,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);


@@ -1228,7 +1233,7 @@ 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);


@@ -1243,17 +1248,17 @@ wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const
 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);
     }
 


@@ -1261,12 +1266,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);


@@ -1297,7 +1302,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());


@@ -1318,7 +1323,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;
 }
 


@@ -1340,7 +1345,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;
 }
 


@@ -1350,16 +1355,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;
 }
 


@@ -1372,13 +1377,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;
         }
     }


@@ -1548,7 +1553,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 ||


@@ -1556,8 +1561,8 @@ 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,
         int x_extent = 0;
         wxSize size = m_art->GetTabSize(dc,
                             wnd,


@@ -1568,12 +1573,12 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                               wxAUI_BUTTON_STATE_NORMAL :
                               wxAUI_BUTTON_STATE_HIDDEN,
                             &x_extent);
                               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)


@@ -1582,7 +1587,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


@@ -1638,7 +1643,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


@@ -1646,12 +1651,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);


@@ -1672,18 +1677,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,


@@ -1694,22 +1699,22 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                           wxLEFT,
                           wxNullBitmap,
                           &button.rect);
                           wxLEFT,
                           wxNullBitmap,
                           &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
     // 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;
     // 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)
     {
     // make sure there are enough tab button entries to accommodate all tabs
     while (m_tab_close_buttons.GetCount() < page_count)
     {


@@ -1719,15 +1724,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)
     {
         m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
     }
     // buttons before the tab offset must be set to hidden
     for (i = 0; i < m_tab_offset; ++i)
     {
         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;


@@ -1785,7 +1790,7 @@ 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;
     }
 


@@ -1825,7 +1830,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                        &x_extent);
     }
 
                        &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);


@@ -1839,7 +1844,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))
     {


@@ -1872,8 +1877,8 @@ 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)
     {
     button_count = m_buttons.GetCount();
     for (i = 0; i < button_count; ++i)
     {


@@ -1887,7 +1892,7 @@ bool wxAuiTabContainer::ButtonHitTest(int x, int y,
             return true;
         }
     }
             return true;
         }
     }

-    
+

     button_count = m_tab_close_buttons.GetCount();
     for (i = 0; i < button_count; ++i)
     {
     button_count = m_tab_close_buttons.GetCount();
     for (i = 0; i < button_count; ++i)
     {


@@ -1901,7 +1906,7 @@ bool wxAuiTabContainer::ButtonHitTest(int x, int y,
             return true;
         }
     }
             return true;
         }
     }

-    
+

     return false;
 }
 
     return false;
 }
 


@@ -1964,6 +1969,7 @@ 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)


@@ -2021,7 +2027,7 @@ void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
     if (TabHitTest(evt.m_x, evt.m_y, &wnd))
     {
         int new_selection = GetIdxFromWindow(wnd);
     if (TabHitTest(evt.m_x, evt.m_y, &wnd))
     {
         int new_selection = GetIdxFromWindow(wnd);

-        
+

         if (new_selection != GetActivePage())
         {
             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
         if (new_selection != GetActivePage())
         {
             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);


@@ -2035,7 +2041,7 @@ void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
         m_click_pt.y = evt.m_y;
         m_click_tab = wnd;
     }
         m_click_pt.y = evt.m_y;
         m_click_tab = wnd;
     }

-    
+

     if (m_hover_button)
     {
         m_pressed_button = m_hover_button;
     if (m_hover_button)
     {
         m_pressed_button = m_hover_button;


@@ -2066,7 +2072,7 @@ void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
         wxAuiTabContainerButton* button = NULL;
         if (!ButtonHitTest(evt.m_x, evt.m_y, &button))
             return;
         wxAuiTabContainerButton* button = NULL;
         if (!ButtonHitTest(evt.m_x, evt.m_y, &button))
             return;

-            
+

         if (button != m_pressed_button)
         {
             m_pressed_button = NULL;
         if (button != m_pressed_button)
         {
             m_pressed_button = NULL;


@@ -2083,7 +2089,7 @@ void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
             evt.SetEventObject(this);
             GetEventHandler()->ProcessEvent(evt);
         }
             evt.SetEventObject(this);
             GetEventHandler()->ProcessEvent(evt);
         }

-        
+

         m_pressed_button = NULL;
     }
 
         m_pressed_button = NULL;
     }
 


@@ -2107,7 +2113,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;


@@ -2173,7 +2179,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)


@@ -2195,7 +2201,7 @@ void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
      else if (button == wxAUI_BUTTON_WINDOWLIST)
     {
         wxArrayString as;
      else if (button == wxAUI_BUTTON_WINDOWLIST)
     {
         wxArrayString as;

-        
+

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


@@ -2204,7 +2210,7 @@ void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
         }
 
         int idx = GetArtProvider()->ShowWindowList(this, as, 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);


@@ -2316,9 +2322,7 @@ public:
 // -- 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_COMMAND_RANGE(10000, 10100,
                       wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
     EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus)
     EVT_COMMAND_RANGE(10000, 10100,
                       wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,


@@ -2343,6 +2347,8 @@ wxAuiNotebook::wxAuiNotebook()
     m_tab_id_counter = 10000;
     m_dummy_wnd = NULL;
     m_tab_ctrl_height = 20;
     m_tab_id_counter = 10000;
     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,


@@ -2351,6 +2357,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);
 }
 


@@ -2375,8 +2384,8 @@ void wxAuiNotebook::InitNotebook(long style)
     m_curpage = -1;
     m_tab_id_counter = 10000;
     m_dummy_wnd = NULL;
     m_curpage = -1;
     m_tab_id_counter = 10000;
     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_normal_font = *wxNORMAL_FONT;
     m_selected_font = *wxNORMAL_FONT;


@@ -2389,9 +2398,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();
 }


@@ -2404,20 +2415,62 @@ wxAuiNotebook::~wxAuiNotebook()
 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
 {
     m_tabs.SetArtProvider(art);
 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
 {
     m_tabs.SetArtProvider(art);

-    
-    SetTabCtrlHeight(CalculateTabCtrlHeight());
+
+    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)
 {
 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();
     // 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;
         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)
         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
         size_t i, pane_count = all_panes.GetCount();
         for (i = 0; i < pane_count; ++i)


@@ -2434,12 +2487,70 @@ void wxAuiNotebook::SetTabCtrlHeight(int height)
     }
 }
 
     }
 }
 

+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)
+    {
+        wxAuiPaneInfo& pane = all_panes.Item(i);
+        if (pane.name == wxT("dummy"))
+            continue;
+        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;
+}
+

 int wxAuiNotebook::CalculateTabCtrlHeight()
 {
 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();
     // find out new best tab height
     wxAuiTabArt* art = m_tabs.GetArtProvider();

-  
-    return art->GetBestTabCtrlSize(this, m_tabs.GetPages());
+
+    return art->GetBestTabCtrlSize(this,
+                                   m_tabs.GetPages(),
+                                   m_requested_bmp_size);

 }
 
 
 }
 
 


@@ -2451,14 +2562,14 @@ wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
 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)


@@ -2466,8 +2577,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();
         }


@@ -2502,13 +2615,19 @@ 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)
+        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);
 

-    SetTabCtrlHeight(CalculateTabCtrlHeight());
+    UpdateTabCtrlHeight();

     DoSizing();
     active_tabctrl->DoShowHide();
 
     DoSizing();
     active_tabctrl->DoShowHide();
 


@@ -2527,7 +2646,7 @@ 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))
     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
 
     if (!RemovePage(page_idx))


@@ -2545,7 +2664,7 @@ bool wxAuiNotebook::DeletePage(size_t page_idx)
     {
         wnd->Destroy();
     }
     {
         wnd->Destroy();
     }

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -2605,7 +2724,7 @@ bool wxAuiNotebook::RemovePage(size_t page_idx)
         m_curpage = -1;
         SetSelection(m_tabs.GetIdxFromWindow(new_active));
     }
         m_curpage = -1;
         SetSelection(m_tabs.GetIdxFromWindow(new_active));
     }

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -2647,14 +2766,14 @@ bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
 {
     if (page_idx >= m_tabs.GetPageCount())
         return false;
 {
     if (page_idx >= m_tabs.GetPageCount())
         return false;

-        
+

     // update our own tab catalog
     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
     page_info.bitmap = bitmap;
     // update our own tab catalog
     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
     page_info.bitmap = bitmap;

-    
+

     // tab height might have changed
     // tab height might have changed

-    SetTabCtrlHeight(CalculateTabCtrlHeight());
-    
+    UpdateTabCtrlHeight();
+

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


@@ -2665,7 +2784,7 @@ bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
         ctrl->Refresh();
         ctrl->Update();
     }
         ctrl->Refresh();
         ctrl->Update();
     }

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -2687,14 +2806,14 @@ size_t wxAuiNotebook::SetSelection(size_t new_page)
     evt.SetSelection(new_page);
     evt.SetOldSelection(m_curpage);
     evt.SetEventObject(this);
     evt.SetSelection(new_page);
     evt.SetOldSelection(m_curpage);
     evt.SetEventObject(this);

-    if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
+    if (!GetParent()->GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())

     {
         int old_curpage = m_curpage;
         m_curpage = new_page;
     {
         int old_curpage = m_curpage;
         m_curpage = new_page;

-            
+

         // program allows the page change
         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
         // program allows the page change
         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);

-        (void)GetEventHandler()->ProcessEvent(evt);
+        (void)GetParent()->GetEventHandler()->ProcessEvent(evt);

 
 
         wxAuiTabCtrl* ctrl;
 
 
         wxAuiTabCtrl* ctrl;


@@ -2838,13 +2957,11 @@ bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
     return false;
 }
 
     return false;
 }
 

-
-void wxAuiNotebook::OnEraseBackground(wxEraseEvent&)
-{
-}
-
-void wxAuiNotebook::OnSize(wxSizeEvent&)
+void wxAuiNotebook::OnSize(wxSizeEvent& evt)

 {
 {

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

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


@@ -2876,32 +2993,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) ||


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

-        
+

         return;
     }
 
         return;
     }
 


@@ -2930,11 +3047,11 @@ 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;
         // if we aren't over any window, stop here
         if (!tab_ctrl)
             return;

-            
+

         // make sure we are not over the hint window
         if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
         {
         // make sure we are not over the hint window
         if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
         {


@@ -2944,11 +3061,11 @@ 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)
                 {
                     wxRect hint_rect = tab_ctrl->GetClientRect();
                 if (nb != this)
                 {
                     wxRect hint_rect = tab_ctrl->GetClientRect();


@@ -2973,7 +3090,7 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
     // if there are less than two panes, split can't happen, so leave
     if (m_tabs.GetPageCount() < 2)
         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))
         return;
     // if tab moving is not allowed, leave
     if (!(m_flags & wxAUI_NB_TAB_SPLIT))
         return;


@@ -2983,8 +3100,8 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
     {
         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
     }
     {
         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
     }

-    
-    
+
+

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


@@ -3005,7 +3122,7 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
 
     m_mgr.HideHint();
 
 
     m_mgr.HideHint();
 

-    
+

     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
     wxAuiTabCtrl* dest_tabs = NULL;
     if (src_tabs)
     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
     wxAuiTabCtrl* dest_tabs = NULL;
     if (src_tabs)


@@ -3013,7 +3130,7 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
         // set cursor back to an arrow
         src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
     }
         // set cursor back to an arrow
         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);


@@ -3024,18 +3141,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


@@ -3046,33 +3163,33 @@ 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);

-                
+

                 // make a copy of the page info
                 wxAuiNotebookPage page_info = m_tabs.GetPage((size_t)main_idx);
                 // make a copy of the page info
                 wxAuiNotebookPage page_info = m_tabs.GetPage((size_t)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);


@@ -3085,7 +3202,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();


@@ -3095,7 +3212,7 @@ 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
                 nb->SetSelection(nb->m_tabs.GetIdxFromWindow(page_info.window));
 
                 // set the selection in the destination tab control
                 nb->SetSelection(nb->m_tabs.GetIdxFromWindow(page_info.window));
 


@@ -3120,8 +3237,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);


@@ -3132,8 +3249,19 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
         }
          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++,


@@ -3180,6 +3308,8 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
         dest_tabs->Refresh();
 
         SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
         dest_tabs->Refresh();
 
         SetSelection(m_tabs.GetIdxFromWindow(page_info.window));

+        
+        UpdateHintWindowSize();

     }
 }
 
     }
 }
 


@@ -3307,7 +3437,7 @@ void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
             e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
             e.SetOldSelection(evt.GetSelection());
             e.SetEventObject(this);
             e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
             e.SetOldSelection(evt.GetSelection());
             e.SetEventObject(this);

-            GetEventHandler()->ProcessEvent(e);
+            GetParent()->GetEventHandler()->ProcessEvent(e);

             if (!e.IsAllowed())
                 return;
 
             if (!e.IsAllowed())
                 return;