]> git.saurik.com Git - wxWidgets.git/blobdiff - src/aui/auibook.cpp
local Bkgen add bakefile_gen dir
[wxWidgets.git] / src / aui / auibook.cpp
index ff461361e226f6e1605418f69a67a39891f5fd2b..84ed97b2b27d7f1ecd8cf2b44fd8f655140a9754 100644 (file)
 #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)
 WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray)
 
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BUTTON)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG)
 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION)
+DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND)
 
 
 IMPLEMENT_CLASS(wxAuiNotebook, wxControl)
+IMPLEMENT_CLASS(wxAuiTabCtrl, wxControl)
 IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxEvent)
 
 
@@ -72,11 +79,11 @@ static wxBitmap BitmapFromBits(const unsigned char bits[], int w, int h,
     return wxBitmap(img);
 }
 
-static void DrawButtonS(wxDC& dc,
-                       const wxRect& _rect,
-                       const wxBitmap& bmp,
-                       const wxColour& bkcolour,
-                       int button_state)
+static void DrawButtons(wxDC& dc,
+                        const wxRect& _rect,
+                        const wxBitmap& bmp,
+                        const wxColour& bkcolour,
+                        int button_state)
 {
     wxRect rect = _rect;
 
@@ -100,6 +107,110 @@ static void DrawButtonS(wxDC& dc,
     dc.DrawBitmap(bmp, rect.x, rect.y, true);
 }
 
+static void IndentPressedBitmap(wxRect* rect, int button_state)
+{
+    if (button_state == wxAUI_BUTTON_STATE_PRESSED)
+    {
+        rect->x++;
+        rect->y++;
+    }
+}
+
+// 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 --
+
+class wxAuiCommandCapture : public wxEvtHandler
+{
+public:
+    
+    wxAuiCommandCapture() { m_last_id = 0; }
+    int GetCommandId() const { return m_last_id; }
+
+    bool ProcessEvent(wxEvent& evt)
+    {
+        if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
+        {
+            m_last_id = evt.GetId();
+            return true;
+        }
+        
+        if (GetNextHandler())
+            return GetNextHandler()->ProcessEvent(evt);
+
+        return false;
+    }
+    
+private:
+    int m_last_id;
+};
+
+
+// -- bitmaps --
+
+#if defined( __WXMAC__ )
+ static unsigned char close_bits[]={
+     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 };          
+#else
+ static unsigned char close_bits[]={
+     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[] = {
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe,
+   0x1f, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x3f, 0xfe, 0x7f, 0xfe, 0xff, 0xfe,
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+static unsigned char right_bits[] = {
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9f, 0xff, 0x1f, 0xff,
+   0x1f, 0xfe, 0x1f, 0xfc, 0x1f, 0xfe, 0x1f, 0xff, 0x9f, 0xff, 0xdf, 0xff,
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+static unsigned char list_bits[] = {
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+   0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
+   0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+
 
 
 
@@ -112,53 +223,25 @@ wxAuiDefaultTabArt::wxAuiDefaultTabArt()
     m_selected_font = *wxNORMAL_FONT;
     m_selected_font.SetWeight(wxBOLD);
     m_measuring_font = m_selected_font;
-
-    wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
-
-    wxColour background_colour = StepColour(base_colour, 95);
-    wxColour normaltab_colour = base_colour;
-    wxColour selectedtab_colour = *wxWHITE;
-
-    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);
-    
     
-#if defined( __WXMAC__ )
-     static unsigned char close_bits[]={
-         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 };
+    m_fixed_tab_width = 100;
+    m_tab_ctrl_height = 0;
+
+#ifdef __WXMAC__
+    wxBrush toolbarbrush;
+    toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
+    wxColor base_colour = toolbarbrush.GetColour();
 #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};
+    wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 #endif
 
-    static unsigned char left_bits[] = {
-       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe,
-       0x1f, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x3f, 0xfe, 0x7f, 0xfe, 0xff, 0xfe,
-       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+    m_base_colour = base_colour;
+    wxColor darker2_colour = StepColour(base_colour, 70);
+    
+    m_border_pen = wxPen(darker2_colour);
+    m_base_colour_pen = wxPen(m_base_colour);
+    m_base_colour_brush = wxBrush(m_base_colour);
     
-    static unsigned char right_bits[] = {
-       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9f, 0xff, 0x1f, 0xff,
-       0x1f, 0xfe, 0x1f, 0xfc, 0x1f, 0xfe, 0x1f, 0xff, 0x9f, 0xff, 0xdf, 0xff,
-       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
-   
-    static unsigned char list_bits[] = {
-       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-       0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
-       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
-   
-   
     m_active_close_bmp = BitmapFromBits(close_bits, 16, 16, *wxBLACK);
     m_disabled_close_bmp = BitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
     
@@ -171,24 +254,67 @@ wxAuiDefaultTabArt::wxAuiDefaultTabArt()
     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;
 }
 
 wxAuiDefaultTabArt::~wxAuiDefaultTabArt()
 {
 }
 
-void wxAuiDefaultTabArt::DrawBackground(wxDC* dc,
+wxAuiTabArt* wxAuiDefaultTabArt::Clone()
+{
+    return static_cast<wxAuiTabArt*>(new wxAuiDefaultTabArt);
+}
+
+void wxAuiDefaultTabArt::SetFlags(unsigned int flags)
+{
+    m_flags = flags;
+}
+
+void wxAuiDefaultTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
+                                       size_t tab_count)
+{
+    m_fixed_tab_width = 100;
+    
+    int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
+    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 > tot_width/2)
+        m_fixed_tab_width = tot_width/2;
+        
+    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
-    dc->SetBrush(m_bkbrush);
-    dc->SetPen(*wxTRANSPARENT_PEN);
-    dc->DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
-
-    // draw base line
-    dc->SetPen(*wxGREY_PEN);
-    dc->DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
+    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);
+    
+    // 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);
 }
 
 
@@ -201,10 +327,11 @@ void wxAuiDefaultTabArt::DrawBackground(wxDC* dc,
 // out_rect - actual output rectangle
 // x_extent - the advance x; where the next tab should start
 
-void wxAuiDefaultTabArt::DrawTab(wxDC* dc,
+void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
                                  wxWindow* wnd,
                                  const wxRect& in_rect,
                                  const wxString& caption_text,
+                                 const wxBitmap& bitmap,
                                  bool active,
                                  int close_button_state,
                                  wxRect* out_tab_rect,
@@ -220,35 +347,580 @@ void wxAuiDefaultTabArt::DrawTab(wxDC* dc,
     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);
+        
+    // figure out the size of the tab
+    wxSize tab_size = GetTabSize(dc,
+                                 wnd,
+                                 caption,
+                                 bitmap,
+                                 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;
+
+
+    caption = caption_text;
+
+
+    // select pen, brush and font for the tab to be drawn
+
+    if (active)
+    {
+        dc.SetFont(m_selected_font);
+        textx = selected_textx;
+        texty = selected_texty;
+    }
+     else
+    {
+        dc.SetFont(m_normal_font);
+        textx = normal_textx;
+        texty = normal_texty;
+    }
+
+    
+    // create points that will make the tab outline
+    
+    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+tab_width-1, tab_y);
+    clip_points[4] = wxPoint(tab_x+tab_width+1, tab_y+2);
+    clip_points[5] = wxPoint(tab_x+tab_width+1, tab_y+tab_height-3);
+
+    // set the clipping region for the tab --
+    wxRegion clipping_region(6, clip_points);
+    dc.SetClippingRegion(clipping_region);
+
+    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 (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, r.y, r.width, r.height);
+        
+        // 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);
+        
+        // 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);
+        
+        // set rectangle down a bit for gradient drawing
+        r.SetHeight(r.GetHeight()/2);
+        r.x += 2;
+        r.width -= 2;
+        r.y += r.height;
+        
+        // draw gradient background
+        wxColor start_color = StepColour(m_base_colour, 95);
+        wxColor end_color = *wxWHITE;
+        dc.GradientFillLinear(r, start_color, end_color, wxNORTH);
+    }
+     else
+    {
+        // draw inactive tab
+        
+        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
+        r.x += 2;
+        r.width -= 2;
+        r.height /= 2;
+        
+        // -- draw bottom gradient fill for glossy look
+        wxColor top_color = m_base_colour;
+        wxColor bottom_color = StepColour(top_color, 106);
+        dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
+    }
+    
+    // draw tab outline 
+    dc.SetPen(m_border_pen);
+    dc.SetBrush(*wxTRANSPARENT_BRUSH);
+    dc.DrawPolygon(6, 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)
+    {
+        wxColor start_color = StepColour(m_base_colour, 93);
+        dc.SetPen(wxPen(start_color));
+        dc.DrawLine(border_points[0].x,
+                    border_points[0].y,
+                    border_points[5].x+1,
+                    border_points[5].y);
+    }
+    
+
+    int text_offset = tab_x + 8;
+    int close_button_width = 0;
+    if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
+    {
+        close_button_width = m_active_close_bmp.GetWidth();
+    }
+    
+    
+    if (bitmap.IsOk())
+    {
+        int bitmap_offset = tab_x + 8;
+        
+        // draw bitmap
+        dc.DrawBitmap(bitmap,
+                      bitmap_offset,
+                      drawn_tab_yoff + (drawn_tab_height/2) - (bitmap.GetHeight()/2) + 1,
+                      true);
+        
+        text_offset = bitmap_offset + bitmap.GetWidth();
+        text_offset += 3; // bitmap padding
+    }
+     else
+    {
+        text_offset = tab_x + 8;
+    }
+        
+
+    wxString draw_text = ChopText(dc,
+                          caption,
+                          tab_width - (text_offset-tab_x) - close_button_width);
+    
+    // draw tab text
+    dc.DrawText(draw_text,
+                text_offset,
+                drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);
+
+
+
+
+    // draw close button if necessary
+    if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
+    {
+        wxBitmap bmp = m_disabled_close_bmp;
+
+        if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
+            close_button_state == wxAUI_BUTTON_STATE_PRESSED)
+        {
+            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);
+        
+        *out_button_rect = rect;
+    }
+    
+    *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
+    
+    dc.DestroyClippingRegion();
+}
+
+int wxAuiDefaultTabArt::GetIndentSize()
+{
+    return 5;
+}
+
+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;
+    
+    dc.SetFont(m_measuring_font);
+    dc.GetTextExtent(caption, &measured_textx, &measured_texty);
+    
+    dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);
+    
+    // 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)
+        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;
+    }
+    
+    *x_extent = tab_width;
+    
+    return wxSize(tab_width, tab_height);
+}
+
+
+void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
+                                    wxWindow* WXUNUSED(wnd),
+                                    const wxRect& in_rect,
+                                    int bitmap_id,
+                                    int button_state,
+                                    int orientation,
+                                    const wxBitmap& bitmap_override,
+                                    wxRect* out_rect)
+{
+    wxBitmap bmp;
+    wxRect rect;
+    
+    if (bitmap_override.IsOk())
+    {
+        bmp = bitmap_override;
+    }
+     else
+    {
+        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;
+        }
+    }
+
+    if (!bmp.IsOk())
+        return;
+        
+    rect = in_rect;
+    
+    if (orientation == wxLEFT)
+    {
+        rect.SetX(in_rect.x);
+        rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
+        rect.SetWidth(bmp.GetWidth());
+        rect.SetHeight(bmp.GetHeight());
+    }
+     else
+    {
+        rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
+                      ((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);
+    
+    *out_rect = rect;
+}
+
+
+int wxAuiDefaultTabArt::ShowWindowList(wxWindow* wnd,
+                                       const wxArrayString& items,
+                                       int active_idx)
+{
+       wxMenu menuPopup;
+
+    size_t i, count = items.GetCount();
+    for (i = 0; i < count; ++i)
+    {
+        menuPopup.AppendCheckItem(1000+i, items.Item(i));
+    }
+    
+    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
+    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;
+    
+    wxAuiCommandCapture* cc = new wxAuiCommandCapture;
+    wnd->PushEventHandler(cc);
+    wnd->PopupMenu(&menuPopup, pt);
+    int command = cc->GetCommandId();
+    wnd->PopEventHandler(true);
+    
+    if (command >= 1000)
+        return command-1000;
+        
+    return -1;
+}
+
+int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
+                                           wxAuiNotebookPageArray& pages)
+{
+    wxClientDC dc(wnd);
+    dc.SetFont(m_measuring_font);
+    
+    int max_y = 0;
+    size_t i, page_count = pages.GetCount();
+    for (i = 0; i < page_count; ++i)
+    {
+        wxAuiNotebookPage& page = pages.Item(i);
+
+        // 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"),
+                              page.bitmap,
+                              true,
+                              wxAUI_BUTTON_STATE_HIDDEN,
+                              &x_ext);
+        max_y = wxMax(max_y, s.y);
+    }
+    
+    return max_y+2;
+}
+
+void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
+{
+    m_normal_font = font;
+}
+
+void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font)
+{
+    m_selected_font = font;
+}
+
+void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
+{
+    m_measuring_font = font;
+}
+
+
+// -- wxAuiSimpleTabArt class implementation --
+
+wxAuiSimpleTabArt::wxAuiSimpleTabArt()
+{
+    m_normal_font = *wxNORMAL_FONT;
+    m_selected_font = *wxNORMAL_FONT;
+    m_selected_font.SetWeight(wxBOLD);
+    m_measuring_font = m_selected_font;
+
+    m_flags = 0;
+    m_fixed_tab_width = 100;
+
+    wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
+
+    wxColour background_colour = StepColour(base_colour, 95);
+    wxColour normaltab_colour = base_colour;
+    wxColour selectedtab_colour = *wxWHITE;
+
+    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));
+    
+}
+
+wxAuiSimpleTabArt::~wxAuiSimpleTabArt()
+{
+}
+
+wxAuiTabArt* wxAuiSimpleTabArt::Clone()
+{
+    return static_cast<wxAuiTabArt*>(new wxAuiSimpleTabArt);
+}
+
+
+void wxAuiSimpleTabArt::SetFlags(unsigned int flags)
+{
+    m_flags = flags;
+}
+
+void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
+                                      size_t tab_count)
+{
+    m_fixed_tab_width = 100;
+    
+    int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
+    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 > tot_width/2)
+        m_fixed_tab_width = tot_width/2;
+        
+    if (m_fixed_tab_width > 220)
+        m_fixed_tab_width = 220;
+}
+
+void wxAuiSimpleTabArt::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);
+
+    // draw base line
+    dc.SetPen(*wxGREY_PEN);
+    dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
+}
+
+
+// DrawTab() draws an individual tab.
+//
+// dc       - output dc
+// in_rect  - rectangle the tab should be confined to
+// caption  - tab's caption
+// active   - whether or not the tab is active
+// out_rect - actual output rectangle
+// x_extent - the advance x; where the next tab should start
+
+void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
+                                wxWindow* wnd,
+                                const wxRect& in_rect,
+                                const wxString& caption_text,
+                                const wxBitmap& bitmap,
+                                bool active,
+                                int close_button_state,
+                                wxRect* out_tab_rect,
+                                wxRect* out_button_rect,
+                                int* x_extent)
+{
+    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");
+            
+    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);
+    wxSize tab_size = GetTabSize(dc,
+                                 wnd,
+                                 caption,
+                                 bitmap,
+                                 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;
 
+    caption = caption_text;
+
     // select pen, brush and font for the tab to be drawn
 
     if (active)
     {
-        dc->SetPen(m_selected_bkpen);
-        dc->SetBrush(m_selected_bkbrush);
-        dc->SetFont(m_selected_font);
+        dc.SetPen(m_selected_bkpen);
+        dc.SetBrush(m_selected_bkbrush);
+        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);
+        dc.SetPen(m_normal_bkpen);
+        dc.SetBrush(m_normal_bkbrush);
+        dc.SetFont(m_normal_font);
         textx = normal_textx;
         texty = normal_texty;
     }
