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 }
2383
2384 wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
2385                              wxWindowID id,
2386                              const wxPoint& pos,
2387                              const wxSize& size,
2388                              long style) : wxControl(parent, id, pos, size, style)
2389 {
2390     m_dummy_wnd = NULL;
2391     m_requested_bmp_size = wxDefaultSize;
2392     InitNotebook(style);
2393 }
2394
2395 bool wxAuiNotebook::Create(wxWindow* parent,
2396                            wxWindowID id,
2397                            const wxPoint& pos,
2398                            const wxSize& size,
2399                            long style)
2400 {
2401     if (!wxControl::Create(parent, id, pos, size, style))
2402         return false;
2403
2404     InitNotebook(style);
2405
2406     return true;
2407 }
2408
2409 // InitNotebook() contains common initialization
2410 // code called by all constructors
2411 void wxAuiNotebook::InitNotebook(long style)
2412 {
2413     m_curpage = -1;
2414     m_tab_id_counter = 10000;
2415     m_dummy_wnd = NULL;
2416     m_tab_ctrl_height = 20;
2417     m_flags = (unsigned int)style;
2418
2419     m_normal_font = *wxNORMAL_FONT;
2420     m_selected_font = *wxNORMAL_FONT;
2421     m_selected_font.SetWeight(wxBOLD);
2422
2423     SetArtProvider(new wxAuiDefaultTabArt);
2424
2425     m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
2426     m_dummy_wnd->SetSize(200, 200);
2427     m_dummy_wnd->Show(false);
2428
2429     m_mgr.SetManagedWindow(this);
2430     m_mgr.SetFlags(wxAUI_MGR_DEFAULT | (1 << 28) /*wxAUI_MGR_NO_DOCK_SIZE_LIMIT*/);
2431
2432     m_mgr.AddPane(m_dummy_wnd,
2433               wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
2434
2435     m_mgr.Update();
2436 }
2437
2438 wxAuiNotebook::~wxAuiNotebook()
2439 {
2440     m_mgr.UnInit();
2441 }
2442
2443 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
2444 {
2445     m_tabs.SetArtProvider(art);
2446
2447     SetTabCtrlHeight(CalculateTabCtrlHeight());
2448 }
2449
2450 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
2451 {
2452     m_requested_bmp_size = size;
2453
2454     // if window is already initialized, recalculate the tab height
2455     if (m_dummy_wnd)
2456     {
2457         SetTabCtrlHeight(CalculateTabCtrlHeight());
2458     }
2459 }
2460
2461 void wxAuiNotebook::SetTabCtrlHeight(int height)
2462 {
2463     // if the tab control height needs to change, update
2464     // all of our tab controls with the new height
2465     if (m_tab_ctrl_height != height)
2466     {
2467         wxAuiTabArt* art = m_tabs.GetArtProvider();
2468
2469         m_tab_ctrl_height = height;
2470
2471         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2472         size_t i, pane_count = all_panes.GetCount();
2473         for (i = 0; i < pane_count; ++i)
2474         {
2475             wxAuiPaneInfo& pane = all_panes.Item(i);
2476             if (pane.name == wxT("dummy"))
2477                 continue;
2478             wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
2479             wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
2480             tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
2481             tabctrl->SetArtProvider(art->Clone());
2482             tab_frame->DoSizing();
2483         }
2484     }
2485 }
2486
2487 void wxAuiNotebook::UpdateHintWindowSize()
2488 {
2489     wxSize size = CalculateNewSplitSize();
2490
2491     // the placeholder hint window should be set to this size
2492     wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
2493     if (info.IsOk())
2494     {
2495         info.MinSize(size);
2496         info.BestSize(size);
2497         m_dummy_wnd->SetSize(size);
2498     }
2499 }
2500
2501
2502 // calculates the size of the new split
2503 wxSize wxAuiNotebook::CalculateNewSplitSize()
2504 {
2505     // count number of tab controls
2506     int tab_ctrl_count = 0;
2507     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2508     size_t i, pane_count = all_panes.GetCount();
2509     for (i = 0; i < pane_count; ++i)
2510     {
2511         wxAuiPaneInfo& pane = all_panes.Item(i);
2512         if (pane.name == wxT("dummy"))
2513             continue;
2514         tab_ctrl_count++;
2515     }
2516
2517     wxSize new_split_size;
2518
2519     // if there is only one tab control, the first split
2520     // should happen around the middle
2521     if (tab_ctrl_count < 2)
2522     {
2523         new_split_size = GetClientSize();
2524         new_split_size.x /= 2;
2525         new_split_size.y /= 2;
2526     }
2527      else
2528     {
2529         // this is in place of a more complicated calculation
2530         // that needs to be implemented
2531         new_split_size = wxSize(180,180);
2532     }
2533
2534     return new_split_size;
2535 }
2536
2537 int wxAuiNotebook::CalculateTabCtrlHeight()
2538 {
2539     // find out new best tab height
2540     wxAuiTabArt* art = m_tabs.GetArtProvider();
2541
2542     return art->GetBestTabCtrlSize(this,
2543                                    m_tabs.GetPages(),
2544                                    m_requested_bmp_size);
2545 }
2546
2547
2548 wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
2549 {
2550     return m_tabs.GetArtProvider();
2551 }
2552
2553 void wxAuiNotebook::SetWindowStyleFlag(long style)
2554 {
2555     wxControl::SetWindowStyleFlag(style);
2556
2557     m_flags = (unsigned int)style;
2558
2559     // if the control is already initialized
2560     if (m_mgr.GetManagedWindow() == (wxWindow*)this)
2561     {
2562         // let all of the tab children know about the new style
2563
2564         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2565         size_t i, pane_count = all_panes.GetCount();
2566         for (i = 0; i < pane_count; ++i)
2567         {
2568             wxAuiPaneInfo& pane = all_panes.Item(i);
2569             if (pane.name == wxT("dummy"))
2570                 continue;
2571             wxTabFrame* tabframe = (wxTabFrame*)pane.window;
2572             wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
2573             tabctrl->SetFlags(m_flags);
2574             tabframe->DoSizing();
2575             tabctrl->Refresh();
2576             tabctrl->Update();
2577         }
2578     }
2579 }
2580
2581
2582 bool wxAuiNotebook::AddPage(wxWindow* page,
2583                             const wxString& caption,
2584                             bool select,
2585                             const wxBitmap& bitmap)
2586 {
2587     return InsertPage(GetPageCount(), page, caption, select, bitmap);
2588 }
2589
2590 bool wxAuiNotebook::InsertPage(size_t page_idx,
2591                                wxWindow* page,
2592                                const wxString& caption,
2593                                bool select,
2594                                const wxBitmap& bitmap)
2595 {
2596     wxAuiNotebookPage info;
2597     info.window = page;
2598     info.caption = caption;
2599     info.bitmap = bitmap;
2600     info.active = false;
2601
2602     // if there are currently no tabs, the first added
2603     // tab must be active
2604     if (m_tabs.GetPageCount() == 0)
2605         info.active = true;
2606
2607     m_tabs.InsertPage(page, info, page_idx);
2608
2609     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
2610     if (page_idx >= active_tabctrl->GetPageCount())
2611         active_tabctrl->AddPage(page, info);
2612          else
2613         active_tabctrl->InsertPage(page, info, page_idx);
2614
2615     SetTabCtrlHeight(CalculateTabCtrlHeight());
2616     DoSizing();
2617     active_tabctrl->DoShowHide();
2618
2619     if (select)
2620     {
2621         int idx = m_tabs.GetIdxFromWindow(page);
2622         wxASSERT_MSG(idx != -1, wxT("Invalid Page index returned on wxAuiNotebook::InsertPage()"));
2623
2624         SetSelection(idx);
2625     }
2626
2627     return true;
2628 }
2629
2630
2631 // DeletePage() removes a tab from the multi-notebook,
2632 // and destroys the window as well
2633 bool wxAuiNotebook::DeletePage(size_t page_idx)
2634 {
2635     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2636
2637     if (!RemovePage(page_idx))
2638         return false;
2639
2640     // actually destroy the window now
2641     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2642     {
2643         // delete the child frame with pending delete, as is
2644         // customary with frame windows
2645         if (!wxPendingDelete.Member(wnd))
2646             wxPendingDelete.Append(wnd);
2647     }
2648      else
2649     {
2650         wnd->Destroy();
2651     }
2652
2653     return true;
2654 }
2655
2656
2657
2658 // RemovePage() removes a tab from the multi-notebook,
2659 // but does not destroy the window
2660 bool wxAuiNotebook::RemovePage(size_t page_idx)
2661 {
2662     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2663     wxWindow* new_active = NULL;
2664
2665     // find out which onscreen tab ctrl owns this tab
2666     wxAuiTabCtrl* ctrl;
2667     int ctrl_idx;
2668     if (!FindTab(wnd, &ctrl, &ctrl_idx))
2669         return false;
2670
2671     // find a new page and set it as active
2672     int new_idx = ctrl_idx+1;
2673     if (new_idx >= (int)ctrl->GetPageCount())
2674         new_idx = ctrl_idx-1;
2675
2676     if (new_idx >= 0 && new_idx < (int)ctrl->GetPageCount())
2677     {
2678         new_active = ctrl->GetWindowFromIdx(new_idx);
2679     }
2680      else
2681     {
2682         // set the active page to the first page that
2683         // isn't the one being deleted
2684         size_t i, page_count = m_tabs.GetPageCount();
2685         for (i = 0; i < page_count; ++i)
2686         {
2687             wxWindow* w = m_tabs.GetWindowFromIdx(i);
2688             if (wnd != w)
2689             {
2690                 new_active = m_tabs.GetWindowFromIdx(i);
2691                 break;
2692             }
2693         }
2694     }
2695
2696     // remove the tab from main catalog
2697     if (!m_tabs.RemovePage(wnd))
2698         return false;
2699
2700     // remove the tab from the onscreen tab ctrl
2701     ctrl->RemovePage(wnd);
2702
2703
2704     RemoveEmptyTabFrames();
2705
2706     // set new active pane
2707     if (new_active)
2708     {
2709         m_curpage = -1;
2710         SetSelection(m_tabs.GetIdxFromWindow(new_active));
2711     }
2712
2713     return true;
2714 }
2715
2716 // GetPageIndex() returns the index of the page, or -1 if the
2717 // page could not be located in the notebook
2718 int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
2719 {
2720     return m_tabs.GetIdxFromWindow(page_wnd);
2721 }
2722
2723
2724
2725 // SetPageText() changes the tab caption of the specified page
2726 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
2727 {
2728     if (page_idx >= m_tabs.GetPageCount())
2729         return false;
2730
2731     // update our own tab catalog
2732     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2733     page_info.caption = text;
2734
2735     // update what's on screen
2736     wxAuiTabCtrl* ctrl;
2737     int ctrl_idx;
2738     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2739     {
2740         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2741         info.caption = text;
2742         ctrl->Refresh();
2743         ctrl->Update();
2744     }
2745
2746     return true;
2747 }
2748
2749
2750 bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
2751 {
2752     if (page_idx >= m_tabs.GetPageCount())
2753         return false;
2754
2755     // update our own tab catalog
2756     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2757     page_info.bitmap = bitmap;
2758
2759     // tab height might have changed
2760     SetTabCtrlHeight(CalculateTabCtrlHeight());
2761
2762     // update what's on screen
2763     wxAuiTabCtrl* ctrl;
2764     int ctrl_idx;
2765     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2766     {
2767         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2768         info.bitmap = bitmap;
2769         ctrl->Refresh();
2770         ctrl->Update();
2771     }
2772
2773     return true;
2774 }
2775
2776
2777 // GetSelection() returns the index of the currently active page
2778 int wxAuiNotebook::GetSelection() const
2779 {
2780     return m_curpage;
2781 }
2782
2783 // SetSelection() sets the currently active page
2784 size_t wxAuiNotebook::SetSelection(size_t new_page)
2785 {
2786     wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
2787     if (!wnd)
2788         return m_curpage;
2789
2790     wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2791     evt.SetSelection(new_page);
2792     evt.SetOldSelection(m_curpage);
2793     evt.SetEventObject(this);
2794     if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
2795     {
2796         int old_curpage = m_curpage;
2797         m_curpage = new_page;
2798
2799         // program allows the page change
2800         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
2801         (void)GetEventHandler()->ProcessEvent(evt);
2802
2803
2804         wxAuiTabCtrl* ctrl;
2805         int ctrl_idx;
2806         if (FindTab(wnd, &ctrl, &ctrl_idx))
2807         {
2808             m_tabs.SetActivePage(wnd);
2809
2810             ctrl->SetActivePage(ctrl_idx);
2811             DoSizing();
2812             ctrl->DoShowHide();
2813
2814
2815
2816             // set fonts
2817             wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2818             size_t i, pane_count = all_panes.GetCount();
2819             for (i = 0; i < pane_count; ++i)
2820             {
2821                 wxAuiPaneInfo& pane = all_panes.Item(i);
2822                 if (pane.name == wxT("dummy"))
2823                     continue;
2824                 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
2825                 if (tabctrl != ctrl)
2826                     tabctrl->SetSelectedFont(m_normal_font);
2827                      else
2828                     tabctrl->SetSelectedFont(m_selected_font);
2829                 tabctrl->Refresh();
2830             }
2831
2832             wnd->SetFocus();
2833
2834             return old_curpage;
2835         }
2836     }
2837
2838     return m_curpage;
2839 }
2840
2841 // GetPageCount() returns the total number of
2842 // pages managed by the multi-notebook
2843 size_t wxAuiNotebook::GetPageCount() const
2844 {
2845     return m_tabs.GetPageCount();
2846 }
2847
2848 // GetPage() returns the wxWindow pointer of the
2849 // specified page
2850 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
2851 {
2852     wxASSERT(page_idx < m_tabs.GetPageCount());
2853
2854     return m_tabs.GetWindowFromIdx(page_idx);
2855 }
2856
2857 // DoSizing() performs all sizing operations in each tab control
2858 void wxAuiNotebook::DoSizing()
2859 {
2860     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2861     size_t i, pane_count = all_panes.GetCount();
2862     for (i = 0; i < pane_count; ++i)
2863     {
2864         if (all_panes.Item(i).name == wxT("dummy"))
2865             continue;
2866
2867         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2868         tabframe->DoSizing();
2869     }
2870 }
2871
2872 // GetActiveTabCtrl() returns the active tab control.  It is
2873 // called to determine which control gets new windows being added
2874 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
2875 {
2876     if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
2877     {
2878         wxAuiTabCtrl* ctrl;
2879         int idx;
2880
2881         // find the tab ctrl with the current page
2882         if (FindTab(m_tabs.GetPage(m_curpage).window,
2883                     &ctrl, &idx))
2884         {
2885             return ctrl;
2886         }
2887     }
2888
2889     // no current page, just find the first tab ctrl
2890     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2891     size_t i, pane_count = all_panes.GetCount();
2892     for (i = 0; i < pane_count; ++i)
2893     {
2894         if (all_panes.Item(i).name == wxT("dummy"))
2895             continue;
2896
2897         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2898         return tabframe->m_tabs;
2899     }
2900
2901     // If there is no tabframe at all, create one
2902     wxTabFrame* tabframe = new wxTabFrame;
2903     tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
2904     tabframe->m_tabs = new wxAuiTabCtrl(this,
2905                                         m_tab_id_counter++,
2906                                         wxDefaultPosition,
2907                                         wxDefaultSize,
2908                                         wxNO_BORDER);
2909     tabframe->m_tabs->SetFlags(m_flags);
2910     tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2911     m_mgr.AddPane(tabframe,
2912                   wxAuiPaneInfo().Center().CaptionVisible(false));
2913
2914     m_mgr.Update();
2915
2916     return tabframe->m_tabs;
2917 }
2918
2919 // FindTab() finds the tab control that currently contains the window as well
2920 // as the index of the window in the tab control.  It returns true if the
2921 // window was found, otherwise false.
2922 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
2923 {
2924     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2925     size_t i, pane_count = all_panes.GetCount();
2926     for (i = 0; i < pane_count; ++i)
2927     {
2928         if (all_panes.Item(i).name == wxT("dummy"))
2929             continue;
2930
2931         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2932
2933         int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
2934         if (page_idx != -1)
2935         {
2936             *ctrl = tabframe->m_tabs;
2937             *idx = page_idx;
2938             return true;
2939         }
2940     }
2941
2942     return false;
2943 }
2944
2945
2946 void wxAuiNotebook::OnEraseBackground(wxEraseEvent&)
2947 {
2948 }
2949
2950 void wxAuiNotebook::OnSize(wxSizeEvent& evt)
2951 {
2952     UpdateHintWindowSize();
2953
2954     evt.Skip();
2955 }
2956
2957 void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
2958 {
2959     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
2960
2961     wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
2962     wxASSERT(ctrl != NULL);
2963
2964     wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
2965     wxASSERT(wnd != NULL);
2966
2967     int idx = m_tabs.GetIdxFromWindow(wnd);
2968     wxASSERT(idx != -1);
2969
2970     SetSelection(idx);
2971 }
2972
2973 void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
2974 {
2975     m_last_drag_x = 0;
2976 }
2977
2978 void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
2979 {
2980     wxPoint screen_pt = ::wxGetMousePosition();
2981     wxPoint client_pt = ScreenToClient(screen_pt);
2982     wxPoint zero(0,0);
2983
2984     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2985     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
2986
2987     if (dest_tabs == src_tabs)
2988     {
2989         if (src_tabs)
2990         {
2991             src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
2992         }
2993
2994         // always hide the hint for inner-tabctrl drag
2995         m_mgr.HideHint();
2996
2997         // if tab moving is not allowed, leave
2998         if (!(m_flags & wxAUI_NB_TAB_MOVE))
2999         {
3000             return;
3001         }
3002
3003         wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
3004         wxWindow* dest_location_tab;
3005
3006         // this is an inner-tab drag/reposition
3007         if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
3008         {
3009             int src_idx = evt.GetSelection();
3010             int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
3011
3012             // prevent jumpy drag
3013             if ((src_idx == dest_idx) || dest_idx == -1 ||
3014                 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
3015                 (src_idx < dest_idx && m_last_drag_x >= pt.x))
3016             {
3017                 m_last_drag_x = pt.x;
3018                 return;
3019             }
3020
3021
3022             wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
3023             dest_tabs->MovePage(src_tab, dest_idx);
3024             dest_tabs->SetActivePage((size_t)dest_idx);
3025             dest_tabs->DoShowHide();
3026             dest_tabs->Refresh();
3027             m_last_drag_x = pt.x;
3028
3029         }
3030
3031         return;
3032     }
3033
3034
3035     // if external drag is allowed, check if the tab is being dragged
3036     // over a different wxAuiNotebook control
3037     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3038     {
3039         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
3040
3041         // if we aren't over any window, stop here
3042         if (!tab_ctrl)
3043             return;
3044
3045         // make sure we are not over the hint window
3046         if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
3047         {
3048             while (tab_ctrl)
3049             {
3050                 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3051                     break;
3052                 tab_ctrl = tab_ctrl->GetParent();
3053             }
3054
3055             if (tab_ctrl)
3056             {
3057                 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3058
3059                 if (nb != this)
3060                 {
3061                     wxRect hint_rect = tab_ctrl->GetClientRect();
3062                     tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
3063                     m_mgr.ShowHint(hint_rect);
3064                     return;
3065                 }
3066             }
3067         }
3068          else
3069         {
3070             if (!dest_tabs)
3071             {
3072                 // we are either over a hint window, or not over a tab
3073                 // window, and there is no where to drag to, so exit
3074                 return;
3075             }
3076         }
3077     }
3078
3079
3080     // if there are less than two panes, split can't happen, so leave
3081     if (m_tabs.GetPageCount() < 2)
3082         return;
3083
3084     // if tab moving is not allowed, leave
3085     if (!(m_flags & wxAUI_NB_TAB_SPLIT))
3086         return;
3087
3088
3089     if (src_tabs)
3090     {
3091         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
3092     }
3093
3094
3095     if (dest_tabs)
3096     {
3097         wxRect hint_rect = dest_tabs->GetRect();
3098         ClientToScreen(&hint_rect.x, &hint_rect.y);
3099         m_mgr.ShowHint(hint_rect);
3100     }
3101      else
3102     {
3103         m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
3104     }
3105 }
3106
3107
3108
3109 void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
3110 {
3111     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3112
3113     m_mgr.HideHint();
3114
3115
3116     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3117     wxAuiTabCtrl* dest_tabs = NULL;
3118     if (src_tabs)
3119     {
3120         // set cursor back to an arrow
3121         src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3122     }
3123
3124     // get the mouse position, which will be used to determine the drop point
3125     wxPoint mouse_screen_pt = ::wxGetMousePosition();
3126     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
3127
3128
3129
3130     // check for an external move
3131     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3132     {
3133         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
3134
3135         while (tab_ctrl)
3136         {
3137             if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3138                 break;
3139             tab_ctrl = tab_ctrl->GetParent();
3140         }
3141
3142         if (tab_ctrl)
3143         {
3144             wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3145
3146             if (nb != this)
3147             {
3148                 // find out from the destination control
3149                 // if it's ok to drop this tab here
3150                 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
3151                 e.SetSelection(evt.GetSelection());
3152                 e.SetOldSelection(evt.GetSelection());
3153                 e.SetEventObject(this);
3154                 e.SetDragSource(this);
3155                 e.Veto(); // dropping must be explicitly approved by control owner
3156
3157                 nb->GetEventHandler()->ProcessEvent(e);
3158
3159                 if (!e.IsAllowed())
3160                 {
3161                     // no answer or negative answer
3162                     m_mgr.HideHint();
3163                     return;
3164                 }
3165
3166                 // drop was allowed
3167                 int src_idx = evt.GetSelection();
3168                 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
3169
3170                 // get main index of the page
3171                 int main_idx = m_tabs.GetIdxFromWindow(src_page);
3172
3173                 // make a copy of the page info
3174                 wxAuiNotebookPage page_info = m_tabs.GetPage((size_t)main_idx);
3175
3176                 // remove the page from the source notebook
3177                 RemovePage(main_idx);
3178
3179                 // reparent the page
3180                 src_page->Reparent(nb);
3181
3182
3183                 // found out the insert idx
3184                 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
3185                 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3186
3187                 wxWindow* target = NULL;
3188                 int insert_idx = -1;
3189                 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3190                 if (target)
3191                 {
3192                     insert_idx = dest_tabs->GetIdxFromWindow(target);
3193                 }
3194
3195
3196                 // add the page to the new notebook
3197                 if (insert_idx == -1)
3198                     insert_idx = dest_tabs->GetPageCount();
3199                 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3200                 nb->m_tabs.AddPage(page_info.window, page_info);
3201
3202                 nb->DoSizing();
3203                 dest_tabs->DoShowHide();
3204                 dest_tabs->Refresh();
3205
3206                 // set the selection in the destination tab control
3207                 nb->SetSelection(nb->m_tabs.GetIdxFromWindow(page_info.window));
3208
3209                 return;
3210             }
3211         }
3212     }
3213
3214
3215
3216
3217     // only perform a tab split if it's allowed
3218     if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
3219     {
3220         // If the pointer is in an existing tab frame, do a tab insert
3221         wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
3222         wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
3223         int insert_idx = -1;
3224         if (tab_frame)
3225         {
3226             dest_tabs = tab_frame->m_tabs;
3227
3228             if (dest_tabs == src_tabs)
3229                 return;
3230
3231
3232             wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3233             wxWindow* target = NULL;
3234             dest_tabs->TabHitTest(pt.x, pt.y, &target);
3235             if (target)
3236             {
3237                 insert_idx = dest_tabs->GetIdxFromWindow(target);
3238             }
3239         }
3240          else
3241         {
3242             wxPoint zero(0,0);
3243             wxRect rect = m_mgr.CalculateHintRect(m_dummy_wnd,
3244                                                   mouse_client_pt,
3245                                                   zero);
3246             if (rect.IsEmpty())
3247             {
3248                 // there is no suitable drop location here, exit out
3249                 return;
3250             }
3251
3252             // If there is no tabframe at all, create one
3253             wxTabFrame* new_tabs = new wxTabFrame;
3254             new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
3255             new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3256             new_tabs->m_tabs = new wxAuiTabCtrl(this,
3257                                                 m_tab_id_counter++,
3258                                                 wxDefaultPosition,
3259                                                 wxDefaultSize,
3260                                                 wxNO_BORDER);
3261             new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3262             new_tabs->m_tabs->SetFlags(m_flags);
3263
3264             m_mgr.AddPane(new_tabs,
3265                           wxAuiPaneInfo().Bottom().CaptionVisible(false),
3266                           mouse_client_pt);
3267             m_mgr.Update();
3268             dest_tabs = new_tabs->m_tabs;
3269         }
3270
3271
3272
3273         // remove the page from the source tabs
3274         wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
3275         page_info.active = false;
3276         src_tabs->RemovePage(page_info.window);
3277         if (src_tabs->GetPageCount() > 0)
3278         {
3279             src_tabs->SetActivePage((size_t)0);
3280             src_tabs->DoShowHide();
3281             src_tabs->Refresh();
3282         }
3283
3284
3285
3286         // add the page to the destination tabs
3287         if (insert_idx == -1)
3288             insert_idx = dest_tabs->GetPageCount();
3289         dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3290
3291         if (src_tabs->GetPageCount() == 0)
3292         {
3293             RemoveEmptyTabFrames();
3294         }
3295
3296         DoSizing();
3297         dest_tabs->DoShowHide();
3298         dest_tabs->Refresh();
3299
3300         SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
3301
3302         UpdateHintWindowSize();
3303     }
3304 }
3305
3306
3307
3308 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
3309 {
3310     // if we've just removed the last tab from the source
3311     // tab set, the remove the tab control completely
3312     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3313     size_t i, pane_count = all_panes.GetCount();
3314     for (i = 0; i < pane_count; ++i)
3315     {
3316         if (all_panes.Item(i).name == wxT("dummy"))
3317             continue;
3318
3319         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3320         if (tabframe->m_tab_rect.Contains(pt))
3321             return tabframe->m_tabs;
3322     }
3323
3324     return NULL;
3325 }
3326
3327 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
3328 {
3329     // if we've just removed the last tab from the source
3330     // tab set, the remove the tab control completely
3331     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3332     size_t i, pane_count = all_panes.GetCount();
3333     for (i = 0; i < pane_count; ++i)
3334     {
3335         if (all_panes.Item(i).name == wxT("dummy"))
3336             continue;
3337
3338         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3339         if (tabframe->m_tabs == tab_ctrl)
3340         {
3341             return tabframe;
3342         }
3343     }
3344
3345     return NULL;
3346 }
3347
3348 void wxAuiNotebook::RemoveEmptyTabFrames()
3349 {
3350     // if we've just removed the last tab from the source
3351     // tab set, the remove the tab control completely
3352     wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
3353     size_t i, pane_count = all_panes.GetCount();
3354     for (i = 0; i < pane_count; ++i)
3355     {
3356         if (all_panes.Item(i).name == wxT("dummy"))
3357             continue;
3358
3359         wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
3360         if (tab_frame->m_tabs->GetPageCount() == 0)
3361         {
3362             m_mgr.DetachPane(tab_frame);
3363
3364             // use pending delete because sometimes during
3365             // window closing, refreshs are pending
3366             if (!wxPendingDelete.Member(tab_frame->m_tabs))
3367                 wxPendingDelete.Append(tab_frame->m_tabs);
3368             //tab_frame->m_tabs->Destroy();
3369
3370             delete tab_frame;
3371         }
3372     }
3373
3374
3375     // check to see if there is still a center pane;
3376     // if there isn't, make a frame the center pane
3377     wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
3378     pane_count = panes.GetCount();
3379     wxWindow* first_good = NULL;
3380     bool center_found = false;
3381     for (i = 0; i < pane_count; ++i)
3382     {
3383         if (panes.Item(i).name == wxT("dummy"))
3384             continue;
3385         if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
3386             center_found = true;
3387         if (!first_good)
3388             first_good = panes.Item(i).window;
3389     }
3390
3391     if (!center_found && first_good)
3392     {
3393         m_mgr.GetPane(first_good).Centre();
3394     }
3395
3396     m_mgr.Update();
3397 }
3398
3399 void wxAuiNotebook::OnChildFocus(wxChildFocusEvent& evt)
3400 {
3401     int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
3402     if (idx != -1 && idx != m_curpage)
3403     {
3404         SetSelection(idx);
3405     }
3406 }
3407
3408
3409 void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
3410 {
3411     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3412     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3413
3414     int button_id = evt.GetInt();
3415
3416     if (button_id == wxAUI_BUTTON_CLOSE)
3417     {
3418         int selection = tabs->GetActivePage();
3419
3420         if (selection != -1)
3421         {
3422             wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
3423
3424
3425             // ask owner if it's ok to close the tab
3426             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
3427             e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
3428             e.SetOldSelection(evt.GetSelection());
3429             e.SetEventObject(this);
3430             GetEventHandler()->ProcessEvent(e);
3431             if (!e.IsAllowed())
3432                 return;
3433
3434
3435             if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3436             {
3437                 close_wnd->Close();
3438             }
3439              else
3440             {
3441                 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
3442                 DeletePage(main_idx);
3443             }
3444         }
3445     }
3446 }
3447
3448
3449
3450
3451 #endif // wxUSE_AUI