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