@@ -271,13 +943,14 @@ void wxAuiDefaultTabArt::DrawTab(wxDC* dc,
     points[5].y = tab_y + tab_height - 1;
     points[6] = points[0];
 
+    dc.SetClippingRegion(in_rect);
 
-    dc->DrawPolygon(6, points);
+    dc.DrawPolygon(6, points);
 
-    dc->SetPen(*wxGREY_PEN);
+    dc.SetPen(*wxGREY_PEN);
 
-    //dc->DrawLines(active ? 6 : 7, points);
-    dc->DrawLines(7, points);
+    //dc.DrawLines(active ? 6 : 7, points);
+    dc.DrawLines(7, points);
 
 
     int text_offset;
@@ -293,9 +966,17 @@ void wxAuiDefaultTabArt::DrawTab(wxDC* dc,
         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
+    wxString draw_text = ChopText(dc,
+                          caption,
+                          tab_width - (text_offset-tab_x) - close_button_width);
 
     // draw tab text
-    dc->DrawText(caption,
+    dc.DrawText(draw_text,
                  text_offset,
                  (tab_y + tab_height)/2 - (texty/2) + 1);
 
@@ -313,49 +994,60 @@ void wxAuiDefaultTabArt::DrawTab(wxDC* dc,
                     tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
                     close_button_width,
                     tab_height - 1);
-        DrawButtonS(*dc, rect, bmp, *wxWHITE, close_button_state);
+        DrawButtons(dc, rect, bmp, *wxWHITE, close_button_state);
         
         *out_button_rect = rect;
     }
 
 
     *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
+    
+    dc.DestroyClippingRegion();
 }
 
+int wxAuiSimpleTabArt::GetIndentSize()
+{
+    return 0;
+}
 
-wxSize wxAuiDefaultTabArt::GetTabSize(wxDC* dc,
-                                      wxWindow* WXUNUSED(wnd),
-                                      const wxString& caption,
-                                      bool WXUNUSED(active),
-                                      int close_button_state,
-                                      int* x_extent)
+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;
     
-    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();
-
+        
+    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);
 }
 
 
