src/aui/auibook.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/aui/auibook.cpp
   3 // Purpose:     wxaui: wx advanced user interface - notebook
   4 // Author:      Benjamin I. Williams
   5 // Modified by:
   6 // Created:     2006-06-28
   7 // Copyright:   (C) Copyright 2006, Kirix Corporation, All Rights Reserved
   8 // Licence:     wxWindows Library Licence, Version 3.1
   9 ///////////////////////////////////////////////////////////////////////////////
  10
  11 // ----------------------------------------------------------------------------
  12 // headers
  13 // ----------------------------------------------------------------------------
  14
  15 #include "wx/wxprec.h"
  16
  17 #ifdef __BORLANDC__
  18     #pragma hdrstop
  19 #endif
  20
  21 #if wxUSE_AUI
  22
  23 #include "wx/aui/auibook.h"
  24
  25 #ifndef WX_PRECOMP
  26     #include "wx/settings.h"
  27     #include "wx/image.h"
  28 #endif
  29
  30 #include "wx/aui/tabmdi.h"
  31 #include "wx/dcbuffer.h"
  32 #include "wx/menu.h"
  33
  34 #ifdef __WXMAC__
  35 #include "wx/mac/carbon/private.h"
  36 #endif
  37
  38 #include "wx/arrimpl.cpp"
  39 WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray)
  40 WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray)
  41
  42 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE)
  43 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING)
  44 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED)
  45 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BUTTON)
  46 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG)
  47 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG)
  48 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION)
  49 DEFINE_EVENT_TYPE(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND)
  50
  51
  52 IMPLEMENT_CLASS(wxAuiNotebook, wxControl)
  53 IMPLEMENT_CLASS(wxAuiTabCtrl, wxControl)
  54 IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxEvent)
  55
  56
  57
  58
  59
  60 // these functions live in dockart.cpp -- they'll eventually
  61 // be moved to a new utility cpp file
  62
  63 wxColor wxAuiStepColour(const wxColor& c, int percent);
  64
  65 wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
  66                              const wxColour& color);
  67
  68 wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size);
  69
  70 static void DrawButtons(wxDC& dc,
  71                         const wxRect& _rect,
  72                         const wxBitmap& bmp,
  73                         const wxColour& bkcolour,
  74                         int button_state)
  75 {
  76     wxRect rect = _rect;
  77
  78     if (button_state == wxAUI_BUTTON_STATE_PRESSED)
  79     {
  80         rect.x++;
  81         rect.y++;
  82     }
  83
  84     if (button_state == wxAUI_BUTTON_STATE_HOVER ||
  85         button_state == wxAUI_BUTTON_STATE_PRESSED)
  86     {
  87         dc.SetBrush(wxBrush(wxAuiStepColour(bkcolour, 120)));
  88         dc.SetPen(wxPen(wxAuiStepColour(bkcolour, 75)));
  89
  90         // draw the background behind the button
  91         dc.DrawRectangle(rect.x, rect.y, 15, 15);
  92     }
  93
  94     // draw the button itself
  95     dc.DrawBitmap(bmp, rect.x, rect.y, true);
  96 }
  97
  98 static void IndentPressedBitmap(wxRect* rect, int button_state)
  99 {
 100     if (button_state == wxAUI_BUTTON_STATE_PRESSED)
 101     {
 102         rect->x++;
 103         rect->y++;
 104     }
 105 }
 106
 107
 108
 109 // -- GUI helper classes and functions --
 110
 111 class wxAuiCommandCapture : public wxEvtHandler
 112 {
 113 public:
 114
 115     wxAuiCommandCapture() { m_last_id = 0; }
 116     int GetCommandId() const { return m_last_id; }
 117
 118     bool ProcessEvent(wxEvent& evt)
 119     {
 120         if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
 121         {
 122             m_last_id = evt.GetId();
 123             return true;
 124         }
 125
 126         if (GetNextHandler())
 127             return GetNextHandler()->ProcessEvent(evt);
 128
 129         return false;
 130     }
 131
 132 private:
 133     int m_last_id;
 134 };
 135
 136
 137 // -- bitmaps --
 138
 139 #if defined( __WXMAC__ )
 140  static unsigned char close_bits[]={
 141      0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
 142      0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
 143      0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
 144 #elif defined( __WXGTK__)
 145  static unsigned char close_bits[]={
 146      0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
 147      0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
 148      0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 149 #else
 150  static unsigned char close_bits[]={
 151      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
 152      0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
 153      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 154 #endif
 155
 156 static unsigned char left_bits[] = {
 157    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe,
 158    0x1f, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x3f, 0xfe, 0x7f, 0xfe, 0xff, 0xfe,
 159    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 160
 161 static unsigned char right_bits[] = {
 162    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9f, 0xff, 0x1f, 0xff,
 163    0x1f, 0xfe, 0x1f, 0xfc, 0x1f, 0xfe, 0x1f, 0xff, 0x9f, 0xff, 0xdf, 0xff,
 164    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 165
 166 static unsigned char list_bits[] = {
 167    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 168    0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
 169    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 170
 171
 172
 173
 174
 175
 176 // -- wxAuiDefaultTabArt class implementation --
 177
 178 wxAuiDefaultTabArt::wxAuiDefaultTabArt()
 179 {
 180     m_normal_font = *wxNORMAL_FONT;
 181     m_selected_font = *wxNORMAL_FONT;
 182     m_selected_font.SetWeight(wxBOLD);
 183     m_measuring_font = m_selected_font;
 184
 185     m_fixed_tab_width = 100;
 186     m_tab_ctrl_height = 0;
 187
 188 #ifdef __WXMAC__
 189     wxBrush toolbarbrush;
 190     toolbarbrush.MacSetTheme( kThemeBrushToolbarBackground );
 191     wxColor base_colour = toolbarbrush.GetColour();
 192 #else
 193     wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 194 #endif
 195
 196     // the base_colour is too pale to use as our base colour,
 197     // so darken it a bit --
 198     if ((255-base_colour.Red()) +
 199         (255-base_colour.Green()) +
 200         (255-base_colour.Blue()) < 60)
 201     {
 202         base_colour = wxAuiStepColour(base_colour, 92);
 203     }
 204
 205     m_base_colour = base_colour;
 206     wxColor border_colour = wxAuiStepColour(base_colour, 75);
 207
 208     m_border_pen = wxPen(border_colour);
 209     m_base_colour_pen = wxPen(m_base_colour);
 210     m_base_colour_brush = wxBrush(m_base_colour);
 211
 212     m_active_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
 213     m_disabled_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
 214
 215     m_active_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
 216     m_disabled_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
 217
 218     m_active_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
 219     m_disabled_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
 220
 221     m_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
 222     m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
 223
 224     m_flags = 0;
 225 }
 226
 227 wxAuiDefaultTabArt::~wxAuiDefaultTabArt()
 228 {
 229 }
 230
 231 wxAuiTabArt* wxAuiDefaultTabArt::Clone()
 232 {
 233     return static_cast<wxAuiTabArt*>(new wxAuiDefaultTabArt);
 234 }
 235
 236 void wxAuiDefaultTabArt::SetFlags(unsigned int flags)
 237 {
 238     m_flags = flags;
 239 }
 240
 241 void wxAuiDefaultTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
 242                                        size_t tab_count)
 243 {
 244     m_fixed_tab_width = 100;
 245
 246     int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
 247
 248     if (m_flags & wxAUI_NB_CLOSE_BUTTON)
 249         tot_width -= m_active_close_bmp.GetWidth();
 250     if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
 251         tot_width -= m_active_windowlist_bmp.GetWidth();
 252
 253     if (tab_count > 0)
 254     {
 255         m_fixed_tab_width = tot_width/(int)tab_count;
 256     }
 257
 258
 259     if (m_fixed_tab_width < 100)
 260         m_fixed_tab_width = 100;
 261
 262     if (m_fixed_tab_width > tot_width/2)
 263         m_fixed_tab_width = tot_width/2;
 264
 265     if (m_fixed_tab_width > 220)
 266         m_fixed_tab_width = 220;
 267
 268     m_tab_ctrl_height = tab_ctrl_size.y;
 269 }
 270
 271
 272 void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
 273                                         wxWindow* WXUNUSED(wnd),
 274                                         const wxRect& rect)
 275 {
 276     // draw background
 277     wxRect r(rect.x, rect.y, rect.width+2, rect.height-3);
 278     wxColor top_color = wxAuiStepColour(m_base_colour, 90);
 279     wxColor bottom_color = wxAuiStepColour(m_base_colour, 170);
 280     dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
 281
 282     // draw base lines
 283     int y = rect.GetHeight();
 284     int w = rect.GetWidth();
 285     dc.SetPen(m_border_pen);
 286     dc.SetBrush(m_base_colour_brush);
 287     dc.DrawRectangle(-1, y-4, w+2, 4);
 288 }
 289
 290
 291 // DrawTab() draws an individual tab.
 292 //
 293 // dc       - output dc
 294 // in_rect  - rectangle the tab should be confined to
 295 // caption  - tab's caption
 296 // active   - whether or not the tab is active
 297 // out_rect - actual output rectangle
 298 // x_extent - the advance x; where the next tab should start
 299
 300 void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
 301                                  wxWindow* wnd,
 302                                  const wxRect& in_rect,
 303                                  const wxString& caption_text,
 304                                  const wxBitmap& bitmap,
 305                                  bool active,
 306                                  int close_button_state,
 307                                  wxRect* out_tab_rect,
 308                                  wxRect* out_button_rect,
 309                                  int* x_extent)
 310 {
 311     wxCoord normal_textx, normal_texty;
 312     wxCoord selected_textx, selected_texty;
 313     wxCoord textx, texty;
 314
 315     // if the caption is empty, measure some temporary text
 316     wxString caption = caption_text;
 317     if (caption_text.empty())
 318         caption = wxT("Xj");
 319
 320     dc.SetFont(m_selected_font);
 321     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
 322
 323     dc.SetFont(m_normal_font);
 324     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
 325
 326     // figure out the size of the tab
 327     wxSize tab_size = GetTabSize(dc,
 328                                  wnd,
 329                                  caption,
 330                                  bitmap,
 331                                  active,
 332                                  close_button_state,
 333                                  x_extent);
 334
 335     wxCoord tab_height = m_tab_ctrl_height - 3;
 336     wxCoord tab_width = tab_size.x;
 337     wxCoord tab_x = in_rect.x;
 338     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
 339
 340
 341     caption = caption_text;
 342
 343
 344     // select pen, brush and font for the tab to be drawn
 345
 346     if (active)
 347     {
 348         dc.SetFont(m_selected_font);
 349         textx = selected_textx;
 350         texty = selected_texty;
 351     }
 352      else
 353     {
 354         dc.SetFont(m_normal_font);
 355         textx = normal_textx;
 356         texty = normal_texty;
 357     }
 358
 359
 360     // create points that will make the tab outline
 361
 362     int clip_width = tab_width;
 363     if (tab_x + clip_width > in_rect.x + in_rect.width)
 364         clip_width = (in_rect.x + in_rect.width) - tab_x;
 365
 366 /*
 367     wxPoint clip_points[6];
 368     clip_points[0] = wxPoint(tab_x,              tab_y+tab_height-3);
 369     clip_points[1] = wxPoint(tab_x,              tab_y+2);
 370     clip_points[2] = wxPoint(tab_x+2,            tab_y);
 371     clip_points[3] = wxPoint(tab_x+clip_width-1, tab_y);
 372     clip_points[4] = wxPoint(tab_x+clip_width+1, tab_y+2);
 373     clip_points[5] = wxPoint(tab_x+clip_width+1, tab_y+tab_height-3);
 374
 375     // FIXME: these ports don't provide wxRegion ctor from array of points
 376 #if !defined(__WXDFB__) && !defined(__WXCOCOA__)
 377     // set the clipping region for the tab --
 378     wxRegion clipping_region(WXSIZEOF(clip_points), clip_points);
 379     dc.SetClippingRegion(clipping_region);
 380 #endif // !wxDFB && !wxCocoa
 381 */
 382     // since the above code above doesn't play well with WXDFB or WXCOCOA,
 383     // we'll just use a rectangle for the clipping region for now --
 384     dc.SetClippingRegion(tab_x, tab_y, clip_width+1, tab_height-3);
 385
 386
 387     wxPoint border_points[6];
 388     border_points[0] = wxPoint(tab_x,             tab_y+tab_height-4);
 389     border_points[1] = wxPoint(tab_x,             tab_y+2);
 390     border_points[2] = wxPoint(tab_x+2,           tab_y);
 391     border_points[3] = wxPoint(tab_x+tab_width-2, tab_y);
 392     border_points[4] = wxPoint(tab_x+tab_width,   tab_y+2);
 393     border_points[5] = wxPoint(tab_x+tab_width,   tab_y+tab_height-4);
 394
 395
 396     int drawn_tab_yoff = border_points[1].y;
 397     int drawn_tab_height = border_points[0].y - border_points[1].y;
 398
 399
 400     if (active)
 401     {
 402         // draw active tab
 403
 404         // draw base background color
 405         wxRect r(tab_x, tab_y, tab_width, tab_height);
 406         dc.SetPen(m_base_colour_pen);
 407         dc.SetBrush(m_base_colour_brush);
 408         dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
 409
 410         // this white helps fill out the gradient at the top of the tab
 411         dc.SetPen(*wxWHITE_PEN);
 412         dc.SetBrush(*wxWHITE_BRUSH);
 413         dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
 414
 415         // these two points help the rounded corners appear more antialiased
 416         dc.SetPen(m_base_colour_pen);
 417         dc.DrawPoint(r.x+2, r.y+1);
 418         dc.DrawPoint(r.x+r.width-2, r.y+1);
 419
 420         // set rectangle down a bit for gradient drawing
 421         r.SetHeight(r.GetHeight()/2);
 422         r.x += 2;
 423         r.width -= 2;
 424         r.y += r.height;
 425         r.y -= 2;
 426
 427         // draw gradient background
 428         wxColor top_color = *wxWHITE;
 429         wxColor bottom_color = m_base_colour;
 430         dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
 431     }
 432      else
 433     {
 434         // draw inactive tab
 435
 436         wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
 437
 438         // start the gradent up a bit and leave the inside border inset
 439         // by a pixel for a 3D look.  Only the top half of the inactive
 440         // tab will have a slight gradient
 441         r.x += 3;
 442         r.y++;
 443         r.width -= 4;
 444         r.height /= 2;
 445         r.height--;
 446
 447         // -- draw top gradient fill for glossy look
 448         wxColor top_color = m_base_colour;
 449         wxColor bottom_color = wxAuiStepColour(top_color, 160);
 450         dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
 451
 452         r.y += r.height;
 453         r.y--;
 454
 455         // -- draw bottom fill for glossy look
 456         top_color = m_base_colour;
 457         bottom_color = m_base_colour;
 458         dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
 459     }
 460
 461     // draw tab outline
 462     dc.SetPen(m_border_pen);
 463     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 464     dc.DrawPolygon(WXSIZEOF(border_points), border_points);
 465
 466     // there are two horizontal grey lines at the bottom of the tab control,
 467     // this gets rid of the top one of those lines in the tab control
 468     if (active)
 469     {
 470         wxColor start_color = m_base_colour;
 471         dc.SetPen(m_base_colour_pen);
 472         dc.DrawLine(border_points[0].x+1,
 473                     border_points[0].y,
 474                     border_points[5].x,
 475                     border_points[5].y);
 476     }
 477
 478
 479     int text_offset = tab_x + 8;
 480     int close_button_width = 0;
 481     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
 482     {
 483         close_button_width = m_active_close_bmp.GetWidth();
 484     }
 485
 486
 487     if (bitmap.IsOk())
 488     {
 489         int bitmap_offset = tab_x + 8;
 490
 491         // draw bitmap
 492         dc.DrawBitmap(bitmap,
 493                       bitmap_offset,
 494                       drawn_tab_yoff + (drawn_tab_height/2) - (bitmap.GetHeight()/2),
 495                       true);
 496
 497         text_offset = bitmap_offset + bitmap.GetWidth();
 498         text_offset += 3; // bitmap padding
 499     }
 500      else
 501     {
 502         text_offset = tab_x + 8;
 503     }
 504
 505
 506     wxString draw_text = wxAuiChopText(dc,
 507                           caption,
 508                           tab_width - (text_offset-tab_x) - close_button_width);
 509
 510     // draw tab text
 511     dc.DrawText(draw_text,
 512                 text_offset,
 513                 drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);
 514
 515
 516
 517
 518     // draw close button if necessary
 519     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
 520     {
 521         wxBitmap bmp = m_disabled_close_bmp;
 522
 523         if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
 524             close_button_state == wxAUI_BUTTON_STATE_PRESSED)
 525         {
 526             bmp = m_active_close_bmp;
 527         }
 528
 529         wxRect rect(tab_x + tab_width - close_button_width - 1,
 530                     tab_y + (tab_height/2) - (bmp.GetHeight()/2),
 531                     close_button_width,
 532                     tab_height);
 533         IndentPressedBitmap(&rect, close_button_state);
 534         dc.DrawBitmap(bmp, rect.x, rect.y, true);
 535
 536         *out_button_rect = rect;
 537     }
 538
 539     *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
 540
 541     dc.DestroyClippingRegion();
 542 }
 543
 544 int wxAuiDefaultTabArt::GetIndentSize()
 545 {
 546     return 5;
 547 }
 548
 549 wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
 550                                       wxWindow* WXUNUSED(wnd),
 551                                       const wxString& caption,
 552                                       const wxBitmap& bitmap,
 553                                       bool WXUNUSED(active),
 554                                       int close_button_state,
 555                                       int* x_extent)
 556 {
 557     wxCoord measured_textx, measured_texty, tmp;
 558
 559     dc.SetFont(m_measuring_font);
 560     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
 561
 562     dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);
 563
 564     // add padding around the text
 565     wxCoord tab_width = measured_textx;
 566     wxCoord tab_height = measured_texty;
 567
 568     // if the close button is showing, add space for it
 569     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
 570         tab_width += m_active_close_bmp.GetWidth() + 3;
 571
 572     // if there's a bitmap, add space for it
 573     if (bitmap.IsOk())
 574     {
 575         tab_width += bitmap.GetWidth();
 576         tab_width += 3; // right side bitmap padding
 577         tab_height = wxMax(tab_height, bitmap.GetHeight());
 578     }
 579
 580     // add padding
 581     tab_width += 16;
 582     tab_height += 10;
 583
 584     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
 585     {
 586         tab_width = m_fixed_tab_width;
 587     }
 588
 589     *x_extent = tab_width;
 590
 591     return wxSize(tab_width, tab_height);
 592 }
 593
 594
 595 void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
 596                                     wxWindow* WXUNUSED(wnd),
 597                                     const wxRect& in_rect,
 598                                     int bitmap_id,
 599                                     int button_state,
 600                                     int orientation,
 601                                     const wxBitmap& bitmap_override,
 602                                     wxRect* out_rect)
 603 {
 604     wxBitmap bmp;
 605     wxRect rect;
 606
 607     if (bitmap_override.IsOk())
 608     {
 609         bmp = bitmap_override;
 610     }
 611      else
 612     {
 613         switch (bitmap_id)
 614         {
 615             case wxAUI_BUTTON_CLOSE:
 616                 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
 617                     bmp = m_disabled_close_bmp;
 618                      else
 619                     bmp = m_active_close_bmp;
 620                 break;
 621             case wxAUI_BUTTON_LEFT:
 622                 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
 623                     bmp = m_disabled_left_bmp;
 624                      else
 625                     bmp = m_active_left_bmp;
 626                 break;
 627             case wxAUI_BUTTON_RIGHT:
 628                 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
 629                     bmp = m_disabled_right_bmp;
 630                      else
 631                     bmp = m_active_right_bmp;
 632                 break;
 633             case wxAUI_BUTTON_WINDOWLIST:
 634                 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
 635                     bmp = m_disabled_windowlist_bmp;
 636                      else
 637                     bmp = m_active_windowlist_bmp;
 638                 break;
 639         }
 640     }
 641
 642     if (!bmp.IsOk())
 643         return;
 644
 645     rect = in_rect;
 646
 647     if (orientation == wxLEFT)
 648     {
 649         rect.SetX(in_rect.x);
 650         rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
 651         rect.SetWidth(bmp.GetWidth());
 652         rect.SetHeight(bmp.GetHeight());
 653     }
 654      else
 655     {
 656         rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
 657                       ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
 658                       bmp.GetWidth(), bmp.GetHeight());
 659     }
 660
 661     IndentPressedBitmap(&rect, button_state);
 662     dc.DrawBitmap(bmp, rect.x, rect.y, true);
 663
 664     *out_rect = rect;
 665 }
 666
 667
 668 int wxAuiDefaultTabArt::ShowWindowList(wxWindow* wnd,
 669                                        const wxArrayString& items,
 670                                        int active_idx)
 671 {
 672         wxMenu menuPopup;
 673
 674     size_t i, count = items.GetCount();
 675     for (i = 0; i < count; ++i)
 676     {
 677         menuPopup.AppendCheckItem(1000+i, items.Item(i));
 678     }
 679
 680     if (active_idx != -1)
 681     {
 682         menuPopup.Check(1000+active_idx, true);
 683     }
 684
 685     // find out where to put the popup menu of window items
 686     wxPoint pt = ::wxGetMousePosition();
 687     pt = wnd->ScreenToClient(pt);
 688
 689     // find out the screen coordinate at the bottom of the tab ctrl
 690     wxRect cli_rect = wnd->GetClientRect();
 691     pt.y = cli_rect.y + cli_rect.height;
 692
 693     wxAuiCommandCapture* cc = new wxAuiCommandCapture;
 694     wnd->PushEventHandler(cc);
 695     wnd->PopupMenu(&menuPopup, pt);
 696     int command = cc->GetCommandId();
 697     wnd->PopEventHandler(true);
 698
 699     if (command >= 1000)
 700         return command-1000;
 701
 702     return -1;
 703 }
 704
 705 int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
 706                                            wxAuiNotebookPageArray& pages,
 707                                            const wxSize& required_bmp_size)
 708 {
 709     wxClientDC dc(wnd);
 710     dc.SetFont(m_measuring_font);
 711
 712     // sometimes a standard bitmap size needs to be enforced, especially
 713     // if some tabs have bitmaps and others don't.  This is important because
 714     // it prevents the tab control from resizing when tabs are added.
 715     wxBitmap measure_bmp;
 716     if (required_bmp_size.IsFullySpecified())
 717     {
 718         measure_bmp.Create(required_bmp_size.x,
 719                            required_bmp_size.y);
 720     }
 721
 722
 723     int max_y = 0;
 724     size_t i, page_count = pages.GetCount();
 725     for (i = 0; i < page_count; ++i)
 726     {
 727         wxAuiNotebookPage& page = pages.Item(i);
 728
 729         wxBitmap bmp;
 730         if (measure_bmp.IsOk())
 731             bmp = measure_bmp;
 732              else
 733             bmp = page.bitmap;
 734
 735         // we don't use the caption text because we don't
 736         // want tab heights to be different in the case
 737         // of a very short piece of text on one tab and a very
 738         // tall piece of text on another tab
 739         int x_ext = 0;
 740         wxSize s = GetTabSize(dc,
 741                               wnd,
 742                               wxT("ABCDEFGHIj"),
 743                               bmp,
 744                               true,
 745                               wxAUI_BUTTON_STATE_HIDDEN,
 746                               &x_ext);
 747
 748         max_y = wxMax(max_y, s.y);
 749     }
 750
 751     return max_y+2;
 752 }
 753
 754 void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
 755 {
 756     m_normal_font = font;
 757 }
 758
 759 void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font)
 760 {
 761     m_selected_font = font;
 762 }
 763
 764 void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
 765 {
 766     m_measuring_font = font;
 767 }
 768
 769
 770 // -- wxAuiSimpleTabArt class implementation --
 771
 772 wxAuiSimpleTabArt::wxAuiSimpleTabArt()
 773 {
 774     m_normal_font = *wxNORMAL_FONT;
 775     m_selected_font = *wxNORMAL_FONT;
 776     m_selected_font.SetWeight(wxBOLD);
 777     m_measuring_font = m_selected_font;
 778
 779     m_flags = 0;
 780     m_fixed_tab_width = 100;
 781
 782     wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 783
 784     wxColour background_colour = base_colour;
 785     wxColour normaltab_colour = base_colour;
 786     wxColour selectedtab_colour = *wxWHITE;
 787
 788     m_bkbrush = wxBrush(background_colour);
 789     m_normal_bkbrush = wxBrush(normaltab_colour);
 790     m_normal_bkpen = wxPen(normaltab_colour);
 791     m_selected_bkbrush = wxBrush(selectedtab_colour);
 792     m_selected_bkpen = wxPen(selectedtab_colour);
 793
 794     m_active_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
 795     m_disabled_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
 796
 797     m_active_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
 798     m_disabled_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
 799
 800     m_active_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
 801     m_disabled_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
 802
 803     m_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
 804     m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
 805
 806 }
 807
 808 wxAuiSimpleTabArt::~wxAuiSimpleTabArt()
 809 {
 810 }
 811
 812 wxAuiTabArt* wxAuiSimpleTabArt::Clone()
 813 {
 814     return static_cast<wxAuiTabArt*>(new wxAuiSimpleTabArt);
 815 }
 816
 817
 818 void wxAuiSimpleTabArt::SetFlags(unsigned int flags)
 819 {
 820     m_flags = flags;
 821 }
 822
 823 void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
 824                                       size_t tab_count)
 825 {
 826     m_fixed_tab_width = 100;
 827
 828     int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
 829
 830     if (m_flags & wxAUI_NB_CLOSE_BUTTON)
 831         tot_width -= m_active_close_bmp.GetWidth();
 832     if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
 833         tot_width -= m_active_windowlist_bmp.GetWidth();
 834
 835     if (tab_count > 0)
 836     {
 837         m_fixed_tab_width = tot_width/(int)tab_count;
 838     }
 839
 840
 841     if (m_fixed_tab_width < 100)
 842         m_fixed_tab_width = 100;
 843
 844     if (m_fixed_tab_width > tot_width/2)
 845         m_fixed_tab_width = tot_width/2;
 846
 847     if (m_fixed_tab_width > 220)
 848         m_fixed_tab_width = 220;
 849 }
 850
 851 void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,
 852                                        wxWindow* WXUNUSED(wnd),
 853                                        const wxRect& rect)
 854 {
 855     // draw background
 856     dc.SetBrush(m_bkbrush);
 857     dc.SetPen(*wxTRANSPARENT_PEN);
 858     dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
 859
 860     // draw base line
 861     dc.SetPen(*wxGREY_PEN);
 862     dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
 863 }
 864
 865
 866 // DrawTab() draws an individual tab.
 867 //
 868 // dc       - output dc
 869 // in_rect  - rectangle the tab should be confined to
 870 // caption  - tab's caption
 871 // active   - whether or not the tab is active
 872 // out_rect - actual output rectangle
 873 // x_extent - the advance x; where the next tab should start
 874
 875 void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
 876                                 wxWindow* wnd,
 877                                 const wxRect& in_rect,
 878                                 const wxString& caption_text,
 879                                 const wxBitmap& bitmap,
 880                                 bool active,
 881                                 int close_button_state,
 882                                 wxRect* out_tab_rect,
 883                                 wxRect* out_button_rect,
 884                                 int* x_extent)
 885 {
 886     wxCoord normal_textx, normal_texty;
 887     wxCoord selected_textx, selected_texty;
 888     wxCoord textx, texty;
 889
 890     // if the caption is empty, measure some temporary text
 891     wxString caption = caption_text;
 892     if (caption_text.empty())
 893         caption = wxT("Xj");
 894
 895     dc.SetFont(m_selected_font);
 896     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
 897
 898     dc.SetFont(m_normal_font);
 899     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
 900
 901     // figure out the size of the tab
 902     wxSize tab_size = GetTabSize(dc,
 903                                  wnd,
 904                                  caption,
 905                                  bitmap,
 906                                  active,
 907                                  close_button_state,
 908                                  x_extent);
 909
 910     wxCoord tab_height = tab_size.y;
 911     wxCoord tab_width = tab_size.x;
 912     wxCoord tab_x = in_rect.x;
 913     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
 914
 915     caption = caption_text;
 916
 917     // select pen, brush and font for the tab to be drawn
 918
 919     if (active)
 920     {
 921         dc.SetPen(m_selected_bkpen);
 922         dc.SetBrush(m_selected_bkbrush);
 923         dc.SetFont(m_selected_font);
 924         textx = selected_textx;
 925         texty = selected_texty;
 926     }
 927      else
 928     {
 929         dc.SetPen(m_normal_bkpen);
 930         dc.SetBrush(m_normal_bkbrush);
 931         dc.SetFont(m_normal_font);
 932         textx = normal_textx;
 933         texty = normal_texty;
 934     }
 935
 936
 937     // -- draw line --
 938
 939     wxPoint points[7];
 940     points[0].x = tab_x;
 941     points[0].y = tab_y + tab_height - 1;
 942     points[1].x = tab_x + tab_height - 3;
 943     points[1].y = tab_y + 2;
 944     points[2].x = tab_x + tab_height + 3;
 945     points[2].y = tab_y;
 946     points[3].x = tab_x + tab_width - 2;
 947     points[3].y = tab_y;
 948     points[4].x = tab_x + tab_width;
 949     points[4].y = tab_y + 2;
 950     points[5].x = tab_x + tab_width;
 951     points[5].y = tab_y + tab_height - 1;
 952     points[6] = points[0];
 953
 954     dc.SetClippingRegion(in_rect);
 955
 956     dc.DrawPolygon(WXSIZEOF(points) - 1, points);
 957
 958     dc.SetPen(*wxGREY_PEN);
 959
 960     //dc.DrawLines(active ? WXSIZEOF(points) - 1 : WXSIZEOF(points), points);
 961     dc.DrawLines(WXSIZEOF(points), points);
 962
 963
 964     int text_offset;
 965
 966     int close_button_width = 0;
 967     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
 968     {
 969         close_button_width = m_active_close_bmp.GetWidth();
 970         text_offset = tab_x + (tab_height/2) + ((tab_width-close_button_width)/2) - (textx/2);
 971     }
 972      else
 973     {
 974         text_offset = tab_x + (tab_height/3) + (tab_width/2) - (textx/2);
 975     }
 976
 977     // set minimum text offset
 978     if (text_offset < tab_x + tab_height)
 979         text_offset = tab_x + tab_height;
 980
 981     // chop text if necessary
 982     wxString draw_text = wxAuiChopText(dc,
 983                           caption,
 984                           tab_width - (text_offset-tab_x) - close_button_width);
 985
 986     // draw tab text
 987     dc.DrawText(draw_text,
 988                  text_offset,
 989                  (tab_y + tab_height)/2 - (texty/2) + 1);
 990
 991
 992     // draw close button if necessary
 993     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
 994     {
 995         wxBitmap bmp;
 996         if (active)
 997             bmp = m_active_close_bmp;
 998              else
 999             bmp = m_disabled_close_bmp;
1000
1001         wxRect rect(tab_x + tab_width - close_button_width - 1,
1002                     tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
1003                     close_button_width,
1004                     tab_height - 1);
1005         DrawButtons(dc, rect, bmp, *wxWHITE, close_button_state);
1006
1007         *out_button_rect = rect;
1008     }
1009
1010
1011     *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
1012
1013     dc.DestroyClippingRegion();
1014 }
1015
1016 int wxAuiSimpleTabArt::GetIndentSize()
1017 {
1018     return 0;
1019 }
1020
1021 wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
1022                                      wxWindow* WXUNUSED(wnd),
1023                                      const wxString& caption,
1024                                      const wxBitmap& WXUNUSED(bitmap),
1025                                      bool WXUNUSED(active),
1026                                      int close_button_state,
1027                                      int* x_extent)
1028 {
1029     wxCoord measured_textx, measured_texty;
1030
1031     dc.SetFont(m_measuring_font);
1032     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
1033
1034     wxCoord tab_height = measured_texty + 4;
1035     wxCoord tab_width = measured_textx + tab_height + 5;
1036
1037     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1038         tab_width += m_active_close_bmp.GetWidth();
1039
1040     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
1041     {
1042         tab_width = m_fixed_tab_width;
1043     }
1044
1045     *x_extent = tab_width - (tab_height/2) - 1;
1046
1047     return wxSize(tab_width, tab_height);
1048 }
1049
1050
1051 void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
1052                                    wxWindow* WXUNUSED(wnd),
1053                                    const wxRect& in_rect,
1054                                    int bitmap_id,
1055                                    int button_state,
1056                                    int orientation,
1057                                    const wxBitmap& bitmap_override,
1058                                    wxRect* out_rect)
1059 {
1060     wxBitmap bmp;
1061     wxRect rect;
1062
1063     if (bitmap_override.IsOk())
1064     {
1065         bmp = bitmap_override;
1066     }
1067      else
1068     {
1069         switch (bitmap_id)
1070         {
1071             case wxAUI_BUTTON_CLOSE:
1072                 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1073                     bmp = m_disabled_close_bmp;
1074                      else
1075                     bmp = m_active_close_bmp;
1076                 break;
1077             case wxAUI_BUTTON_LEFT:
1078                 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1079                     bmp = m_disabled_left_bmp;
1080                      else
1081                     bmp = m_active_left_bmp;
1082                 break;
1083             case wxAUI_BUTTON_RIGHT:
1084                 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1085                     bmp = m_disabled_right_bmp;
1086                      else
1087                     bmp = m_active_right_bmp;
1088                 break;
1089             case wxAUI_BUTTON_WINDOWLIST:
1090                 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1091                     bmp = m_disabled_windowlist_bmp;
1092                      else
1093                     bmp = m_active_windowlist_bmp;
1094                 break;
1095         }
1096     }
1097
1098     if (!bmp.IsOk())
1099         return;
1100
1101     rect = in_rect;
1102
1103     if (orientation == wxLEFT)
1104     {
1105         rect.SetX(in_rect.x);
1106         rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
1107         rect.SetWidth(bmp.GetWidth());
1108         rect.SetHeight(bmp.GetHeight());
1109     }
1110      else
1111     {
1112         rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
1113                       ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
1114                       bmp.GetWidth(), bmp.GetHeight());
1115     }
1116
1117
1118     DrawButtons(dc, rect, bmp, *wxWHITE, button_state);
1119
1120     *out_rect = rect;
1121 }
1122
1123
1124 int wxAuiSimpleTabArt::ShowWindowList(wxWindow* wnd,
1125                                       const wxArrayString& items,
1126                                       int active_idx)
1127 {
1128         wxMenu menuPopup;
1129
1130     size_t i, count = items.GetCount();
1131     for (i = 0; i < count; ++i)
1132     {
1133         menuPopup.AppendCheckItem(1000+i, items.Item(i));
1134     }
1135
1136     if (active_idx != -1)
1137     {
1138         menuPopup.Check(1000+active_idx, true);
1139     }
1140
1141     // find out where to put the popup menu of window
1142     // items.  Subtract 100 for now to center the menu
1143     // a bit, until a better mechanism can be implemented
1144     wxPoint pt = ::wxGetMousePosition();
1145     pt = wnd->ScreenToClient(pt);
1146     if (pt.x < 100)
1147         pt.x = 0;
1148          else
1149         pt.x -= 100;
1150
1151     // find out the screen coordinate at the bottom of the tab ctrl
1152     wxRect cli_rect = wnd->GetClientRect();
1153     pt.y = cli_rect.y + cli_rect.height;
1154
1155     wxAuiCommandCapture* cc = new wxAuiCommandCapture;
1156     wnd->PushEventHandler(cc);
1157     wnd->PopupMenu(&menuPopup, pt);
1158     int command = cc->GetCommandId();
1159     wnd->PopEventHandler(true);
1160
1161     if (command >= 1000)
1162         return command-1000;
1163
1164     return -1;
1165 }
1166
1167 int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
1168                                           wxAuiNotebookPageArray& WXUNUSED(pages),
1169                                           const wxSize& WXUNUSED(required_bmp_size))
1170 {
1171     wxClientDC dc(wnd);
1172     dc.SetFont(m_measuring_font);
1173     int x_ext = 0;
1174     wxSize s = GetTabSize(dc,
1175                           wnd,
1176                           wxT("ABCDEFGHIj"),
1177                           wxNullBitmap,
1178                           true,
1179                           wxAUI_BUTTON_STATE_HIDDEN,
1180                           &x_ext);
1181     return s.y+3;
1182 }
1183
1184 void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
1185 {
1186     m_normal_font = font;
1187 }
1188
1189 void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
1190 {
1191     m_selected_font = font;
1192 }
1193
1194 void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
1195 {
1196     m_measuring_font = font;
1197 }
1198
1199
1200
1201
1202 // -- wxAuiTabContainer class implementation --
1203
1204
1205 // wxAuiTabContainer is a class which contains information about each
1206 // tab.  It also can render an entire tab control to a specified DC.
1207 // It's not a window class itself, because this code will be used by
1208 // the wxFrameMananger, where it is disadvantageous to have separate
1209 // windows for each tab control in the case of "docked tabs"
1210
1211 // A derived class, wxAuiTabCtrl, is an actual wxWindow-derived window
1212 // which can be used as a tab control in the normal sense.
1213
1214
1215 wxAuiTabContainer::wxAuiTabContainer()
1216 {
1217     m_tab_offset = 0;
1218     m_flags = 0;
1219     m_art = new wxAuiDefaultTabArt;
1220
1221     AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
1222     AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
1223     AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
1224     AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
1225 }
1226
1227 wxAuiTabContainer::~wxAuiTabContainer()
1228 {
1229     delete m_art;
1230 }
1231
1232 void wxAuiTabContainer::SetArtProvider(wxAuiTabArt* art)
1233 {
1234     delete m_art;
1235     m_art = art;
1236
1237     if (m_art)
1238     {
1239         m_art->SetFlags(m_flags);
1240     }
1241 }
1242
1243 wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const
1244 {
1245     return m_art;
1246 }
1247
1248 void wxAuiTabContainer::SetFlags(unsigned int flags)
1249 {
1250     m_flags = flags;
1251
1252     // check for new close button settings
1253     RemoveButton(wxAUI_BUTTON_LEFT);
1254     RemoveButton(wxAUI_BUTTON_RIGHT);
1255     RemoveButton(wxAUI_BUTTON_WINDOWLIST);
1256     RemoveButton(wxAUI_BUTTON_CLOSE);
1257
1258
1259     if (flags & wxAUI_NB_SCROLL_BUTTONS)
1260     {
1261         AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
1262         AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
1263     }
1264
1265     if (flags & wxAUI_NB_WINDOWLIST_BUTTON)
1266     {
1267         AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
1268     }
1269
1270     if (flags & wxAUI_NB_CLOSE_BUTTON)
1271     {
1272         AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
1273     }
1274
1275     if (m_art)
1276     {
1277         m_art->SetFlags(m_flags);
1278     }
1279 }
1280
1281 unsigned int wxAuiTabContainer::GetFlags() const
1282 {
1283     return m_flags;
1284 }
1285
1286
1287 void wxAuiTabContainer::SetNormalFont(const wxFont& font)
1288 {
1289     m_art->SetNormalFont(font);
1290 }
1291
1292 void wxAuiTabContainer::SetSelectedFont(const wxFont& font)
1293 {
1294     m_art->SetSelectedFont(font);
1295 }
1296
1297 void wxAuiTabContainer::SetMeasuringFont(const wxFont& font)
1298 {
1299     m_art->SetMeasuringFont(font);
1300 }
1301
1302 void wxAuiTabContainer::SetRect(const wxRect& rect)
1303 {
1304     m_rect = rect;
1305
1306     if (m_art)
1307     {
1308         m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());
1309     }
1310 }
1311
1312 bool wxAuiTabContainer::AddPage(wxWindow* page,
1313                                 const wxAuiNotebookPage& info)
1314 {
1315     wxAuiNotebookPage page_info;
1316     page_info = info;
1317     page_info.window = page;
1318
1319     m_pages.Add(page_info);
1320
1321     // let the art provider know how many pages we have
1322     if (m_art)
1323     {
1324         m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1325     }
1326
1327     return true;
1328 }
1329
1330 bool wxAuiTabContainer::InsertPage(wxWindow* page,
1331                                    const wxAuiNotebookPage& info,
1332                                    size_t idx)
1333 {
1334     wxAuiNotebookPage page_info;
1335     page_info = info;
1336     page_info.window = page;
1337
1338     if (idx >= m_pages.GetCount())
1339         m_pages.Add(page_info);
1340          else
1341         m_pages.Insert(page_info, idx);
1342
1343     // let the art provider know how many pages we have
1344     if (m_art)
1345     {
1346         m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1347     }
1348
1349     return true;
1350 }
1351
1352 bool wxAuiTabContainer::MovePage(wxWindow* page,
1353                                  size_t new_idx)
1354 {
1355     int idx = GetIdxFromWindow(page);
1356     if (idx == -1)
1357         return false;
1358
1359     // get page entry, make a copy of it
1360     wxAuiNotebookPage p = GetPage(idx);
1361
1362     // remove old page entry
1363     RemovePage(page);
1364
1365     // insert page where it should be
1366     InsertPage(page, p, new_idx);
1367
1368     return true;
1369 }
1370
1371 bool wxAuiTabContainer::RemovePage(wxWindow* wnd)
1372 {
1373     size_t i, page_count = m_pages.GetCount();
1374     for (i = 0; i < page_count; ++i)
1375     {
1376         wxAuiNotebookPage& page = m_pages.Item(i);
1377         if (page.window == wnd)
1378         {
1379             m_pages.RemoveAt(i);
1380
1381             // let the art provider know how many pages we have
1382             if (m_art)
1383             {
1384                 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1385             }
1386
1387             return true;
1388         }
1389     }
1390
1391     return false;
1392 }
1393
1394 bool wxAuiTabContainer::SetActivePage(wxWindow* wnd)
1395 {
1396     bool found = false;
1397
1398     size_t i, page_count = m_pages.GetCount();
1399     for (i = 0; i < page_count; ++i)
1400     {
1401         wxAuiNotebookPage& page = m_pages.Item(i);
1402         if (page.window == wnd)
1403         {
1404             page.active = true;
1405             found = true;
1406         }
1407          else
1408         {
1409             page.active = false;
1410         }
1411     }
1412
1413     return found;
1414 }
1415
1416 void wxAuiTabContainer::SetNoneActive()
1417 {
1418     size_t i, page_count = m_pages.GetCount();
1419     for (i = 0; i < page_count; ++i)
1420     {
1421         wxAuiNotebookPage& page = m_pages.Item(i);
1422         page.active = false;
1423     }
1424 }
1425
1426 bool wxAuiTabContainer::SetActivePage(size_t page)
1427 {
1428     if (page >= m_pages.GetCount())
1429         return false;
1430
1431     return SetActivePage(m_pages.Item(page).window);
1432 }
1433
1434 int wxAuiTabContainer::GetActivePage() const
1435 {
1436     size_t i, page_count = m_pages.GetCount();
1437     for (i = 0; i < page_count; ++i)
1438     {
1439         wxAuiNotebookPage& page = m_pages.Item(i);
1440         if (page.active)
1441             return i;
1442     }
1443
1444     return -1;
1445 }
1446
1447 wxWindow* wxAuiTabContainer::GetWindowFromIdx(size_t idx) const
1448 {
1449     if (idx >= m_pages.GetCount())
1450         return NULL;
1451
1452     return m_pages[idx].window;
1453 }
1454
1455 int wxAuiTabContainer::GetIdxFromWindow(wxWindow* wnd) const
1456 {
1457     size_t i, page_count = m_pages.GetCount();
1458     for (i = 0; i < page_count; ++i)
1459     {
1460         wxAuiNotebookPage& page = m_pages.Item(i);
1461         if (page.window == wnd)
1462             return i;
1463     }
1464     return -1;
1465 }
1466
1467 wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx)
1468 {
1469     wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
1470
1471     return m_pages[idx];
1472 }
1473
1474 wxAuiNotebookPageArray& wxAuiTabContainer::GetPages()
1475 {
1476     return m_pages;
1477 }
1478
1479 size_t wxAuiTabContainer::GetPageCount() const
1480 {
1481     return m_pages.GetCount();
1482 }
1483
1484 void wxAuiTabContainer::AddButton(int id,
1485                                   int location,
1486                                   const wxBitmap& normal_bitmap,
1487                                   const wxBitmap& disabled_bitmap)
1488 {
1489     wxAuiTabContainerButton button;
1490     button.id = id;
1491     button.bitmap = normal_bitmap;
1492     button.dis_bitmap = disabled_bitmap;
1493     button.location = location;
1494     button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
1495
1496     m_buttons.Add(button);
1497 }
1498
1499 void wxAuiTabContainer::RemoveButton(int id)
1500 {
1501     size_t i, button_count = m_buttons.GetCount();
1502
1503     for (i = 0; i < button_count; ++i)
1504     {
1505         if (m_buttons.Item(i).id == id)
1506         {
1507             m_buttons.RemoveAt(i);
1508             return;
1509         }
1510     }
1511 }
1512
1513
1514
1515 size_t wxAuiTabContainer::GetTabOffset() const
1516 {
1517     return m_tab_offset;
1518 }
1519
1520 void wxAuiTabContainer::SetTabOffset(size_t offset)
1521 {
1522     m_tab_offset = offset;
1523 }
1524
1525
1526
1527
1528 // Render() renders the tab catalog to the specified DC
1529 // It is a virtual function and can be overridden to
1530 // provide custom drawing capabilities
1531 void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
1532 {
1533     if (!raw_dc || !raw_dc->IsOk())
1534         return;
1535
1536     wxMemoryDC dc;
1537     wxBitmap bmp;
1538     size_t i;
1539     size_t page_count = m_pages.GetCount();
1540     size_t button_count = m_buttons.GetCount();
1541
1542     // create off-screen bitmap
1543     bmp.Create(m_rect.GetWidth(), m_rect.GetHeight());
1544     dc.SelectObject(bmp);
1545
1546     if (!dc.IsOk())
1547         return;
1548
1549     // find out if size of tabs is larger than can be
1550     // afforded on screen
1551     int total_width = 0;
1552     int visible_width = 0;
1553     for (i = 0; i < page_count; ++i)
1554     {
1555         wxAuiNotebookPage& page = m_pages.Item(i);
1556
1557         // determine if a close button is on this tab
1558         bool close_button = false;
1559         if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1560             ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1561         {
1562             close_button = true;
1563         }
1564
1565
1566         int x_extent = 0;
1567         wxSize size = m_art->GetTabSize(dc,
1568                             wnd,
1569                             page.caption,
1570                             page.bitmap,
1571                             page.active,
1572                             close_button ?
1573                               wxAUI_BUTTON_STATE_NORMAL :
1574                               wxAUI_BUTTON_STATE_HIDDEN,
1575                             &x_extent);
1576
1577         if (i+1 < page_count)
1578             total_width += x_extent;
1579              else
1580             total_width += size.x;
1581
1582         if (i >= m_tab_offset)
1583         {
1584             if (i+1 < page_count)
1585                 visible_width += x_extent;
1586                  else
1587                 visible_width += size.x;
1588         }
1589     }
1590
1591     if (total_width > m_rect.GetWidth() || m_tab_offset != 0)
1592     {
1593         // show left/right buttons
1594         for (i = 0; i < button_count; ++i)
1595         {
1596             wxAuiTabContainerButton& button = m_buttons.Item(i);
1597             if (button.id == wxAUI_BUTTON_LEFT ||
1598                 button.id == wxAUI_BUTTON_RIGHT)
1599             {
1600                 button.cur_state &= ~wxAUI_BUTTON_STATE_HIDDEN;
1601             }
1602         }
1603     }
1604      else
1605     {
1606         // hide left/right buttons
1607         for (i = 0; i < button_count; ++i)
1608         {
1609             wxAuiTabContainerButton& button = m_buttons.Item(i);
1610             if (button.id == wxAUI_BUTTON_LEFT ||
1611                 button.id == wxAUI_BUTTON_RIGHT)
1612             {
1613                 button.cur_state |= wxAUI_BUTTON_STATE_HIDDEN;
1614             }
1615         }
1616     }
1617
1618     // determine whether left button should be enabled
1619     for (i = 0; i < button_count; ++i)
1620     {
1621         wxAuiTabContainerButton& button = m_buttons.Item(i);
1622         if (button.id == wxAUI_BUTTON_LEFT)
1623         {
1624             if (m_tab_offset == 0)
1625                 button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
1626                  else
1627                 button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
1628         }
1629         if (button.id == wxAUI_BUTTON_RIGHT)
1630         {
1631             if (visible_width < m_rect.GetWidth() - ((int)button_count*16))
1632                 button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
1633                  else
1634                 button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
1635         }
1636     }
1637
1638
1639
1640     // draw background
1641     m_art->DrawBackground(dc, wnd, m_rect);
1642
1643     // draw buttons
1644     int left_buttons_width = 0;
1645     int right_buttons_width = 0;
1646
1647     int offset = 0;
1648
1649     // draw the buttons on the right side
1650     offset = m_rect.x + m_rect.width;
1651     for (i = 0; i < button_count; ++i)
1652     {
1653         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1654
1655         if (button.location != wxRIGHT)
1656             continue;
1657         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1658             continue;
1659
1660         wxRect button_rect = m_rect;
1661         button_rect.SetY(1);
1662         button_rect.SetWidth(offset);
1663
1664         m_art->DrawButton(dc,
1665                           wnd,
1666                           button_rect,
1667                           button.id,
1668                           button.cur_state,
1669                           wxRIGHT,
1670                           wxNullBitmap,
1671                           &button.rect);
1672
1673         offset -= button.rect.GetWidth();
1674         right_buttons_width += button.rect.GetWidth();
1675     }
1676
1677
1678
1679     offset = 0;
1680
1681     // draw the buttons on the left side
1682
1683     for (i = 0; i < button_count; ++i)
1684     {
1685         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1686
1687         if (button.location != wxLEFT)
1688             continue;
1689         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1690             continue;
1691
1692         wxRect button_rect(offset, 1, 1000, m_rect.height);
1693
1694         m_art->DrawButton(dc,
1695                           wnd,
1696                           button_rect,
1697                           button.id,
1698                           button.cur_state,
1699                           wxLEFT,
1700                           wxNullBitmap,
1701                           &button.rect);
1702
1703         offset += button.rect.GetWidth();
1704         left_buttons_width += button.rect.GetWidth();
1705     }
1706
1707     offset = left_buttons_width;
1708
1709     if (offset == 0)
1710         offset += m_art->GetIndentSize();
1711
1712
1713     // prepare the tab-close-button array
1714     // make sure tab button entries which aren't used are marked as hidden
1715     for (i = page_count; i < m_tab_close_buttons.GetCount(); ++i)
1716         m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1717
1718     // make sure there are enough tab button entries to accommodate all tabs
1719     while (m_tab_close_buttons.GetCount() < page_count)
1720     {
1721         wxAuiTabContainerButton tempbtn;
1722         tempbtn.id = wxAUI_BUTTON_CLOSE;
1723         tempbtn.location = wxCENTER;
1724         tempbtn.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1725         m_tab_close_buttons.Add(tempbtn);
1726     }
1727
1728
1729     // buttons before the tab offset must be set to hidden
1730     for (i = 0; i < m_tab_offset; ++i)
1731     {
1732         m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1733     }
1734
1735
1736     // draw the tabs
1737
1738     size_t active = 999;
1739     int active_offset = 0;
1740     wxRect active_rect;
1741
1742     int x_extent = 0;
1743     wxRect rect = m_rect;
1744     rect.y = 0;
1745     rect.height = m_rect.height;
1746
1747     for (i = m_tab_offset; i < page_count; ++i)
1748     {
1749         wxAuiNotebookPage& page = m_pages.Item(i);
1750         wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
1751
1752         // determine if a close button is on this tab
1753         bool close_button = false;
1754         if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1755             ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1756         {
1757             close_button = true;
1758             if (tab_button.cur_state == wxAUI_BUTTON_STATE_HIDDEN)
1759             {
1760                 tab_button.id = wxAUI_BUTTON_CLOSE;
1761                 tab_button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
1762                 tab_button.location = wxCENTER;
1763             }
1764         }
1765          else
1766         {
1767             tab_button.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1768         }
1769
1770         rect.x = offset;
1771         rect.width = m_rect.width - right_buttons_width - offset - 2;
1772
1773         if (rect.width <= 0)
1774             break;
1775
1776         m_art->DrawTab(dc,
1777                        wnd,
1778                        rect,
1779                        page.caption,
1780                        page.bitmap,
1781                        page.active,
1782                        tab_button.cur_state,
1783                        &page.rect,
1784                        &tab_button.rect,
1785                        &x_extent);
1786
1787         if (page.active)
1788         {
1789             active = i;
1790             active_offset = offset;
1791             active_rect = rect;
1792         }
1793
1794         offset += x_extent;
1795     }
1796
1797
1798     // make sure to deactivate buttons which are off the screen to the right
1799     for (++i; i < m_tab_close_buttons.GetCount(); ++i)
1800     {
1801         m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1802     }
1803
1804
1805     // draw the active tab again so it stands in the foreground
1806     if (active >= m_tab_offset && active < m_pages.GetCount())
1807     {
1808         wxAuiNotebookPage& page = m_pages.Item(active);
1809
1810         wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(active);
1811
1812         // determine if a close button is on this tab
1813         bool close_button = false;
1814         if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1815             ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1816         {
1817             close_button = true;
1818         }
1819
1820         rect.x = active_offset;
1821         m_art->DrawTab(dc,
1822                        wnd,
1823                        active_rect,
1824                        page.caption,
1825                        page.bitmap,
1826                        page.active,
1827                        tab_button.cur_state,
1828                        &page.rect,
1829                        &tab_button.rect,
1830                        &x_extent);
1831     }
1832
1833
1834     raw_dc->Blit(m_rect.x, m_rect.y,
1835                  m_rect.GetWidth(), m_rect.GetHeight(),
1836                  &dc, 0, 0);
1837 }
1838
1839
1840 // TabHitTest() tests if a tab was hit, passing the window pointer
1841 // back if that condition was fulfilled.  The function returns
1842 // true if a tab was hit, otherwise false
1843 bool wxAuiTabContainer::TabHitTest(int x, int y, wxWindow** hit) const
1844 {
1845     if (!m_rect.Contains(x,y))
1846         return false;
1847
1848     wxAuiTabContainerButton* btn = NULL;
1849     if (ButtonHitTest(x, y, &btn))
1850     {
1851         if (m_buttons.Index(*btn) != wxNOT_FOUND)
1852             return false;
1853     }
1854
1855     size_t i, page_count = m_pages.GetCount();
1856
1857     for (i = m_tab_offset; i < page_count; ++i)
1858     {
1859         wxAuiNotebookPage& page = m_pages.Item(i);
1860         if (page.rect.Contains(x,y))
1861         {
1862             if (hit)
1863                 *hit = page.window;
1864             return true;
1865         }
1866     }
1867
1868     return false;
1869 }
1870
1871 // ButtonHitTest() tests if a button was hit. The function returns
1872 // true if a button was hit, otherwise false
1873 bool wxAuiTabContainer::ButtonHitTest(int x, int y,
1874                                       wxAuiTabContainerButton** hit) const
1875 {
1876     if (!m_rect.Contains(x,y))
1877         return false;
1878
1879     size_t i, button_count;
1880
1881
1882     button_count = m_buttons.GetCount();
1883     for (i = 0; i < button_count; ++i)
1884     {
1885         wxAuiTabContainerButton& button = m_buttons.Item(i);
1886         if (button.rect.Contains(x,y) &&
1887             !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
1888                                    wxAUI_BUTTON_STATE_DISABLED)))
1889         {
1890             if (hit)
1891                 *hit = &button;
1892             return true;
1893         }
1894     }
1895
1896     button_count = m_tab_close_buttons.GetCount();
1897     for (i = 0; i < button_count; ++i)
1898     {
1899         wxAuiTabContainerButton& button = m_tab_close_buttons.Item(i);
1900         if (button.rect.Contains(x,y) &&
1901             !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
1902                                    wxAUI_BUTTON_STATE_DISABLED)))
1903         {
1904             if (hit)
1905                 *hit = &button;
1906             return true;
1907         }
1908     }
1909
1910     return false;
1911 }
1912
1913
1914
1915 // the utility function ShowWnd() is the same as show,
1916 // except it handles wxAuiMDIChildFrame windows as well,
1917 // as the Show() method on this class is "unplugged"
1918 static void ShowWnd(wxWindow* wnd, bool show)
1919 {
1920     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
1921     {
1922         wxAuiMDIChildFrame* cf = (wxAuiMDIChildFrame*)wnd;
1923         cf->DoShow(show);
1924     }
1925      else
1926     {
1927         wnd->Show(show);
1928     }
1929 }
1930
1931
1932 // DoShowHide() this function shows the active window, then
1933 // hides all of the other windows (in that order)
1934 void wxAuiTabContainer::DoShowHide()
1935 {
1936     wxAuiNotebookPageArray& pages = GetPages();
1937     size_t i, page_count = pages.GetCount();
1938
1939     // show new active page first
1940     for (i = 0; i < page_count; ++i)
1941     {
1942         wxAuiNotebookPage& page = pages.Item(i);
1943         if (page.active)
1944         {
1945             ShowWnd(page.window, true);
1946             break;
1947         }
1948     }
1949
1950     // hide all other pages
1951     for (i = 0; i < page_count; ++i)
1952     {
1953         wxAuiNotebookPage& page = pages.Item(i);
1954         ShowWnd(page.window, page.active);
1955     }
1956 }
1957
1958
1959
1960
1961
1962
1963 // -- wxAuiTabCtrl class implementation --
1964
1965
1966
1967 BEGIN_EVENT_TABLE(wxAuiTabCtrl, wxControl)
1968     EVT_PAINT(wxAuiTabCtrl::OnPaint)
1969     EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
1970     EVT_SIZE(wxAuiTabCtrl::OnSize)
1971     EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
1972     EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
1973     EVT_MOTION(wxAuiTabCtrl::OnMotion)
1974     EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
1975     EVT_AUINOTEBOOK_BUTTON(-1, wxAuiTabCtrl::OnButton)
1976 END_EVENT_TABLE()
1977
1978
1979 wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent,
1980                            wxWindowID id,
1981                            const wxPoint& pos,
1982                            const wxSize& size,
1983                            long style) : wxControl(parent, id, pos, size, style)
1984 {
1985     m_click_pt = wxDefaultPosition;
1986     m_is_dragging = false;
1987     m_hover_button = NULL;
1988     m_pressed_button = NULL;
1989 }
1990
1991 wxAuiTabCtrl::~wxAuiTabCtrl()
1992 {
1993 }
1994
1995 void wxAuiTabCtrl::OnPaint(wxPaintEvent&)
1996 {
1997     wxPaintDC dc(this);
1998
1999     dc.SetFont(GetFont());
2000
2001     if (GetPageCount() > 0)
2002         Render(&dc, this);
2003 }
2004
2005 void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
2006 {
2007 }
2008
2009 void wxAuiTabCtrl::OnSize(wxSizeEvent& evt)
2010 {
2011     wxSize s = evt.GetSize();
2012     wxRect r(0, 0, s.GetWidth(), s.GetHeight());
2013     SetRect(r);
2014 }
2015
2016 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
2017 {
2018     CaptureMouse();
2019     m_click_pt = wxDefaultPosition;
2020     m_is_dragging = false;
2021     m_click_tab = NULL;
2022     m_pressed_button = NULL;
2023
2024
2025     wxWindow* wnd;
2026     if (TabHitTest(evt.m_x, evt.m_y, &wnd))
2027     {
2028         int new_selection = GetIdxFromWindow(wnd);
2029
2030         if (new_selection != GetActivePage())
2031         {
2032             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2033             e.SetSelection(new_selection);
2034             e.SetOldSelection(GetActivePage());
2035             e.SetEventObject(this);
2036             GetEventHandler()->ProcessEvent(e);
2037         }
2038
2039         m_click_pt.x = evt.m_x;
2040         m_click_pt.y = evt.m_y;
2041         m_click_tab = wnd;
2042     }
2043
2044     if (m_hover_button)
2045     {
2046         m_pressed_button = m_hover_button;
2047         m_pressed_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
2048         Refresh();
2049         Update();
2050     }
2051 }
2052
2053 void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
2054 {
2055     if (GetCapture() == this)
2056         ReleaseMouse();
2057
2058     if (m_is_dragging)
2059     {
2060         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
2061         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2062         evt.SetOldSelection(evt.GetSelection());
2063         evt.SetEventObject(this);
2064         GetEventHandler()->ProcessEvent(evt);
2065         return;
2066     }
2067
2068     if (m_pressed_button)
2069     {
2070         // make sure we're still clicking the button
2071         wxAuiTabContainerButton* button = NULL;
2072         if (!ButtonHitTest(evt.m_x, evt.m_y, &button))
2073             return;
2074
2075         if (button != m_pressed_button)
2076         {
2077             m_pressed_button = NULL;
2078             return;
2079         }
2080
2081         Refresh();
2082         Update();
2083
2084         if (!(m_pressed_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
2085         {
2086             wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
2087             evt.SetInt(m_pressed_button->id);
2088             evt.SetEventObject(this);
2089             GetEventHandler()->ProcessEvent(evt);
2090         }
2091
2092         m_pressed_button = NULL;
2093     }
2094
2095     m_click_pt = wxDefaultPosition;
2096     m_is_dragging = false;
2097     m_click_tab = NULL;
2098 }
2099
2100 void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
2101 {
2102     wxPoint pos = evt.GetPosition();
2103
2104     // check if the mouse is hovering above a button
2105     wxAuiTabContainerButton* button;
2106     if (ButtonHitTest(pos.x, pos.y, &button))
2107     {
2108         if (m_hover_button && button != m_hover_button)
2109         {
2110             m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2111             m_hover_button = NULL;
2112             Refresh();
2113             Update();
2114         }
2115
2116         if (button->cur_state != wxAUI_BUTTON_STATE_HOVER)
2117         {
2118             button->cur_state = wxAUI_BUTTON_STATE_HOVER;
2119             Refresh();
2120             Update();
2121             m_hover_button = button;
2122             return;
2123         }
2124     }
2125      else
2126     {
2127         if (m_hover_button)
2128         {
2129             m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2130             m_hover_button = NULL;
2131             Refresh();
2132             Update();
2133         }
2134     }
2135
2136
2137     if (!evt.LeftIsDown() || m_click_pt == wxDefaultPosition)
2138         return;
2139
2140     if (m_is_dragging)
2141     {
2142         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
2143         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2144         evt.SetOldSelection(evt.GetSelection());
2145         evt.SetEventObject(this);
2146         GetEventHandler()->ProcessEvent(evt);
2147         return;
2148     }
2149
2150
2151     int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
2152     int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
2153
2154     if (abs(pos.x - m_click_pt.x) > drag_x_threshold ||
2155         abs(pos.y - m_click_pt.y) > drag_y_threshold)
2156     {
2157         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
2158         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2159         evt.SetOldSelection(evt.GetSelection());
2160         evt.SetEventObject(this);
2161         GetEventHandler()->ProcessEvent(evt);
2162
2163         m_is_dragging = true;
2164     }
2165 }
2166
2167 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
2168 {
2169     if (m_hover_button)
2170     {
2171         m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2172         m_hover_button = NULL;
2173         Refresh();
2174         Update();
2175     }
2176 }
2177
2178 void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
2179 {
2180     int button = event.GetInt();
2181
2182     if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
2183     {
2184         if (button == wxAUI_BUTTON_LEFT)
2185         {
2186             if (GetTabOffset() > 0)
2187             {
2188                 SetTabOffset(GetTabOffset()-1);
2189                 Refresh();
2190                 Update();
2191             }
2192         }
2193          else
2194         {
2195             SetTabOffset(GetTabOffset()+1);
2196             Refresh();
2197             Update();
2198         }
2199     }
2200      else if (button == wxAUI_BUTTON_WINDOWLIST)
2201     {
2202         wxArrayString as;
2203
2204         size_t i, page_count = m_pages.GetCount();
2205         for (i = 0; i < page_count; ++i)
2206         {
2207             wxAuiNotebookPage& page = m_pages.Item(i);
2208             as.Add(page.caption);
2209         }
2210
2211         int idx = GetArtProvider()->ShowWindowList(this, as, GetActivePage());
2212
2213         if (idx != -1)
2214         {
2215             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2216             e.SetSelection(idx);
2217             e.SetOldSelection(GetActivePage());
2218             e.SetEventObject(this);
2219             GetEventHandler()->ProcessEvent(e);
2220         }
2221     }
2222      else
2223     {
2224         event.Skip();
2225     }
2226 }
2227
2228 // wxTabFrame is an interesting case.  It's important that all child pages
2229 // of the multi-notebook control are all actually children of that control
2230 // (and not grandchildren).  wxTabFrame facilitates this.  There is one
2231 // instance of wxTabFrame for each tab control inside the multi-notebook.
2232 // It's important to know that wxTabFrame is not a real window, but it merely
2233 // used to capture the dimensions/positioning of the internal tab control and
2234 // it's managed page windows
2235
2236 class wxTabFrame : public wxWindow
2237 {
2238 public:
2239
2240     wxTabFrame()
2241     {
2242         m_tabs = NULL;
2243         m_rect = wxRect(0,0,200,200);
2244         m_tab_ctrl_height = 20;
2245     }
2246
2247     void SetTabCtrlHeight(int h)
2248     {
2249         m_tab_ctrl_height = h;
2250     }
2251
2252     void DoSetSize(int x, int y,
2253                    int width, int height,
2254                    int WXUNUSED(sizeFlags = wxSIZE_AUTO))
2255     {
2256         m_rect = wxRect(x, y, width, height);
2257         DoSizing();
2258     }
2259
2260     void DoGetClientSize(int* x, int* y) const
2261     {
2262         *x = m_rect.width;
2263         *y = m_rect.height;
2264     }
2265
2266     bool Show( bool WXUNUSED(show = true) ) { return false; }
2267
2268     void DoSizing()
2269     {
2270         if (!m_tabs)
2271             return;
2272
2273         m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2274         m_tabs->SetSize(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2275         m_tabs->SetRect(wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
2276         m_tabs->Refresh();
2277         m_tabs->Update();
2278
2279         wxAuiNotebookPageArray& pages = m_tabs->GetPages();
2280         size_t i, page_count = pages.GetCount();
2281
2282         for (i = 0; i < page_count; ++i)
2283         {
2284             wxAuiNotebookPage& page = pages.Item(i);
2285             page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
2286                                  m_rect.width, m_rect.height - m_tab_ctrl_height);
2287
2288             if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2289             {
2290                 wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
2291                 wnd->ApplyMDIChildFrameRect();
2292             }
2293         }
2294     }
2295
2296     void DoGetSize(int* x, int* y) const
2297     {
2298         if (x)
2299             *x = m_rect.GetWidth();
2300         if (y)
2301             *y = m_rect.GetHeight();
2302     }
2303
2304     void Update()
2305     {
2306         // does nothing
2307     }
2308
2309 public:
2310
2311     wxRect m_rect;
2312     wxRect m_tab_rect;
2313     wxAuiTabCtrl* m_tabs;
2314     int m_tab_ctrl_height;
2315 };
2316
2317
2318
2319
2320
2321 // -- wxAuiNotebook class implementation --
2322
2323 BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
2324     //EVT_ERASE_BACKGROUND(wxAuiNotebook::OnEraseBackground)
2325     EVT_SIZE(wxAuiNotebook::OnSize)
2326     //EVT_LEFT_DOWN(wxAuiNotebook::OnLeftDown)
2327     EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus)
2328     EVT_COMMAND_RANGE(10000, 10100,
2329                       wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
2330                       wxAuiNotebook::OnTabClicked)
2331     EVT_COMMAND_RANGE(10000, 10100,
2332                       wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
2333                       wxAuiNotebook::OnTabBeginDrag)
2334     EVT_COMMAND_RANGE(10000, 10100,
2335                       wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
2336                       wxAuiNotebook::OnTabEndDrag)
2337     EVT_COMMAND_RANGE(10000, 10100,
2338                       wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
2339                       wxAuiNotebook::OnTabDragMotion)
2340     EVT_COMMAND_RANGE(10000, 10100,
2341                       wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
2342                       wxAuiNotebook::OnTabButton)
2343 END_EVENT_TABLE()
2344
2345 wxAuiNotebook::wxAuiNotebook()
2346 {
2347     m_curpage = -1;
2348     m_tab_id_counter = 10000;
2349     m_dummy_wnd = NULL;
2350     m_tab_ctrl_height = 20;
2351     m_requested_bmp_size = wxDefaultSize;
2352     m_requested_tabctrl_height = -1;
2353 }
2354
2355 wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
2356                              wxWindowID id,
2357                              const wxPoint& pos,
2358                              const wxSize& size,
2359                              long style) : wxControl(parent, id, pos, size, style)
2360 {
2361     m_dummy_wnd = NULL;
2362     m_requested_bmp_size = wxDefaultSize;
2363     m_requested_tabctrl_height = -1;
2364     InitNotebook(style);
2365 }
2366
2367 bool wxAuiNotebook::Create(wxWindow* parent,
2368                            wxWindowID id,
2369                            const wxPoint& pos,
2370                            const wxSize& size,
2371                            long style)
2372 {
2373     if (!wxControl::Create(parent, id, pos, size, style))
2374         return false;
2375
2376     InitNotebook(style);
2377
2378     return true;
2379 }
2380
2381 // InitNotebook() contains common initialization
2382 // code called by all constructors
2383 void wxAuiNotebook::InitNotebook(long style)
2384 {
2385     m_curpage = -1;
2386     m_tab_id_counter = 10000;
2387     m_dummy_wnd = NULL;
2388     m_flags = (unsigned int)style;
2389     m_tab_ctrl_height = 20;
2390
2391     m_normal_font = *wxNORMAL_FONT;
2392     m_selected_font = *wxNORMAL_FONT;
2393     m_selected_font.SetWeight(wxBOLD);
2394
2395     SetArtProvider(new wxAuiDefaultTabArt);
2396
2397     m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
2398     m_dummy_wnd->SetSize(200, 200);
2399     m_dummy_wnd->Show(false);
2400
2401     m_mgr.SetManagedWindow(this);
2402     m_mgr.SetFlags(wxAUI_MGR_DEFAULT | (1 << 28) /*wxAUI_MGR_NO_DOCK_SIZE_LIMIT*/);
2403
2404     m_mgr.AddPane(m_dummy_wnd,
2405               wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
2406
2407     m_mgr.Update();
2408 }
2409
2410 wxAuiNotebook::~wxAuiNotebook()
2411 {
2412     m_mgr.UnInit();
2413 }
2414
2415 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
2416 {
2417     m_tabs.SetArtProvider(art);
2418
2419     UpdateTabCtrlHeight();
2420 }
2421
2422 // SetTabCtrlHeight() is the highest-level override of the
2423 // tab height.  A call to this function effectively enforces a
2424 // specified tab ctrl height, overriding all other considerations,
2425 // such as text or bitmap height.  It overrides any call to
2426 // SetUniformBitmapSize().  Specifying a height of -1 reverts
2427 // any previous call and returns to the default behavior
2428
2429 void wxAuiNotebook::SetTabCtrlHeight(int height)
2430 {
2431     m_requested_tabctrl_height = height;
2432
2433     // if window is already initialized, recalculate the tab height
2434     if (m_dummy_wnd)
2435     {
2436         UpdateTabCtrlHeight();
2437     }
2438 }
2439
2440
2441 // SetUniformBitmapSize() ensures that all tabs will have
2442 // the same height, even if some tabs don't have bitmaps
2443 // Passing wxDefaultSize to this function will instruct
2444 // the control to use dynamic tab height-- so when a tab
2445 // with a large bitmap is added, the tab ctrl's height will
2446 // automatically increase to accommodate the bitmap
2447
2448 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
2449 {
2450     m_requested_bmp_size = size;
2451
2452     // if window is already initialized, recalculate the tab height
2453     if (m_dummy_wnd)
2454     {
2455         UpdateTabCtrlHeight();
2456     }
2457 }
2458
2459 // UpdateTabCtrlHeight() does the actual tab resizing. It's meant
2460 // to be used interally
2461 void wxAuiNotebook::UpdateTabCtrlHeight()
2462 {
2463     // get the tab ctrl height we will use
2464     int height = CalculateTabCtrlHeight();
2465
2466     // if the tab control height needs to change, update
2467     // all of our tab controls with the new height
2468     if (m_tab_ctrl_height != height)
2469     {
2470         wxAuiTabArt* art = m_tabs.GetArtProvider();
2471
2472         m_tab_ctrl_height = height;
2473
2474         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2475         size_t i, pane_count = all_panes.GetCount();
2476         for (i = 0; i < pane_count; ++i)
2477         {
2478             wxAuiPaneInfo& pane = all_panes.Item(i);
2479             if (pane.name == wxT("dummy"))
2480                 continue;
2481             wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
2482             wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
2483             tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
2484             tabctrl->SetArtProvider(art->Clone());
2485             tab_frame->DoSizing();
2486         }
2487     }
2488 }
2489
2490 void wxAuiNotebook::UpdateHintWindowSize()
2491 {
2492     wxSize size = CalculateNewSplitSize();
2493
2494     // the placeholder hint window should be set to this size
2495     wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
2496     if (info.IsOk())
2497     {
2498         info.MinSize(size);
2499         info.BestSize(size);
2500         m_dummy_wnd->SetSize(size);
2501     }
2502 }
2503
2504
2505 // calculates the size of the new split
2506 wxSize wxAuiNotebook::CalculateNewSplitSize()
2507 {
2508     // count number of tab controls
2509     int tab_ctrl_count = 0;
2510     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2511     size_t i, pane_count = all_panes.GetCount();
2512     for (i = 0; i < pane_count; ++i)
2513     {
2514         wxAuiPaneInfo& pane = all_panes.Item(i);
2515         if (pane.name == wxT("dummy"))
2516             continue;
2517         tab_ctrl_count++;
2518     }
2519
2520     wxSize new_split_size;
2521
2522     // if there is only one tab control, the first split
2523     // should happen around the middle
2524     if (tab_ctrl_count < 2)
2525     {
2526         new_split_size = GetClientSize();
2527         new_split_size.x /= 2;
2528         new_split_size.y /= 2;
2529     }
2530      else
2531     {
2532         // this is in place of a more complicated calculation
2533         // that needs to be implemented
2534         new_split_size = wxSize(180,180);
2535     }
2536
2537     return new_split_size;
2538 }
2539
2540 int wxAuiNotebook::CalculateTabCtrlHeight()
2541 {
2542     // if a fixed tab ctrl height is specified,
2543     // just return that instead of calculating a
2544     // tab height
2545     if (m_requested_tabctrl_height != -1)
2546         return m_requested_tabctrl_height;
2547
2548     // find out new best tab height
2549     wxAuiTabArt* art = m_tabs.GetArtProvider();
2550
2551     return art->GetBestTabCtrlSize(this,
2552                                    m_tabs.GetPages(),
2553                                    m_requested_bmp_size);
2554 }
2555
2556
2557 wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
2558 {
2559     return m_tabs.GetArtProvider();
2560 }
2561
2562 void wxAuiNotebook::SetWindowStyleFlag(long style)
2563 {
2564     wxControl::SetWindowStyleFlag(style);
2565
2566     m_flags = (unsigned int)style;
2567
2568     // if the control is already initialized
2569     if (m_mgr.GetManagedWindow() == (wxWindow*)this)
2570     {
2571         // let all of the tab children know about the new style
2572
2573         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2574         size_t i, pane_count = all_panes.GetCount();
2575         for (i = 0; i < pane_count; ++i)
2576         {
2577             wxAuiPaneInfo& pane = all_panes.Item(i);
2578             if (pane.name == wxT("dummy"))
2579                 continue;
2580             wxTabFrame* tabframe = (wxTabFrame*)pane.window;
2581             wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
2582             tabctrl->SetFlags(m_flags);
2583             tabframe->DoSizing();
2584             tabctrl->Refresh();
2585             tabctrl->Update();
2586         }
2587     }
2588 }
2589
2590
2591 bool wxAuiNotebook::AddPage(wxWindow* page,
2592                             const wxString& caption,
2593                             bool select,
2594                             const wxBitmap& bitmap)
2595 {
2596     return InsertPage(GetPageCount(), page, caption, select, bitmap);
2597 }
2598
2599 bool wxAuiNotebook::InsertPage(size_t page_idx,
2600                                wxWindow* page,
2601                                const wxString& caption,
2602                                bool select,
2603                                const wxBitmap& bitmap)
2604 {
2605     wxAuiNotebookPage info;
2606     info.window = page;
2607     info.caption = caption;
2608     info.bitmap = bitmap;
2609     info.active = false;
2610
2611     // if there are currently no tabs, the first added
2612     // tab must be active
2613     if (m_tabs.GetPageCount() == 0)
2614         info.active = true;
2615
2616     m_tabs.InsertPage(page, info, page_idx);
2617
2618     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
2619     if (page_idx >= active_tabctrl->GetPageCount())
2620         active_tabctrl->AddPage(page, info);
2621          else
2622         active_tabctrl->InsertPage(page, info, page_idx);
2623
2624     UpdateTabCtrlHeight();
2625     DoSizing();
2626     active_tabctrl->DoShowHide();
2627
2628     if (select)
2629     {
2630         int idx = m_tabs.GetIdxFromWindow(page);
2631         wxASSERT_MSG(idx != -1, wxT("Invalid Page index returned on wxAuiNotebook::InsertPage()"));
2632
2633         SetSelection(idx);
2634     }
2635
2636     return true;
2637 }
2638
2639
2640 // DeletePage() removes a tab from the multi-notebook,
2641 // and destroys the window as well
2642 bool wxAuiNotebook::DeletePage(size_t page_idx)
2643 {
2644     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2645
2646     if (!RemovePage(page_idx))
2647         return false;
2648
2649     // actually destroy the window now
2650     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2651     {
2652         // delete the child frame with pending delete, as is
2653         // customary with frame windows
2654         if (!wxPendingDelete.Member(wnd))
2655             wxPendingDelete.Append(wnd);
2656     }
2657      else
2658     {
2659         wnd->Destroy();
2660     }
2661
2662     return true;
2663 }
2664
2665
2666
2667 // RemovePage() removes a tab from the multi-notebook,
2668 // but does not destroy the window
2669 bool wxAuiNotebook::RemovePage(size_t page_idx)
2670 {
2671     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2672     wxWindow* new_active = NULL;
2673
2674     // find out which onscreen tab ctrl owns this tab
2675     wxAuiTabCtrl* ctrl;
2676     int ctrl_idx;
2677     if (!FindTab(wnd, &ctrl, &ctrl_idx))
2678         return false;
2679
2680     // find a new page and set it as active
2681     int new_idx = ctrl_idx+1;
2682     if (new_idx >= (int)ctrl->GetPageCount())
2683         new_idx = ctrl_idx-1;
2684
2685     if (new_idx >= 0 && new_idx < (int)ctrl->GetPageCount())
2686     {
2687         new_active = ctrl->GetWindowFromIdx(new_idx);
2688     }
2689      else
2690     {
2691         // set the active page to the first page that
2692         // isn't the one being deleted
2693         size_t i, page_count = m_tabs.GetPageCount();
2694         for (i = 0; i < page_count; ++i)
2695         {
2696             wxWindow* w = m_tabs.GetWindowFromIdx(i);
2697             if (wnd != w)
2698             {
2699                 new_active = m_tabs.GetWindowFromIdx(i);
2700                 break;
2701             }
2702         }
2703     }
2704
2705     // remove the tab from main catalog
2706     if (!m_tabs.RemovePage(wnd))
2707         return false;
2708
2709     // remove the tab from the onscreen tab ctrl
2710     ctrl->RemovePage(wnd);
2711
2712
2713     RemoveEmptyTabFrames();
2714
2715     // set new active pane
2716     if (new_active)
2717     {
2718         m_curpage = -1;
2719         SetSelection(m_tabs.GetIdxFromWindow(new_active));
2720     }
2721
2722     return true;
2723 }
2724
2725 // GetPageIndex() returns the index of the page, or -1 if the
2726 // page could not be located in the notebook
2727 int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
2728 {
2729     return m_tabs.GetIdxFromWindow(page_wnd);
2730 }
2731
2732
2733
2734 // SetPageText() changes the tab caption of the specified page
2735 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
2736 {
2737     if (page_idx >= m_tabs.GetPageCount())
2738         return false;
2739
2740     // update our own tab catalog
2741     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2742     page_info.caption = text;
2743
2744     // update what's on screen
2745     wxAuiTabCtrl* ctrl;
2746     int ctrl_idx;
2747     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2748     {
2749         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2750         info.caption = text;
2751         ctrl->Refresh();
2752         ctrl->Update();
2753     }
2754
2755     return true;
2756 }
2757
2758
2759 bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
2760 {
2761     if (page_idx >= m_tabs.GetPageCount())
2762         return false;
2763
2764     // update our own tab catalog
2765     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2766     page_info.bitmap = bitmap;
2767
2768     // tab height might have changed
2769     UpdateTabCtrlHeight();
2770
2771     // update what's on screen
2772     wxAuiTabCtrl* ctrl;
2773     int ctrl_idx;
2774     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2775     {
2776         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2777         info.bitmap = bitmap;
2778         ctrl->Refresh();
2779         ctrl->Update();
2780     }
2781
2782     return true;
2783 }
2784
2785
2786 // GetSelection() returns the index of the currently active page
2787 int wxAuiNotebook::GetSelection() const
2788 {
2789     return m_curpage;
2790 }
2791
2792 // SetSelection() sets the currently active page
2793 size_t wxAuiNotebook::SetSelection(size_t new_page)
2794 {
2795     wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
2796     if (!wnd)
2797         return m_curpage;
2798
2799     wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2800     evt.SetSelection(new_page);
2801     evt.SetOldSelection(m_curpage);
2802     evt.SetEventObject(this);
2803     if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
2804     {
2805         int old_curpage = m_curpage;
2806         m_curpage = new_page;
2807
2808         // program allows the page change
2809         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
2810         (void)GetEventHandler()->ProcessEvent(evt);
2811
2812
2813         wxAuiTabCtrl* ctrl;
2814         int ctrl_idx;
2815         if (FindTab(wnd, &ctrl, &ctrl_idx))
2816         {
2817             m_tabs.SetActivePage(wnd);
2818
2819             ctrl->SetActivePage(ctrl_idx);
2820             DoSizing();
2821             ctrl->DoShowHide();
2822
2823
2824
2825             // set fonts
2826             wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2827             size_t i, pane_count = all_panes.GetCount();
2828             for (i = 0; i < pane_count; ++i)
2829             {
2830                 wxAuiPaneInfo& pane = all_panes.Item(i);
2831                 if (pane.name == wxT("dummy"))
2832                     continue;
2833                 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
2834                 if (tabctrl != ctrl)
2835                     tabctrl->SetSelectedFont(m_normal_font);
2836                      else
2837                     tabctrl->SetSelectedFont(m_selected_font);
2838                 tabctrl->Refresh();
2839             }
2840
2841             wnd->SetFocus();
2842
2843             return old_curpage;
2844         }
2845     }
2846
2847     return m_curpage;
2848 }
2849
2850 // GetPageCount() returns the total number of
2851 // pages managed by the multi-notebook
2852 size_t wxAuiNotebook::GetPageCount() const
2853 {
2854     return m_tabs.GetPageCount();
2855 }
2856
2857 // GetPage() returns the wxWindow pointer of the
2858 // specified page
2859 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
2860 {
2861     wxASSERT(page_idx < m_tabs.GetPageCount());
2862
2863     return m_tabs.GetWindowFromIdx(page_idx);
2864 }
2865
2866 // DoSizing() performs all sizing operations in each tab control
2867 void wxAuiNotebook::DoSizing()
2868 {
2869     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2870     size_t i, pane_count = all_panes.GetCount();
2871     for (i = 0; i < pane_count; ++i)
2872     {
2873         if (all_panes.Item(i).name == wxT("dummy"))
2874             continue;
2875
2876         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2877         tabframe->DoSizing();
2878     }
2879 }
2880
2881 // GetActiveTabCtrl() returns the active tab control.  It is
2882 // called to determine which control gets new windows being added
2883 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
2884 {
2885     if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
2886     {
2887         wxAuiTabCtrl* ctrl;
2888         int idx;
2889
2890         // find the tab ctrl with the current page
2891         if (FindTab(m_tabs.GetPage(m_curpage).window,
2892                     &ctrl, &idx))
2893         {
2894             return ctrl;
2895         }
2896     }
2897
2898     // no current page, just find the first tab ctrl
2899     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2900     size_t i, pane_count = all_panes.GetCount();
2901     for (i = 0; i < pane_count; ++i)
2902     {
2903         if (all_panes.Item(i).name == wxT("dummy"))
2904             continue;
2905
2906         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2907         return tabframe->m_tabs;
2908     }
2909
2910     // If there is no tabframe at all, create one
2911     wxTabFrame* tabframe = new wxTabFrame;
2912     tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
2913     tabframe->m_tabs = new wxAuiTabCtrl(this,
2914                                         m_tab_id_counter++,
2915                                         wxDefaultPosition,
2916                                         wxDefaultSize,
2917                                         wxNO_BORDER);
2918     tabframe->m_tabs->SetFlags(m_flags);
2919     tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2920     m_mgr.AddPane(tabframe,
2921                   wxAuiPaneInfo().Center().CaptionVisible(false));
2922
2923     m_mgr.Update();
2924
2925     return tabframe->m_tabs;
2926 }
2927
2928 // FindTab() finds the tab control that currently contains the window as well
2929 // as the index of the window in the tab control.  It returns true if the
2930 // window was found, otherwise false.
2931 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
2932 {
2933     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2934     size_t i, pane_count = all_panes.GetCount();
2935     for (i = 0; i < pane_count; ++i)
2936     {
2937         if (all_panes.Item(i).name == wxT("dummy"))
2938             continue;
2939
2940         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2941
2942         int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
2943         if (page_idx != -1)
2944         {
2945             *ctrl = tabframe->m_tabs;
2946             *idx = page_idx;
2947             return true;
2948         }
2949     }
2950
2951     return false;
2952 }
2953
2954
2955 void wxAuiNotebook::OnEraseBackground(wxEraseEvent&)
2956 {
2957 }
2958
2959 void wxAuiNotebook::OnSize(wxSizeEvent& evt)
2960 {
2961     UpdateHintWindowSize();
2962
2963     evt.Skip();
2964 }
2965
2966 void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
2967 {
2968     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
2969
2970     wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
2971     wxASSERT(ctrl != NULL);
2972
2973     wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
2974     wxASSERT(wnd != NULL);
2975
2976     int idx = m_tabs.GetIdxFromWindow(wnd);
2977     wxASSERT(idx != -1);
2978
2979     SetSelection(idx);
2980 }
2981
2982 void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
2983 {
2984     m_last_drag_x = 0;
2985 }
2986
2987 void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
2988 {
2989     wxPoint screen_pt = ::wxGetMousePosition();
2990     wxPoint client_pt = ScreenToClient(screen_pt);
2991     wxPoint zero(0,0);
2992
2993     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2994     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
2995
2996     if (dest_tabs == src_tabs)
2997     {
2998         if (src_tabs)
2999         {
3000             src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3001         }
3002
3003         // always hide the hint for inner-tabctrl drag
3004         m_mgr.HideHint();
3005
3006         // if tab moving is not allowed, leave
3007         if (!(m_flags & wxAUI_NB_TAB_MOVE))
3008         {
3009             return;
3010         }
3011
3012         wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
3013         wxWindow* dest_location_tab;
3014
3015         // this is an inner-tab drag/reposition
3016         if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
3017         {
3018             int src_idx = evt.GetSelection();
3019             int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
3020
3021             // prevent jumpy drag
3022             if ((src_idx == dest_idx) || dest_idx == -1 ||
3023                 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
3024                 (src_idx < dest_idx && m_last_drag_x >= pt.x))
3025             {
3026                 m_last_drag_x = pt.x;
3027                 return;
3028             }
3029
3030
3031             wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
3032             dest_tabs->MovePage(src_tab, dest_idx);
3033             dest_tabs->SetActivePage((size_t)dest_idx);
3034             dest_tabs->DoShowHide();
3035             dest_tabs->Refresh();
3036             m_last_drag_x = pt.x;
3037
3038         }
3039
3040         return;
3041     }
3042
3043
3044     // if external drag is allowed, check if the tab is being dragged
3045     // over a different wxAuiNotebook control
3046     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3047     {
3048         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
3049
3050         // if we aren't over any window, stop here
3051         if (!tab_ctrl)
3052             return;
3053
3054         // make sure we are not over the hint window
3055         if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
3056         {
3057             while (tab_ctrl)
3058             {
3059                 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3060                     break;
3061                 tab_ctrl = tab_ctrl->GetParent();
3062             }
3063
3064             if (tab_ctrl)
3065             {
3066                 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3067
3068                 if (nb != this)
3069                 {
3070                     wxRect hint_rect = tab_ctrl->GetClientRect();
3071                     tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
3072                     m_mgr.ShowHint(hint_rect);
3073                     return;
3074                 }
3075             }
3076         }
3077          else
3078         {
3079             if (!dest_tabs)
3080             {
3081                 // we are either over a hint window, or not over a tab
3082                 // window, and there is no where to drag to, so exit
3083                 return;
3084             }
3085         }
3086     }
3087
3088
3089     // if there are less than two panes, split can't happen, so leave
3090     if (m_tabs.GetPageCount() < 2)
3091         return;
3092
3093     // if tab moving is not allowed, leave
3094     if (!(m_flags & wxAUI_NB_TAB_SPLIT))
3095         return;
3096
3097
3098     if (src_tabs)
3099     {
3100         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
3101     }
3102
3103
3104     if (dest_tabs)
3105     {
3106         wxRect hint_rect = dest_tabs->GetRect();
3107         ClientToScreen(&hint_rect.x, &hint_rect.y);
3108         m_mgr.ShowHint(hint_rect);
3109     }
3110      else
3111     {
3112         m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
3113     }
3114 }
3115
3116
3117
3118 void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
3119 {
3120     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3121
3122     m_mgr.HideHint();
3123
3124
3125     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3126     wxAuiTabCtrl* dest_tabs = NULL;
3127     if (src_tabs)
3128     {
3129         // set cursor back to an arrow
3130         src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3131     }
3132
3133     // get the mouse position, which will be used to determine the drop point
3134     wxPoint mouse_screen_pt = ::wxGetMousePosition();
3135     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
3136
3137
3138
3139     // check for an external move
3140     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3141     {
3142         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
3143
3144         while (tab_ctrl)
3145         {
3146             if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3147                 break;
3148             tab_ctrl = tab_ctrl->GetParent();
3149         }
3150
3151         if (tab_ctrl)
3152         {
3153             wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3154
3155             if (nb != this)
3156             {
3157                 // find out from the destination control
3158                 // if it's ok to drop this tab here
3159                 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
3160                 e.SetSelection(evt.GetSelection());
3161                 e.SetOldSelection(evt.GetSelection());
3162                 e.SetEventObject(this);
3163                 e.SetDragSource(this);
3164                 e.Veto(); // dropping must be explicitly approved by control owner
3165
3166                 nb->GetEventHandler()->ProcessEvent(e);
3167
3168                 if (!e.IsAllowed())
3169                 {
3170                     // no answer or negative answer
3171                     m_mgr.HideHint();
3172                     return;
3173                 }
3174
3175                 // drop was allowed
3176                 int src_idx = evt.GetSelection();
3177                 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
3178
3179                 // get main index of the page
3180                 int main_idx = m_tabs.GetIdxFromWindow(src_page);
3181
3182                 // make a copy of the page info
3183                 wxAuiNotebookPage page_info = m_tabs.GetPage((size_t)main_idx);
3184
3185                 // remove the page from the source notebook
3186                 RemovePage(main_idx);
3187
3188                 // reparent the page
3189                 src_page->Reparent(nb);
3190
3191
3192                 // found out the insert idx
3193                 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
3194                 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3195
3196                 wxWindow* target = NULL;
3197                 int insert_idx = -1;
3198                 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3199                 if (target)
3200                 {
3201                     insert_idx = dest_tabs->GetIdxFromWindow(target);
3202                 }
3203
3204
3205                 // add the page to the new notebook
3206                 if (insert_idx == -1)
3207                     insert_idx = dest_tabs->GetPageCount();
3208                 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3209                 nb->m_tabs.AddPage(page_info.window, page_info);
3210
3211                 nb->DoSizing();
3212                 dest_tabs->DoShowHide();
3213                 dest_tabs->Refresh();
3214
3215                 // set the selection in the destination tab control
3216                 nb->SetSelection(nb->m_tabs.GetIdxFromWindow(page_info.window));
3217
3218                 return;
3219             }
3220         }
3221     }
3222
3223
3224
3225
3226     // only perform a tab split if it's allowed
3227     if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
3228     {
3229         // If the pointer is in an existing tab frame, do a tab insert
3230         wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
3231         wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
3232         int insert_idx = -1;
3233         if (tab_frame)
3234         {
3235             dest_tabs = tab_frame->m_tabs;
3236
3237             if (dest_tabs == src_tabs)
3238                 return;
3239
3240
3241             wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3242             wxWindow* target = NULL;
3243             dest_tabs->TabHitTest(pt.x, pt.y, &target);
3244             if (target)
3245             {
3246                 insert_idx = dest_tabs->GetIdxFromWindow(target);
3247             }
3248         }
3249          else
3250         {
3251             wxPoint zero(0,0);
3252             wxRect rect = m_mgr.CalculateHintRect(m_dummy_wnd,
3253                                                   mouse_client_pt,
3254                                                   zero);
3255             if (rect.IsEmpty())
3256             {
3257                 // there is no suitable drop location here, exit out
3258                 return;
3259             }
3260
3261             // If there is no tabframe at all, create one
3262             wxTabFrame* new_tabs = new wxTabFrame;
3263             new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
3264             new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3265             new_tabs->m_tabs = new wxAuiTabCtrl(this,
3266                                                 m_tab_id_counter++,
3267                                                 wxDefaultPosition,
3268                                                 wxDefaultSize,
3269                                                 wxNO_BORDER);
3270             new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3271             new_tabs->m_tabs->SetFlags(m_flags);
3272
3273             m_mgr.AddPane(new_tabs,
3274                           wxAuiPaneInfo().Bottom().CaptionVisible(false),
3275                           mouse_client_pt);
3276             m_mgr.Update();
3277             dest_tabs = new_tabs->m_tabs;
3278         }
3279
3280
3281
3282         // remove the page from the source tabs
3283         wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
3284         page_info.active = false;
3285         src_tabs->RemovePage(page_info.window);
3286         if (src_tabs->GetPageCount() > 0)
3287         {
3288             src_tabs->SetActivePage((size_t)0);
3289             src_tabs->DoShowHide();
3290             src_tabs->Refresh();
3291         }
3292
3293
3294
3295         // add the page to the destination tabs
3296         if (insert_idx == -1)
3297             insert_idx = dest_tabs->GetPageCount();
3298         dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3299
3300         if (src_tabs->GetPageCount() == 0)
3301         {
3302             RemoveEmptyTabFrames();
3303         }
3304
3305         DoSizing();
3306         dest_tabs->DoShowHide();
3307         dest_tabs->Refresh();
3308
3309         SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
3310
3311         UpdateHintWindowSize();
3312     }
3313 }
3314
3315
3316
3317 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
3318 {
3319     // if we've just removed the last tab from the source
3320     // tab set, the remove the tab control completely
3321     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3322     size_t i, pane_count = all_panes.GetCount();
3323     for (i = 0; i < pane_count; ++i)
3324     {
3325         if (all_panes.Item(i).name == wxT("dummy"))
3326             continue;
3327
3328         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3329         if (tabframe->m_tab_rect.Contains(pt))
3330             return tabframe->m_tabs;
3331     }
3332
3333     return NULL;
3334 }
3335
3336 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
3337 {
3338     // if we've just removed the last tab from the source
3339     // tab set, the remove the tab control completely
3340     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3341     size_t i, pane_count = all_panes.GetCount();
3342     for (i = 0; i < pane_count; ++i)
3343     {
3344         if (all_panes.Item(i).name == wxT("dummy"))
3345             continue;
3346
3347         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3348         if (tabframe->m_tabs == tab_ctrl)
3349         {
3350             return tabframe;
3351         }
3352     }
3353
3354     return NULL;
3355 }
3356
3357 void wxAuiNotebook::RemoveEmptyTabFrames()
3358 {
3359     // if we've just removed the last tab from the source
3360     // tab set, the remove the tab control completely
3361     wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
3362     size_t i, pane_count = all_panes.GetCount();
3363     for (i = 0; i < pane_count; ++i)
3364     {
3365         if (all_panes.Item(i).name == wxT("dummy"))
3366             continue;
3367
3368         wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
3369         if (tab_frame->m_tabs->GetPageCount() == 0)
3370         {
3371             m_mgr.DetachPane(tab_frame);
3372
3373             // use pending delete because sometimes during
3374             // window closing, refreshs are pending
3375             if (!wxPendingDelete.Member(tab_frame->m_tabs))
3376                 wxPendingDelete.Append(tab_frame->m_tabs);
3377             //tab_frame->m_tabs->Destroy();
3378
3379             delete tab_frame;
3380         }
3381     }
3382
3383
3384     // check to see if there is still a center pane;
3385     // if there isn't, make a frame the center pane
3386     wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
3387     pane_count = panes.GetCount();
3388     wxWindow* first_good = NULL;
3389     bool center_found = false;
3390     for (i = 0; i < pane_count; ++i)
3391     {
3392         if (panes.Item(i).name == wxT("dummy"))
3393             continue;
3394         if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
3395             center_found = true;
3396         if (!first_good)
3397             first_good = panes.Item(i).window;
3398     }
3399
3400     if (!center_found && first_good)
3401     {
3402         m_mgr.GetPane(first_good).Centre();
3403     }
3404
3405     m_mgr.Update();
3406 }
3407
3408 void wxAuiNotebook::OnChildFocus(wxChildFocusEvent& evt)
3409 {
3410     int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
3411     if (idx != -1 && idx != m_curpage)
3412     {
3413         SetSelection(idx);
3414     }
3415 }
3416
3417
3418 void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
3419 {
3420     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3421     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3422
3423     int button_id = evt.GetInt();
3424
3425     if (button_id == wxAUI_BUTTON_CLOSE)
3426     {
3427         int selection = tabs->GetActivePage();
3428
3429         if (selection != -1)
3430         {
3431             wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
3432
3433
3434             // ask owner if it's ok to close the tab
3435             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
3436             e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
3437             e.SetOldSelection(evt.GetSelection());
3438             e.SetEventObject(this);
3439             GetEventHandler()->ProcessEvent(e);
3440             if (!e.IsAllowed())
3441                 return;
3442
3443
3444             if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3445             {
3446                 close_wnd->Close();
3447             }
3448              else
3449             {
3450                 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
3451                 DeletePage(main_idx);
3452             }
3453         }
3454     }
3455 }
3456
3457
3458
3459
3460 #endif // wxUSE_AUI