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