-void wxAuiDefaultTabArt::DrawButton(
-                                    wxDC* dc,
-                                    wxWindow* WXUNUSED(wnd),
-                                    const wxRect& in_rect,
-                                    int bitmap_id,
-                                    int button_state,
-                                    int orientation,
-                                    const wxBitmap& bitmap_override,
-                                    wxRect* out_rect)
+void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
+                                   wxWindow* WXUNUSED(wnd),
+                                   const wxRect& in_rect,
+                                   int bitmap_id,
+                                   int button_state,
+                                   int orientation,
+                                   const wxBitmap& bitmap_override,
+                                   wxRect* out_rect)
 {
     wxBitmap bmp;
     wxRect rect;
@@ -415,46 +1107,15 @@ void wxAuiDefaultTabArt::DrawButton(
     }
     
         
-    DrawButtonS(*dc, rect, bmp, *wxWHITE, button_state);
-    
-    *out_rect = rect;
-}
-
-
-
-
-// -- GUI helper classes and functions --
-
-class wxAuiCommandCapture : public wxEvtHandler
-{
-public:
-    
-    wxAuiCommandCapture() { m_last_id = 0; }
-    int GetCommandId() const { return m_last_id; }
-
-    bool ProcessEvent(wxEvent& evt)
-    {
-        if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
-        {
-            m_last_id = evt.GetId();
-            return true;
-        }
-        
-        if (GetNextHandler())
-            return GetNextHandler()->ProcessEvent(evt);
-
-        return false;
-    }
+    DrawButtons(dc, rect, bmp, *wxWHITE, button_state);
     
-private:
-    int m_last_id;
-};
-
+    *out_rect = rect;
+}
 
 
-int wxAuiDefaultTabArt::ShowWindowList(wxWindow* wnd,
-                                       const wxArrayString& items,
-                                       int active_idx)
+int wxAuiSimpleTabArt::ShowWindowList(wxWindow* wnd,
+                                      const wxArrayString& items,
+                                      int active_idx)
 {
        wxMenu menuPopup;
 
@@ -495,31 +1156,33 @@ int wxAuiDefaultTabArt::ShowWindowList(wxWindow* wnd,
     return -1;
 }
 
-int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd)
+int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
+                                          wxAuiNotebookPageArray& WXUNUSED(pages))
 {
     wxClientDC dc(wnd);
     dc.SetFont(m_measuring_font);
     int x_ext = 0;
-    wxSize s = GetTabSize(&dc,
+    wxSize s = GetTabSize(dc,
                           wnd,
                           wxT("ABCDEFGHIj"),
+                          wxNullBitmap,
                           true,
                           wxAUI_BUTTON_STATE_HIDDEN,
                           &x_ext);
     return s.y+3;
 }
 
-void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
+void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
 {
     m_normal_font = font;
 }
 
-void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font)
+void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
 {
     m_selected_font = font;
 }
 
