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