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     // if that was the first page added, even if
2619     // select is false, it must become the "current page"
2620     // (though no select events will be fired)
2621     if (!select && m_tabs.GetPageCount() == 1)
2622         m_curpage = GetPageIndex(page);
2623
2624     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
2625     if (page_idx >= active_tabctrl->GetPageCount())
2626         active_tabctrl->AddPage(page, info);
2627          else
2628         active_tabctrl->InsertPage(page, info, page_idx);
2629
2630     UpdateTabCtrlHeight();
2631     DoSizing();
2632     active_tabctrl->DoShowHide();
2633
2634     if (select)
2635     {
2636         int idx = m_tabs.GetIdxFromWindow(page);
2637         wxASSERT_MSG(idx != -1, wxT("Invalid Page index returned on wxAuiNotebook::InsertPage()"));
2638
2639         SetSelection(idx);
2640     }
2641
2642     return true;
2643 }
2644
2645
2646 // DeletePage() removes a tab from the multi-notebook,
2647 // and destroys the window as well
2648 bool wxAuiNotebook::DeletePage(size_t page_idx)
2649 {
2650     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2651
2652     if (!RemovePage(page_idx))
2653         return false;
2654
2655     // actually destroy the window now
2656     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2657     {
2658         // delete the child frame with pending delete, as is
2659         // customary with frame windows
2660         if (!wxPendingDelete.Member(wnd))
2661             wxPendingDelete.Append(wnd);
2662     }
2663      else
2664     {
2665         wnd->Destroy();
2666     }
2667
2668     return true;
2669 }
2670
2671
2672
2673 // RemovePage() removes a tab from the multi-notebook,
2674 // but does not destroy the window
2675 bool wxAuiNotebook::RemovePage(size_t page_idx)
2676 {
2677     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2678     wxWindow* new_active = NULL;
2679
2680     // find out which onscreen tab ctrl owns this tab
2681     wxAuiTabCtrl* ctrl;
2682     int ctrl_idx;
2683     if (!FindTab(wnd, &ctrl, &ctrl_idx))
2684         return false;
2685
2686     // find a new page and set it as active
2687     int new_idx = ctrl_idx+1;
2688     if (new_idx >= (int)ctrl->GetPageCount())
2689         new_idx = ctrl_idx-1;
2690
2691     if (new_idx >= 0 && new_idx < (int)ctrl->GetPageCount())
2692     {
2693         new_active = ctrl->GetWindowFromIdx(new_idx);
2694     }
2695      else
2696     {
2697         // set the active page to the first page that
2698         // isn't the one being deleted
2699         size_t i, page_count = m_tabs.GetPageCount();
2700         for (i = 0; i < page_count; ++i)
2701         {
2702             wxWindow* w = m_tabs.GetWindowFromIdx(i);
2703             if (wnd != w)
2704             {
2705                 new_active = m_tabs.GetWindowFromIdx(i);
2706                 break;
2707             }
2708         }
2709     }
2710
2711     // remove the tab from main catalog
2712     if (!m_tabs.RemovePage(wnd))
2713         return false;
2714
2715     // remove the tab from the onscreen tab ctrl
2716     ctrl->RemovePage(wnd);
2717
2718
2719     RemoveEmptyTabFrames();
2720
2721     // set new active pane
2722     if (new_active)
2723     {
2724         m_curpage = -1;
2725         SetSelection(m_tabs.GetIdxFromWindow(new_active));
2726     }
2727
2728     return true;
2729 }
2730
2731 // GetPageIndex() returns the index of the page, or -1 if the
2732 // page could not be located in the notebook
2733 int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
2734 {
2735     return m_tabs.GetIdxFromWindow(page_wnd);
2736 }
2737
2738
2739
2740 // SetPageText() changes the tab caption of the specified page
2741 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
2742 {
2743     if (page_idx >= m_tabs.GetPageCount())
2744         return false;
2745
2746     // update our own tab catalog
2747     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2748     page_info.caption = text;
2749
2750     // update what's on screen
2751     wxAuiTabCtrl* ctrl;
2752     int ctrl_idx;
2753     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2754     {
2755         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2756         info.caption = text;
2757         ctrl->Refresh();
2758         ctrl->Update();
2759     }
2760
2761     return true;
2762 }
2763
2764
2765 bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
2766 {
2767     if (page_idx >= m_tabs.GetPageCount())
2768         return false;
2769
2770     // update our own tab catalog
2771     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2772     page_info.bitmap = bitmap;
2773
2774     // tab height might have changed
2775     UpdateTabCtrlHeight();
2776
2777     // update what's on screen
2778     wxAuiTabCtrl* ctrl;
2779     int ctrl_idx;
2780     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2781     {
2782         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2783         info.bitmap = bitmap;
2784         ctrl->Refresh();
2785         ctrl->Update();
2786     }
2787
2788     return true;
2789 }
2790
2791
2792 // GetSelection() returns the index of the currently active page
2793 int wxAuiNotebook::GetSelection() const
2794 {
2795     return m_curpage;
2796 }
2797
2798 // SetSelection() sets the currently active page
2799 size_t wxAuiNotebook::SetSelection(size_t new_page)
2800 {
2801     wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
2802     if (!wnd)
2803         return m_curpage;
2804
2805     wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2806     evt.SetSelection(new_page);
2807     evt.SetOldSelection(m_curpage);
2808     evt.SetEventObject(this);
2809     if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
2810     {
2811         int old_curpage = m_curpage;
2812         m_curpage = new_page;
2813
2814         // program allows the page change
2815         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
2816         (void)GetEventHandler()->ProcessEvent(evt);
2817
2818
2819         wxAuiTabCtrl* ctrl;
2820         int ctrl_idx;
2821         if (FindTab(wnd, &ctrl, &ctrl_idx))
2822         {
2823             m_tabs.SetActivePage(wnd);
2824
2825             ctrl->SetActivePage(ctrl_idx);
2826             DoSizing();
2827             ctrl->DoShowHide();
2828
2829
2830
2831             // set fonts
2832             wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2833             size_t i, pane_count = all_panes.GetCount();
2834             for (i = 0; i < pane_count; ++i)
2835             {
2836                 wxAuiPaneInfo& pane = all_panes.Item(i);
2837                 if (pane.name == wxT("dummy"))
2838                     continue;
2839                 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
2840                 if (tabctrl != ctrl)
2841                     tabctrl->SetSelectedFont(m_normal_font);
2842                      else
2843                     tabctrl->SetSelectedFont(m_selected_font);
2844                 tabctrl->Refresh();
2845             }
2846
2847             wnd->SetFocus();
2848
2849             return old_curpage;
2850         }
2851     }
2852
2853     return m_curpage;
2854 }
2855
2856 // GetPageCount() returns the total number of
2857 // pages managed by the multi-notebook
2858 size_t wxAuiNotebook::GetPageCount() const
2859 {
2860     return m_tabs.GetPageCount();
2861 }
2862
2863 // GetPage() returns the wxWindow pointer of the
2864 // specified page
2865 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
2866 {
2867     wxASSERT(page_idx < m_tabs.GetPageCount());
2868
2869     return m_tabs.GetWindowFromIdx(page_idx);
2870 }
2871
2872 // DoSizing() performs all sizing operations in each tab control
2873 void wxAuiNotebook::DoSizing()
2874 {
2875     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2876     size_t i, pane_count = all_panes.GetCount();
2877     for (i = 0; i < pane_count; ++i)
2878     {
2879         if (all_panes.Item(i).name == wxT("dummy"))
2880             continue;
2881
2882         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2883         tabframe->DoSizing();
2884     }
2885 }
2886
2887 // GetActiveTabCtrl() returns the active tab control.  It is
2888 // called to determine which control gets new windows being added
2889 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
2890 {
2891     if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
2892     {
2893         wxAuiTabCtrl* ctrl;
2894         int idx;
2895
2896         // find the tab ctrl with the current page
2897         if (FindTab(m_tabs.GetPage(m_curpage).window,
2898                     &ctrl, &idx))
2899         {
2900             return ctrl;
2901         }
2902     }
2903
2904     // no current page, just find the first tab ctrl
2905     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2906     size_t i, pane_count = all_panes.GetCount();
2907     for (i = 0; i < pane_count; ++i)
2908     {
2909         if (all_panes.Item(i).name == wxT("dummy"))
2910             continue;
2911
2912         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2913         return tabframe->m_tabs;
2914     }
2915
2916     // If there is no tabframe at all, create one
2917     wxTabFrame* tabframe = new wxTabFrame;
2918     tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
2919     tabframe->m_tabs = new wxAuiTabCtrl(this,
2920                                         m_tab_id_counter++,
2921                                         wxDefaultPosition,
2922                                         wxDefaultSize,
2923                                         wxNO_BORDER);
2924     tabframe->m_tabs->SetFlags(m_flags);
2925     tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2926     m_mgr.AddPane(tabframe,
2927                   wxAuiPaneInfo().Center().CaptionVisible(false));
2928
2929     m_mgr.Update();
2930
2931     return tabframe->m_tabs;
2932 }
2933
2934 // FindTab() finds the tab control that currently contains the window as well
2935 // as the index of the window in the tab control.  It returns true if the
2936 // window was found, otherwise false.
2937 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
2938 {
2939     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2940     size_t i, pane_count = all_panes.GetCount();
2941     for (i = 0; i < pane_count; ++i)
2942     {
2943         if (all_panes.Item(i).name == wxT("dummy"))
2944             continue;
2945
2946         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2947
2948         int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
2949         if (page_idx != -1)
2950         {
2951             *ctrl = tabframe->m_tabs;
2952             *idx = page_idx;
2953             return true;
2954         }
2955     }
2956
2957     return false;
2958 }
2959
2960
2961 void wxAuiNotebook::OnEraseBackground(wxEraseEvent&)
2962 {
2963 }
2964
2965 void wxAuiNotebook::OnSize(wxSizeEvent& evt)
2966 {
2967     UpdateHintWindowSize();
2968
2969     evt.Skip();
2970 }
2971
2972 void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
2973 {
2974     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
2975
2976     wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
2977     wxASSERT(ctrl != NULL);
2978
2979     wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
2980     wxASSERT(wnd != NULL);
2981
2982     int idx = m_tabs.GetIdxFromWindow(wnd);
2983     wxASSERT(idx != -1);
2984
2985     SetSelection(idx);
2986 }
2987
2988 void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
2989 {
2990     m_last_drag_x = 0;
2991 }
2992
2993 void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
2994 {
2995     wxPoint screen_pt = ::wxGetMousePosition();
2996     wxPoint client_pt = ScreenToClient(screen_pt);
2997     wxPoint zero(0,0);
2998
2999     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3000     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
3001
3002     if (dest_tabs == src_tabs)
3003     {
3004         if (src_tabs)
3005         {
3006             src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3007         }
3008
3009         // always hide the hint for inner-tabctrl drag
3010         m_mgr.HideHint();
3011
3012         // if tab moving is not allowed, leave
3013         if (!(m_flags & wxAUI_NB_TAB_MOVE))
3014         {
3015             return;
3016         }
3017
3018         wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
3019         wxWindow* dest_location_tab;
3020
3021         // this is an inner-tab drag/reposition
3022         if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
3023         {
3024             int src_idx = evt.GetSelection();
3025             int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
3026
3027             // prevent jumpy drag
3028             if ((src_idx == dest_idx) || dest_idx == -1 ||
3029                 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
3030                 (src_idx < dest_idx && m_last_drag_x >= pt.x))
3031             {
3032                 m_last_drag_x = pt.x;
3033                 return;
3034             }
3035
3036
3037             wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
3038             dest_tabs->MovePage(src_tab, dest_idx);
3039             dest_tabs->SetActivePage((size_t)dest_idx);
3040             dest_tabs->DoShowHide();
3041             dest_tabs->Refresh();
3042             m_last_drag_x = pt.x;
3043
3044         }
3045
3046         return;
3047     }
3048
3049
3050     // if external drag is allowed, check if the tab is being dragged
3051     // over a different wxAuiNotebook control
3052     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3053     {
3054         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
3055
3056         // if we aren't over any window, stop here
3057         if (!tab_ctrl)
3058             return;
3059
3060         // make sure we are not over the hint window
3061         if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
3062         {
3063             while (tab_ctrl)
3064             {
3065                 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3066                     break;
3067                 tab_ctrl = tab_ctrl->GetParent();
3068             }
3069
3070             if (tab_ctrl)
3071             {
3072                 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3073
3074                 if (nb != this)
3075                 {
3076                     wxRect hint_rect = tab_ctrl->GetClientRect();
3077                     tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
3078                     m_mgr.ShowHint(hint_rect);
3079                     return;
3080                 }
3081             }
3082         }
3083          else
3084         {
3085             if (!dest_tabs)
3086             {
3087                 // we are either over a hint window, or not over a tab
3088                 // window, and there is no where to drag to, so exit
3089                 return;
3090             }
3091         }
3092     }
3093
3094
3095     // if there are less than two panes, split can't happen, so leave
3096     if (m_tabs.GetPageCount() < 2)
3097         return;
3098
3099     // if tab moving is not allowed, leave
3100     if (!(m_flags & wxAUI_NB_TAB_SPLIT))
3101         return;
3102
3103
3104     if (src_tabs)
3105     {
3106         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
3107     }
3108
3109
3110     if (dest_tabs)
3111     {
3112         wxRect hint_rect = dest_tabs->GetRect();
3113         ClientToScreen(&hint_rect.x, &hint_rect.y);
3114         m_mgr.ShowHint(hint_rect);
3115     }
3116      else
3117     {
3118         m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
3119     }
3120 }
3121
3122
3123
3124 void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
3125 {
3126     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3127
3128     m_mgr.HideHint();
3129
3130
3131     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3132     wxAuiTabCtrl* dest_tabs = NULL;
3133     if (src_tabs)
3134     {
3135         // set cursor back to an arrow
3136         src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3137     }
3138
3139     // get the mouse position, which will be used to determine the drop point
3140     wxPoint mouse_screen_pt = ::wxGetMousePosition();
3141     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
3142
3143
3144
3145     // check for an external move
3146     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3147     {
3148         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
3149
3150         while (tab_ctrl)
3151         {
3152             if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3153                 break;
3154             tab_ctrl = tab_ctrl->GetParent();
3155         }
3156
3157         if (tab_ctrl)
3158         {
3159             wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3160
3161             if (nb != this)
3162             {
3163                 // find out from the destination control
3164                 // if it's ok to drop this tab here
3165                 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
3166                 e.SetSelection(evt.GetSelection());
3167                 e.SetOldSelection(evt.GetSelection());
3168                 e.SetEventObject(this);
3169                 e.SetDragSource(this);
3170                 e.Veto(); // dropping must be explicitly approved by control owner
3171
3172                 nb->GetEventHandler()->ProcessEvent(e);
3173
3174                 if (!e.IsAllowed())
3175                 {
3176                     // no answer or negative answer
3177                     m_mgr.HideHint();
3178                     return;
3179                 }
3180
3181                 // drop was allowed
3182                 int src_idx = evt.GetSelection();
3183                 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
3184
3185                 // get main index of the page
3186                 int main_idx = m_tabs.GetIdxFromWindow(src_page);
3187
3188                 // make a copy of the page info
3189                 wxAuiNotebookPage page_info = m_tabs.GetPage((size_t)main_idx);
3190
3191                 // remove the page from the source notebook
3192                 RemovePage(main_idx);
3193
3194                 // reparent the page
3195                 src_page->Reparent(nb);
3196
3197
3198                 // found out the insert idx
3199                 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
3200                 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3201
3202                 wxWindow* target = NULL;
3203                 int insert_idx = -1;
3204                 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3205                 if (target)
3206                 {
3207                     insert_idx = dest_tabs->GetIdxFromWindow(target);
3208                 }
3209
3210
3211                 // add the page to the new notebook
3212                 if (insert_idx == -1)
3213                     insert_idx = dest_tabs->GetPageCount();
3214                 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3215                 nb->m_tabs.AddPage(page_info.window, page_info);
3216
3217                 nb->DoSizing();
3218                 dest_tabs->DoShowHide();
3219                 dest_tabs->Refresh();
3220
3221                 // set the selection in the destination tab control
3222                 nb->SetSelection(nb->m_tabs.GetIdxFromWindow(page_info.window));
3223
3224                 return;
3225             }
3226         }
3227     }
3228
3229
3230
3231
3232     // only perform a tab split if it's allowed
3233     if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
3234     {
3235         // If the pointer is in an existing tab frame, do a tab insert
3236         wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
3237         wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
3238         int insert_idx = -1;
3239         if (tab_frame)
3240         {
3241             dest_tabs = tab_frame->m_tabs;
3242
3243             if (dest_tabs == src_tabs)
3244                 return;
3245
3246
3247             wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3248             wxWindow* target = NULL;
3249             dest_tabs->TabHitTest(pt.x, pt.y, &target);
3250             if (target)
3251             {
3252                 insert_idx = dest_tabs->GetIdxFromWindow(target);
3253             }
3254         }
3255          else
3256         {
3257             wxPoint zero(0,0);
3258             wxRect rect = m_mgr.CalculateHintRect(m_dummy_wnd,
3259                                                   mouse_client_pt,
3260                                                   zero);
3261             if (rect.IsEmpty())
3262             {
3263                 // there is no suitable drop location here, exit out
3264                 return;
3265             }
3266
3267             // If there is no tabframe at all, create one
3268             wxTabFrame* new_tabs = new wxTabFrame;
3269             new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
3270             new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3271             new_tabs->m_tabs = new wxAuiTabCtrl(this,
3272                                                 m_tab_id_counter++,
3273                                                 wxDefaultPosition,
3274                                                 wxDefaultSize,
3275                                                 wxNO_BORDER);
3276             new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3277             new_tabs->m_tabs->SetFlags(m_flags);
3278
3279             m_mgr.AddPane(new_tabs,
3280                           wxAuiPaneInfo().Bottom().CaptionVisible(false),
3281                           mouse_client_pt);
3282             m_mgr.Update();
3283             dest_tabs = new_tabs->m_tabs;
3284         }
3285
3286
3287
3288         // remove the page from the source tabs
3289         wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
3290         page_info.active = false;
3291         src_tabs->RemovePage(page_info.window);
3292         if (src_tabs->GetPageCount() > 0)
3293         {
3294             src_tabs->SetActivePage((size_t)0);
3295             src_tabs->DoShowHide();
3296             src_tabs->Refresh();
3297         }
3298
3299
3300
3301         // add the page to the destination tabs
3302         if (insert_idx == -1)
3303             insert_idx = dest_tabs->GetPageCount();
3304         dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3305
3306         if (src_tabs->GetPageCount() == 0)
3307         {
3308             RemoveEmptyTabFrames();
3309         }
3310
3311         DoSizing();
3312         dest_tabs->DoShowHide();
3313         dest_tabs->Refresh();
3314
3315         SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
3316
3317         UpdateHintWindowSize();
3318     }
3319 }
3320
3321
3322
3323 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
3324 {
3325     // if we've just removed the last tab from the source
3326     // tab set, the remove the tab control completely
3327     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3328     size_t i, pane_count = all_panes.GetCount();
3329     for (i = 0; i < pane_count; ++i)
3330     {
3331         if (all_panes.Item(i).name == wxT("dummy"))
3332             continue;
3333
3334         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3335         if (tabframe->m_tab_rect.Contains(pt))
3336             return tabframe->m_tabs;
3337     }
3338
3339     return NULL;
3340 }
3341
3342 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
3343 {
3344     // if we've just removed the last tab from the source
3345     // tab set, the remove the tab control completely
3346     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3347     size_t i, pane_count = all_panes.GetCount();
3348     for (i = 0; i < pane_count; ++i)
3349     {
3350         if (all_panes.Item(i).name == wxT("dummy"))
3351             continue;
3352
3353         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3354         if (tabframe->m_tabs == tab_ctrl)
3355         {
3356             return tabframe;
3357         }
3358     }
3359
3360     return NULL;
3361 }
3362
3363 void wxAuiNotebook::RemoveEmptyTabFrames()
3364 {
3365     // if we've just removed the last tab from the source
3366     // tab set, the remove the tab control completely
3367     wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
3368     size_t i, pane_count = all_panes.GetCount();
3369     for (i = 0; i < pane_count; ++i)
3370     {
3371         if (all_panes.Item(i).name == wxT("dummy"))
3372             continue;
3373
3374         wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
3375         if (tab_frame->m_tabs->GetPageCount() == 0)
3376         {
3377             m_mgr.DetachPane(tab_frame);
3378
3379             // use pending delete because sometimes during
3380             // window closing, refreshs are pending
3381             if (!wxPendingDelete.Member(tab_frame->m_tabs))
3382                 wxPendingDelete.Append(tab_frame->m_tabs);
3383             //tab_frame->m_tabs->Destroy();
3384
3385             delete tab_frame;
3386         }
3387     }
3388
3389
3390     // check to see if there is still a center pane;
3391     // if there isn't, make a frame the center pane
3392     wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
3393     pane_count = panes.GetCount();
3394     wxWindow* first_good = NULL;
3395     bool center_found = false;
3396     for (i = 0; i < pane_count; ++i)
3397     {
3398         if (panes.Item(i).name == wxT("dummy"))
3399             continue;
3400         if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
3401             center_found = true;
3402         if (!first_good)
3403             first_good = panes.Item(i).window;
3404     }
3405
3406     if (!center_found && first_good)
3407     {
3408         m_mgr.GetPane(first_good).Centre();
3409     }
3410
3411     m_mgr.Update();
3412 }
3413
3414 void wxAuiNotebook::OnChildFocus(wxChildFocusEvent& evt)
3415 {
3416     int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
3417     if (idx != -1 && idx != m_curpage)
3418     {
3419         SetSelection(idx);
3420     }
3421 }
3422
3423
3424 void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
3425 {
3426     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3427     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3428
3429     int button_id = evt.GetInt();
3430
3431     if (button_id == wxAUI_BUTTON_CLOSE)
3432     {
3433         int selection = tabs->GetActivePage();
3434
3435         if (selection != -1)
3436         {
3437             wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
3438
3439
3440             // ask owner if it's ok to close the tab
3441             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
3442             e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
3443             e.SetOldSelection(evt.GetSelection());
3444             e.SetEventObject(this);
3445             GetEventHandler()->ProcessEvent(e);
3446             if (!e.IsAllowed())
3447                 return;
3448
3449
3450             if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3451             {
3452                 close_wnd->Close();
3453             }
3454              else
3455             {
3456                 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
3457                 DeletePage(main_idx);
3458             }
3459         }
3460     }
3461 }
3462
3463
3464
3465
3466 #endif // wxUSE_AUI