-void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
+void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
 {
     m_measuring_font = font;
 }
@@ -527,8 +1190,6 @@ void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
 
 
 
-
-
 // -- wxAuiTabContainer class implementation --
 
 
@@ -563,9 +1224,14 @@ void wxAuiTabContainer::SetArtProvider(wxAuiTabArt* art)
 {
     delete m_art;
     m_art = art;
+    
+    if (m_art)
+    {
+        m_art->SetFlags(m_flags);
+    }
 }
 
-wxAuiTabArt* wxAuiTabContainer::GetArtProvider()
+wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const
 {
     return m_art;
 }
@@ -596,6 +1262,11 @@ void wxAuiTabContainer::SetFlags(unsigned int flags)
     {
         AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
     }
+    
+    if (m_art)
+    {
+        m_art->SetFlags(m_flags);
+    }
 }
 
 unsigned int wxAuiTabContainer::GetFlags() const
@@ -622,6 +1293,11 @@ void wxAuiTabContainer::SetMeasuringFont(const wxFont& font)
 void wxAuiTabContainer::SetRect(const wxRect& rect)
 {
     m_rect = rect;
+    
+    if (m_art)
+    {
+        m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());
+    }
 }
 
 bool wxAuiTabContainer::AddPage(wxWindow* page,
@@ -633,6 +1309,12 @@ bool wxAuiTabContainer::AddPage(wxWindow* page,
 
     m_pages.Add(page_info);
 
+    // let the art provider know how many pages we have
+    if (m_art)
+    {
+        m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
+    }
+    
     return true;
 }
 
@@ -649,6 +1331,12 @@ bool wxAuiTabContainer::InsertPage(wxWindow* page,
          else
         m_pages.Insert(page_info, idx);
 
+    // let the art provider know how many pages we have
+    if (m_art)
+    {
+        m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
+    }
+    
     return true;
 }
 
@@ -680,6 +1368,13 @@ bool wxAuiTabContainer::RemovePage(wxWindow* wnd)
         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());
+            }
+             
             return true;
         }
     }
@@ -818,11 +1513,17 @@ void wxAuiTabContainer::SetTabOffset(size_t offset)
     m_tab_offset = offset;
 }
 
+
+
+
 // Render() renders the tab catalog to the specified DC
 // It is a virtual function and can be overridden to
 // 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;
@@ -833,6 +1534,8 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
     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
@@ -852,9 +1555,10 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         
     
         int x_extent = 0;
-        wxSize size = m_art->GetTabSize(&dc,
+        wxSize size = m_art->GetTabSize(dc,
                             wnd,
                             page.caption,
+                            page.bitmap,
                             page.active,
                             close_button ?
                               wxAUI_BUTTON_STATE_NORMAL :
@@ -875,7 +1579,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         }
     }
     
-    if (total_width > m_rect.GetWidth() - 20 || m_tab_offset != 0)
+    if (total_width > m_rect.GetWidth() || m_tab_offset != 0)
     {
         // show left/right buttons
         for (i = 0; i < button_count; ++i)
@@ -925,7 +1629,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 
 
     // draw background
-    m_art->DrawBackground(&dc, wnd, m_rect);
+    m_art->DrawBackground(dc, wnd, m_rect);
 
     // draw buttons
     int left_buttons_width = 0;
@@ -948,7 +1652,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         button_rect.SetY(1);
         button_rect.SetWidth(offset);
 
-        m_art->DrawButton(&dc,
+        m_art->DrawButton(dc,
                           wnd,
                           button_rect,
                           button.id,
@@ -978,7 +1682,7 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
    
         wxRect button_rect(offset, 1, 1000, m_rect.height);
 
-        m_art->DrawButton(&dc,
+        m_art->DrawButton(dc,
                           wnd,
                           button_rect,
                           button.id,
@@ -993,14 +1697,16 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 
     offset = left_buttons_width;
     
-    // set a clipping region to the tabs don't draw over the buttons
-    dc.SetClippingRegion(left_buttons_width, 0,
-                 m_rect.GetWidth() - right_buttons_width - left_buttons_width - 2,
-                 m_rect.GetHeight());
-           
-           
+    if (offset == 0)
+        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;
+    
+    // make sure there are enough tab button entries to accommodate all tabs
     while (m_tab_close_buttons.GetCount() < page_count)
     {
         wxAuiTabContainerButton tempbtn;
@@ -1010,9 +1716,10 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         m_tab_close_buttons.Add(tempbtn);
     }
     
+    
+    // buttons before the tab offset must be set to hidden
     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;
     }
         
@@ -1021,11 +1728,11 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
 
     size_t active = 999;
     int active_offset = 0;
+    wxRect active_rect;
 
     int x_extent = 0;
     wxRect rect = m_rect;
     rect.y = 0;
-    rect.width = 1000;
     rect.height = m_rect.height;
 
     for (i = m_tab_offset; i < page_count; ++i)
@@ -1052,11 +1759,16 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         }
 
         rect.x = offset;
+        rect.width = m_rect.width - right_buttons_width - offset - 2;
+
+        if (rect.width <= 0)
+            break;
 
-        m_art->DrawTab(&dc,
+        m_art->DrawTab(dc,
                        wnd,
                        rect,
                        page.caption,
+                       page.bitmap,
                        page.active,
                        tab_button.cur_state,
                        &page.rect,
@@ -1067,11 +1779,20 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         {
             active = i;
             active_offset = offset;
+            active_rect = rect;
         }
         
         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())
     {
@@ -1088,10 +1809,11 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
         }
 
         rect.x = active_offset;
-        m_art->DrawTab(&dc,
+        m_art->DrawTab(dc,
                        wnd,
-                       rect,
+                       active_rect,
                        page.caption,
+                       page.bitmap,
                        page.active,
                        tab_button.cur_state,
                        &page.rect,
@@ -1099,7 +1821,6 @@ void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
                        &x_extent);
     }
 
-    dc.DestroyClippingRegion();
     
     raw_dc->Blit(m_rect.x, m_rect.y,
                  m_rect.GetWidth(), m_rect.GetHeight(),
@@ -1153,7 +1874,9 @@ bool wxAuiTabContainer::ButtonHitTest(int x, int y,
     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;
@@ -1165,7 +1888,9 @@ bool wxAuiTabContainer::ButtonHitTest(int x, int y,
     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;
@@ -1251,6 +1976,7 @@ wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent,
     m_click_pt = wxDefaultPosition;
     m_is_dragging = false;
     m_hover_button = NULL;
+    m_pressed_button = NULL;
 }
 
 wxAuiTabCtrl::~wxAuiTabCtrl()
@@ -1284,30 +2010,38 @@ void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
     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))
     {
-        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);
+        
+        if (new_selection != GetActivePage())
+        {
+            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_tab = wnd;
     }
-
+    
     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();
     }
 }
 
-void wxAuiTabCtrl::OnLeftUp(wxMouseEvent&)
+void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
 {
     if (GetCapture() == this)
         ReleaseMouse();
@@ -1322,19 +2056,31 @@ void wxAuiTabCtrl::OnLeftUp(wxMouseEvent&)
         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();
 
-        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);
-            evt.SetInt(m_hover_button->id);
+            evt.SetInt(m_pressed_button->id);
             evt.SetEventObject(this);
             GetEventHandler()->ProcessEvent(evt);
         }
+        
+        m_pressed_button = NULL;
     }
 
     m_click_pt = wxDefaultPosition;
@@ -1515,10 +2261,9 @@ public:
         if (!m_tabs)
             return;
 
-        int tab_height = wxMin(m_rect.height, m_tab_ctrl_height);
-        m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, tab_height);
-        m_tabs->SetSize(m_rect.x, m_rect.y, m_rect.width, tab_height);
-        m_tabs->SetRect(wxRect(0, 0, m_rect.width, tab_height));
+        m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
+        m_tabs->SetSize(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
+        m_tabs->SetRect(wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
         m_tabs->Refresh();
         m_tabs->Update();
 
@@ -1528,8 +2273,8 @@ public:
         for (i = 0; i < page_count; ++i)
         {
             wxAuiNotebookPage& page = pages.Item(i);
-            page.window->SetSize(m_rect.x, m_rect.y+tab_height,
-                                 m_rect.width, m_rect.height-tab_height);
+            page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
+                                 m_rect.width, m_rect.height - m_tab_ctrl_height);
 
             if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
             {
@@ -1633,8 +2378,7 @@ void wxAuiNotebook::InitNotebook(long style)
     m_selected_font = *wxNORMAL_FONT;
     m_selected_font.SetWeight(wxBOLD);
 
-    // choose a default for the tab height
-    m_tab_ctrl_height = m_tabs.GetArtProvider()->GetBestTabCtrlSize(this);
+    SetArtProvider(new wxAuiDefaultTabArt);
 
     m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
     m_dummy_wnd->SetSize(200, 200);
@@ -1656,9 +2400,46 @@ wxAuiNotebook::~wxAuiNotebook()
 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
 {
     m_tabs.SetArtProvider(art);
+    
+    SetTabCtrlHeight(CalculateTabCtrlHeight());
+}
+
+void wxAuiNotebook::SetTabCtrlHeight(int height)
+{
+    // 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();
+        }
+    }
+}
+
+int wxAuiNotebook::CalculateTabCtrlHeight()
+{
+    // find out new best tab height
+    wxAuiTabArt* art = m_tabs.GetArtProvider();
+  
+    return art->GetBestTabCtrlSize(this, m_tabs.GetPages());
 }
 
-wxAuiTabArt* wxAuiNotebook::GetArtProvider()
+
+wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
 {
     return m_tabs.GetArtProvider();
 }
@@ -1723,6 +2504,7 @@ bool wxAuiNotebook::InsertPage(size_t page_idx,
          else
         active_tabctrl->InsertPage(page, info, page_idx);
 
+    SetTabCtrlHeight(CalculateTabCtrlHeight());
     DoSizing();
     active_tabctrl->DoShowHide();
 
@@ -1743,6 +2525,33 @@ bool wxAuiNotebook::InsertPage(size_t page_idx,
 bool wxAuiNotebook::DeletePage(size_t page_idx)
 {    
     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
+
+    if (!RemovePage(page_idx))
+        return false;
+
+    // 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();
+    }
+    
+    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;
 
     // find out which onscreen tab ctrl owns this tab
@@ -1783,18 +2592,6 @@ bool wxAuiNotebook::DeletePage(size_t page_idx)
     // 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();
 
@@ -1808,53 +2605,67 @@ bool wxAuiNotebook::DeletePage(size_t page_idx)
     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)
+
+// SetPageText() changes the tab caption of the specified page
+bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
 {
-    // remove the tab from our own catalog
-    wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
-    if (!m_tabs.RemovePage(wnd))
+    if (page_idx >= m_tabs.GetPageCount())
         return false;
 
-    // remove the tab from the onscreen tab ctrl
+    // update our own tab catalog
+    wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
+    page_info.caption = text;
+
+    // update what's on screen
     wxAuiTabCtrl* ctrl;
     int ctrl_idx;
-    if (FindTab(wnd, &ctrl, &ctrl_idx))
+    if (FindTab(page_info.window, &ctrl, &ctrl_idx))
     {
-        ctrl->RemovePage(wnd);
-        return true;
+        wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
+        info.caption = text;
+        ctrl->Refresh();
+        ctrl->Update();
     }
 
-    return false;
+    return true;
 }
 
-// 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);
-    page_info.caption = text;
-
+    page_info.bitmap = bitmap;
+    
+    // tab height might have changed
+    SetTabCtrlHeight(CalculateTabCtrlHeight());
+    
     // update what's on screen
     wxAuiTabCtrl* ctrl;
     int 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();
     }
-
+    
     return true;
 }
 
+
 // GetSelection() returns the index of the currently active page
 int wxAuiNotebook::GetSelection() const
 {
@@ -1874,12 +2685,14 @@ size_t wxAuiNotebook::SetSelection(size_t new_page)
     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);
 
 
-
         wxAuiTabCtrl* ctrl;
         int ctrl_idx;
         if (FindTab(wnd, &ctrl, &ctrl_idx))
@@ -1890,8 +2703,6 @@ size_t wxAuiNotebook::SetSelection(size_t new_page)
             DoSizing();
             ctrl->DoShowHide();
 
-            int old_curpage = m_curpage;
-            m_curpage = new_page;
 
 
             // set fonts
@@ -1988,6 +2799,7 @@ wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
                                         wxDefaultSize,
                                         wxNO_BORDER);
     tabframe->m_tabs->SetFlags(m_flags);
+    tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
     m_mgr.AddPane(tabframe,
                   wxAuiPaneInfo().Center().CaptionVisible(false));
 
@@ -2059,8 +2871,8 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
     wxPoint zero(0,0);
 
     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
-
     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
+    
     if (dest_tabs == src_tabs)
     {
         if (src_tabs)
@@ -2109,11 +2921,58 @@ void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
     }
 
 
+    // if external drag is allowed, check if the tab is being dragged
+    // over a different wxAuiNotebook control
+    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
+        if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
+        {
+            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 (nb != this)
+                {
+                    wxRect hint_rect = tab_ctrl->GetClientRect();
+                    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))
-    {
         return;
-    }
 
 
     if (src_tabs)
@@ -2142,16 +3001,12 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
 
     m_mgr.HideHint();
 
-    // if tab moving is not allowed, leave
-    if (!(m_flags & wxAUI_NB_TAB_SPLIT))
-    {
-        return;
-    }
     
-    // set cursor back to an arrow
     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));
     }
     
@@ -2160,79 +3015,168 @@ void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
 
 
-    // the src tab control is the control that fired this event
-    wxAuiTabCtrl* dest_tabs = NULL;
-
 
-    // If the pointer is in an existing tab frame, do a tab insert
-    wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
-    wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
-    int insert_idx = -1;
-    if (tab_frame)
+    // check for an external move
+    if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
     {
-        dest_tabs = tab_frame->m_tabs;
-
-        if (dest_tabs == src_tabs)
-            return;
+        wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
         
-            
-        wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
-        wxWindow* target = NULL;
-        dest_tabs->TabHitTest(pt.x, pt.y, &target);
-        if (target)
+        while (tab_ctrl)
         {
-            insert_idx = dest_tabs->GetIdxFromWindow(target);
+            if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
+                break;
+            tab_ctrl = tab_ctrl->GetParent();
         }
-    }
-     else
-    {
-        // If there is no tabframe at all, create one
-        wxTabFrame* new_tabs = new wxTabFrame;
-        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->SetFlags(m_flags);
+        
+        if (tab_ctrl)
+        {
+            wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
+            
+            if (nb != this)
+            {
+                // find out from the destination control
+                // if it's ok to drop this tab here
+                wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
+                e.SetSelection(evt.GetSelection());
+                e.SetOldSelection(evt.GetSelection());
+                e.SetEventObject(this);
+                e.SetDragSource(this);
+                e.Veto(); // dropping must be explicitly approved by control owner
+                
+                nb->GetEventHandler()->ProcessEvent(e);
+                
+                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);
+                
+                // 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);
+                
+                // remove the page from the source notebook
+                RemovePage(main_idx);
+                
+                // 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);
+
+                wxWindow* target = NULL;
+                int insert_idx = -1;
+                dest_tabs->TabHitTest(pt.x, pt.y, &target);
+                if (target)
+                {
+                    insert_idx = dest_tabs->GetIdxFromWindow(target);
+                }
+
+                
+                // add the page to the new notebook
+                if (insert_idx == -1)
+                    insert_idx = dest_tabs->GetPageCount();
+                dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
+                nb->m_tabs.AddPage(page_info.window, page_info);
+
+                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));
 
-        m_mgr.AddPane(new_tabs,
-                      wxAuiPaneInfo().Bottom().CaptionVisible(false),
-                      mouse_client_pt);
-        m_mgr.Update();
-        dest_tabs = new_tabs->m_tabs;
+                return;
+            }
+        }
     }
 
 
 
-    // remove the page from the source tabs
-    wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
-    page_info.active = false;
-    src_tabs->RemovePage(page_info.window);
-    if (src_tabs->GetPageCount() > 0)
+
+    // only perform a tab split if it's allowed
+    if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
     {
-        src_tabs->SetActivePage((size_t)0);
-        src_tabs->DoShowHide();
-        src_tabs->Refresh();
-    }
+        // If the pointer is in an existing tab frame, do a tab insert
+        wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
+        wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
+        int insert_idx = -1;
+        if (tab_frame)
+        {
+            dest_tabs = tab_frame->m_tabs;
 
+            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);
+            if (target)
+            {
+                insert_idx = dest_tabs->GetIdxFromWindow(target);
+            }
+        }
+         else
+        {
+            // If there is no tabframe at all, create one
+            wxTabFrame* new_tabs = new wxTabFrame;
+            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);
+
+            m_mgr.AddPane(new_tabs,
+                          wxAuiPaneInfo().Bottom().CaptionVisible(false),
+                          mouse_client_pt);
+            m_mgr.Update();
+            dest_tabs = new_tabs->m_tabs;
+        }
 
 
-    // add the page to the destination tabs
-    if (insert_idx == -1)
-        insert_idx = dest_tabs->GetPageCount();
-    dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
 
-    if (src_tabs->GetPageCount() == 0)
-    {
-        RemoveEmptyTabFrames();
-    }
+        // remove the page from the source tabs
+        wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
+        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();
+        }
 
-    DoSizing();
-    dest_tabs->DoShowHide();
-    dest_tabs->Refresh();
 
-    SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
+
+        // add the page to the destination tabs
+        if (insert_idx == -1)
+            insert_idx = dest_tabs->GetPageCount();
+        dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
+
+        if (src_tabs->GetPageCount() == 0)
+        {
+            RemoveEmptyTabFrames();
+        }
+
+        DoSizing();
+        dest_tabs->DoShowHide();
+        dest_tabs->Refresh();
+
+        SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
+    }
 }
 
 
@@ -2353,6 +3297,17 @@ void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
         {
             wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
 
+
+            // ask owner if it's ok to close the tab
+            wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
+            e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
+            e.SetOldSelection(evt.GetSelection());
+            e.SetEventObject(this);
+            GetEventHandler()->ProcessEvent(e);
+            if (!e.IsAllowed())
+                return;
+
+
             if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
             {
                 close_wnd->Close();