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     m_pressed_button = NULL;
1838 }
1839
1840 wxAuiTabCtrl::~wxAuiTabCtrl()
1841 {
1842 }
1843
1844 void wxAuiTabCtrl::OnPaint(wxPaintEvent&)
1845 {
1846     wxPaintDC dc(this);
1847
1848     dc.SetFont(GetFont());
1849
1850     if (GetPageCount() > 0)
1851         Render(&dc, this);
1852 }
1853
1854 void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
1855 {
1856 }
1857
1858 void wxAuiTabCtrl::OnSize(wxSizeEvent& evt)
1859 {
1860     wxSize s = evt.GetSize();
1861     wxRect r(0, 0, s.GetWidth(), s.GetHeight());
1862     SetRect(r);
1863 }
1864
1865 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
1866 {
1867     CaptureMouse();
1868     m_click_pt = wxDefaultPosition;
1869     m_is_dragging = false;
1870     m_click_tab = NULL;
1871     m_pressed_button = NULL;
1872
1873
1874     wxWindow* wnd;
1875     if (TabHitTest(evt.m_x, evt.m_y, &wnd))
1876     {
1877         wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
1878         e.SetSelection(GetIdxFromWindow(wnd));
1879         e.SetOldSelection(GetActivePage());
1880         e.SetEventObject(this);
1881         GetEventHandler()->ProcessEvent(e);
1882
1883         m_click_pt.x = evt.m_x;
1884         m_click_pt.y = evt.m_y;
1885         m_click_tab = wnd;
1886     }
1887
1888     if (m_hover_button)
1889     {
1890         m_pressed_button = m_hover_button;
1891         m_pressed_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
1892         Refresh();
1893         Update();
1894     }
1895 }
1896
1897 void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
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_pressed_button)
1913     {
1914         // make sure we're still clicking the button
1915         wxAuiTabContainerButton* button = NULL;
1916         if (!ButtonHitTest(evt.m_x, evt.m_y, &button))
1917             return;
1918
1919         if (button != m_pressed_button)
1920         {
1921             m_pressed_button = NULL;
1922             return;
1923         }
1924
1925         Refresh();
1926         Update();
1927
1928         if (!(m_pressed_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
1929         {
1930             wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
1931             evt.SetInt(m_pressed_button->id);
1932             evt.SetEventObject(this);
1933             GetEventHandler()->ProcessEvent(evt);
1934         }
1935
1936         m_pressed_button = NULL;
1937     }
1938
1939     m_click_pt = wxDefaultPosition;
1940     m_is_dragging = false;
1941     m_click_tab = NULL;
1942 }
1943
1944 void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
1945 {
1946     wxPoint pos = evt.GetPosition();
1947
1948     // check if the mouse is hovering above a button
1949     wxAuiTabContainerButton* button;
1950     if (ButtonHitTest(pos.x, pos.y, &button))
1951     {
1952         if (m_hover_button && button != m_hover_button)
1953         {
1954             m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
1955             m_hover_button = NULL;
1956             Refresh();
1957             Update();
1958         }
1959
1960         if (button->cur_state != wxAUI_BUTTON_STATE_HOVER)
1961         {
1962             button->cur_state = wxAUI_BUTTON_STATE_HOVER;
1963             Refresh();
1964             Update();
1965             m_hover_button = button;
1966             return;
1967         }
1968     }
1969      else
1970     {
1971         if (m_hover_button)
1972         {
1973             m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
1974             m_hover_button = NULL;
1975             Refresh();
1976             Update();
1977         }
1978     }
1979
1980
1981     if (!evt.LeftIsDown() || m_click_pt == wxDefaultPosition)
1982         return;
1983
1984     if (m_is_dragging)
1985     {
1986         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
1987         evt.SetSelection(GetIdxFromWindow(m_click_tab));
1988         evt.SetOldSelection(evt.GetSelection());
1989         evt.SetEventObject(this);
1990         GetEventHandler()->ProcessEvent(evt);
1991         return;
1992     }
1993
1994
1995     int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
1996     int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
1997
1998     if (abs(pos.x - m_click_pt.x) > drag_x_threshold ||
1999         abs(pos.y - m_click_pt.y) > drag_y_threshold)
2000     {
2001         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
2002         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2003         evt.SetOldSelection(evt.GetSelection());
2004         evt.SetEventObject(this);
2005         GetEventHandler()->ProcessEvent(evt);
2006
2007         m_is_dragging = true;
2008     }
2009 }
2010
2011 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
2012 {
2013     if (m_hover_button)
2014     {
2015         m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2016         m_hover_button = NULL;
2017         Refresh();
2018         Update();
2019     }
2020 }
2021
2022 void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
2023 {
2024     int button = event.GetInt();
2025
2026     if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
2027     {
2028         if (button == wxAUI_BUTTON_LEFT)
2029         {
2030             if (GetTabOffset() > 0)
2031             {
2032                 SetTabOffset(GetTabOffset()-1);
2033                 Refresh();
2034                 Update();
2035             }
2036         }
2037          else
2038         {
2039             SetTabOffset(GetTabOffset()+1);
2040             Refresh();
2041             Update();
2042         }
2043     }
2044      else if (button == wxAUI_BUTTON_WINDOWLIST)
2045     {
2046         wxArrayString as;
2047
2048         size_t i, page_count = m_pages.GetCount();
2049         for (i = 0; i < page_count; ++i)
2050         {
2051             wxAuiNotebookPage& page = m_pages.Item(i);
2052             as.Add(page.caption);
2053         }
2054
2055         int idx = GetArtProvider()->ShowWindowList(this, as, GetActivePage());
2056
2057         if (idx != -1)
2058         {
2059             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2060             e.SetSelection(idx);
2061             e.SetOldSelection(GetActivePage());
2062             e.SetEventObject(this);
2063             GetEventHandler()->ProcessEvent(e);
2064         }
2065     }
2066      else
2067     {
2068         event.Skip();
2069     }
2070 }
2071
2072 // wxTabFrame is an interesting case.  It's important that all child pages
2073 // of the multi-notebook control are all actually children of that control
2074 // (and not grandchildren).  wxTabFrame facilitates this.  There is one
2075 // instance of wxTabFrame for each tab control inside the multi-notebook.
2076 // It's important to know that wxTabFrame is not a real window, but it merely
2077 // used to capture the dimensions/positioning of the internal tab control and
2078 // it's managed page windows
2079
2080 class wxTabFrame : public wxWindow
2081 {
2082 public:
2083
2084     wxTabFrame()
2085     {
2086         m_tabs = NULL;
2087         m_rect = wxRect(0,0,200,200);
2088         m_tab_ctrl_height = 20;
2089     }
2090
2091     void SetTabCtrlHeight(int h)
2092     {
2093         m_tab_ctrl_height = h;
2094     }
2095
2096     void DoSetSize(int x, int y,
2097                    int width, int height,
2098                    int WXUNUSED(sizeFlags = wxSIZE_AUTO))
2099     {
2100         m_rect = wxRect(x, y, width, height);
2101         DoSizing();
2102     }
2103
2104     void DoGetClientSize(int* x, int* y) const
2105     {
2106         *x = m_rect.width;
2107         *y = m_rect.height;
2108     }
2109
2110     bool Show( bool WXUNUSED(show = true) ) { return false; }
2111
2112     void DoSizing()
2113     {
2114         if (!m_tabs)
2115             return;
2116
2117         m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2118         m_tabs->SetSize(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2119         m_tabs->SetRect(wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
2120         m_tabs->Refresh();
2121         m_tabs->Update();
2122
2123         wxAuiNotebookPageArray& pages = m_tabs->GetPages();
2124         size_t i, page_count = pages.GetCount();
2125
2126         for (i = 0; i < page_count; ++i)
2127         {
2128             wxAuiNotebookPage& page = pages.Item(i);
2129             page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
2130                                  m_rect.width, m_rect.height - m_tab_ctrl_height);
2131
2132             if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2133             {
2134                 wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
2135                 wnd->ApplyMDIChildFrameRect();
2136             }
2137         }
2138     }
2139
2140     void DoGetSize(int* x, int* y) const
2141     {
2142         if (x)
2143             *x = m_rect.GetWidth();
2144         if (y)
2145             *y = m_rect.GetHeight();
2146     }
2147
2148     void Update()
2149     {
2150         // does nothing
2151     }
2152
2153 public:
2154
2155     wxRect m_rect;
2156     wxRect m_tab_rect;
2157     wxAuiTabCtrl* m_tabs;
2158     int m_tab_ctrl_height;
2159 };
2160
2161
2162
2163
2164
2165 // -- wxAuiNotebook class implementation --
2166
2167 BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
2168     //EVT_ERASE_BACKGROUND(wxAuiNotebook::OnEraseBackground)
2169     //EVT_SIZE(wxAuiNotebook::OnSize)
2170     //EVT_LEFT_DOWN(wxAuiNotebook::OnLeftDown)
2171     EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus)
2172     EVT_COMMAND_RANGE(10000, 10100,
2173                       wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
2174                       wxAuiNotebook::OnTabClicked)
2175     EVT_COMMAND_RANGE(10000, 10100,
2176                       wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
2177                       wxAuiNotebook::OnTabBeginDrag)
2178     EVT_COMMAND_RANGE(10000, 10100,
2179                       wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
2180                       wxAuiNotebook::OnTabEndDrag)
2181     EVT_COMMAND_RANGE(10000, 10100,
2182                       wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
2183                       wxAuiNotebook::OnTabDragMotion)
2184     EVT_COMMAND_RANGE(10000, 10100,
2185                       wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
2186                       wxAuiNotebook::OnTabButton)
2187 END_EVENT_TABLE()
2188
2189 wxAuiNotebook::wxAuiNotebook()
2190 {
2191     m_curpage = -1;
2192     m_tab_id_counter = 10000;
2193     m_dummy_wnd = NULL;
2194     m_tab_ctrl_height = 20;
2195 }
2196
2197 wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
2198                              wxWindowID id,
2199                              const wxPoint& pos,
2200                              const wxSize& size,
2201                              long style) : wxControl(parent, id, pos, size, style)
2202 {
2203     InitNotebook(style);
2204 }
2205
2206 bool wxAuiNotebook::Create(wxWindow* parent,
2207                            wxWindowID id,
2208                            const wxPoint& pos,
2209                            const wxSize& size,
2210                            long style)
2211 {
2212     if (!wxControl::Create(parent, id, pos, size, style))
2213         return false;
2214
2215     InitNotebook(style);
2216
2217     return true;
2218 }
2219
2220 // InitNotebook() contains common initialization
2221 // code called by all constructors
2222 void wxAuiNotebook::InitNotebook(long style)
2223 {
2224     m_curpage = -1;
2225     m_tab_id_counter = 10000;
2226     m_dummy_wnd = NULL;
2227     m_tab_ctrl_height = 20;
2228     m_flags = (unsigned int)style;
2229
2230     m_normal_font = *wxNORMAL_FONT;
2231     m_selected_font = *wxNORMAL_FONT;
2232     m_selected_font.SetWeight(wxBOLD);
2233
2234     SetArtProvider(new wxAuiDefaultTabArt);
2235
2236     m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
2237     m_dummy_wnd->SetSize(200, 200);
2238     m_dummy_wnd->Show(false);
2239
2240     m_mgr.SetManagedWindow(this);
2241
2242     m_mgr.AddPane(m_dummy_wnd,
2243               wxAuiPaneInfo().Name(wxT("dummy")).Bottom().Show(false));
2244
2245     m_mgr.Update();
2246 }
2247
2248 wxAuiNotebook::~wxAuiNotebook()
2249 {
2250     m_mgr.UnInit();
2251 }
2252
2253 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
2254 {
2255     m_tabs.SetArtProvider(art);
2256
2257     // choose a default for the tab height
2258     m_tab_ctrl_height = art->GetBestTabCtrlSize(this);
2259
2260     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2261     size_t i, pane_count = all_panes.GetCount();
2262     for (i = 0; i < pane_count; ++i)
2263     {
2264         wxAuiPaneInfo& pane = all_panes.Item(i);
2265         if (pane.name == wxT("dummy"))
2266             continue;
2267         wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
2268         wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
2269         tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
2270         tabctrl->SetArtProvider(art->Clone());
2271         tab_frame->DoSizing();
2272     }
2273
2274 }
2275
2276 wxAuiTabArt* wxAuiNotebook::GetArtProvider()
2277 {
2278     return m_tabs.GetArtProvider();
2279 }
2280
2281 void wxAuiNotebook::SetWindowStyleFlag(long style)
2282 {
2283     wxControl::SetWindowStyleFlag(style);
2284
2285     m_flags = (unsigned int)style;
2286
2287     // if the control is already initialized
2288     if (m_mgr.GetManagedWindow() == (wxWindow*)this)
2289     {
2290         // let all of the tab children know about the new style
2291
2292         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2293         size_t i, pane_count = all_panes.GetCount();
2294         for (i = 0; i < pane_count; ++i)
2295         {
2296             wxAuiPaneInfo& pane = all_panes.Item(i);
2297             if (pane.name == wxT("dummy"))
2298                 continue;
2299             wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
2300             tabctrl->SetFlags(m_flags);
2301             tabctrl->Refresh();
2302             tabctrl->Update();
2303         }
2304     }
2305 }
2306
2307
2308 bool wxAuiNotebook::AddPage(wxWindow* page,
2309                             const wxString& caption,
2310                             bool select,
2311                             const wxBitmap& bitmap)
2312 {
2313     return InsertPage(GetPageCount(), page, caption, select, bitmap);
2314 }
2315
2316 bool wxAuiNotebook::InsertPage(size_t page_idx,
2317                                wxWindow* page,
2318                                const wxString& caption,
2319                                bool select,
2320                                const wxBitmap& bitmap)
2321 {
2322     wxAuiNotebookPage info;
2323     info.window = page;
2324     info.caption = caption;
2325     info.bitmap = bitmap;
2326     info.active = false;
2327
2328     // if there are currently no tabs, the first added
2329     // tab must be active
2330     if (m_tabs.GetPageCount() == 0)
2331         info.active = true;
2332
2333     m_tabs.InsertPage(page, info, page_idx);
2334
2335     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
2336     if (page_idx >= active_tabctrl->GetPageCount())
2337         active_tabctrl->AddPage(page, info);
2338          else
2339         active_tabctrl->InsertPage(page, info, page_idx);
2340
2341     DoSizing();
2342     active_tabctrl->DoShowHide();
2343
2344     if (select)
2345     {
2346         int idx = m_tabs.GetIdxFromWindow(page);
2347         wxASSERT_MSG(idx != -1, wxT("Invalid Page index returned on wxAuiNotebook::InsertPage()"));
2348
2349         SetSelection(idx);
2350     }
2351
2352     return true;
2353 }
2354
2355
2356 // DeletePage() removes a tab from the multi-notebook,
2357 // and destroys the window as well
2358 bool wxAuiNotebook::DeletePage(size_t page_idx)
2359 {
2360     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2361
2362     if (!RemovePage(page_idx))
2363         return false;
2364
2365
2366     // actually destroy the window now
2367     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2368     {
2369         // delete the child frame with pending delete, as is
2370         // customary with frame windows
2371         if (!wxPendingDelete.Member(wnd))
2372             wxPendingDelete.Append(wnd);
2373     }
2374      else
2375     {
2376         wnd->Destroy();
2377     }
2378
2379     return true;
2380 }
2381
2382
2383
2384 // RemovePage() removes a tab from the multi-notebook,
2385 // but does not destroy the window
2386 bool wxAuiNotebook::RemovePage(size_t page_idx)
2387 {
2388     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2389     wxWindow* new_active = NULL;
2390
2391     // find out which onscreen tab ctrl owns this tab
2392     wxAuiTabCtrl* ctrl;
2393     int ctrl_idx;
2394     if (!FindTab(wnd, &ctrl, &ctrl_idx))
2395         return false;
2396
2397     // find a new page and set it as active
2398     int new_idx = ctrl_idx+1;
2399     if (new_idx >= (int)ctrl->GetPageCount())
2400         new_idx = ctrl_idx-1;
2401
2402     if (new_idx >= 0 && new_idx < (int)ctrl->GetPageCount())
2403     {
2404         new_active = ctrl->GetWindowFromIdx(new_idx);
2405     }
2406      else
2407     {
2408         // set the active page to the first page that
2409         // isn't the one being deleted
2410         size_t i, page_count = m_tabs.GetPageCount();
2411         for (i = 0; i < page_count; ++i)
2412         {
2413             wxWindow* w = m_tabs.GetWindowFromIdx(i);
2414             if (wnd != w)
2415             {
2416                 new_active = m_tabs.GetWindowFromIdx(i);
2417                 break;
2418             }
2419         }
2420     }
2421
2422     // remove the tab from main catalog
2423     if (!m_tabs.RemovePage(wnd))
2424         return false;
2425
2426     // remove the tab from the onscreen tab ctrl
2427     ctrl->RemovePage(wnd);
2428
2429
2430     RemoveEmptyTabFrames();
2431
2432     // set new active pane
2433     if (new_active)
2434     {
2435         m_curpage = -1;
2436         SetSelection(m_tabs.GetIdxFromWindow(new_active));
2437     }
2438
2439     return true;
2440 }
2441
2442 // SetPageText() changes the tab caption of the specified page
2443 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
2444 {
2445     if (page_idx >= m_tabs.GetPageCount())
2446         return false;
2447
2448     // update our own tab catalog
2449     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2450     page_info.caption = text;
2451
2452     // update what's on screen
2453     wxAuiTabCtrl* ctrl;
2454     int ctrl_idx;
2455     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2456     {
2457         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2458         info.caption = text;
2459         ctrl->Refresh();
2460         ctrl->Update();
2461     }
2462
2463     return true;
2464 }
2465
2466 // GetSelection() returns the index of the currently active page
2467 int wxAuiNotebook::GetSelection() const
2468 {
2469     return m_curpage;
2470 }
2471
2472 // SetSelection() sets the currently active page
2473 size_t wxAuiNotebook::SetSelection(size_t new_page)
2474 {
2475     wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
2476     if (!wnd)
2477         return m_curpage;
2478
2479     wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2480     evt.SetSelection(new_page);
2481     evt.SetOldSelection(m_curpage);
2482     evt.SetEventObject(this);
2483     if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
2484     {
2485         // program allows the page change
2486         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
2487         (void)GetEventHandler()->ProcessEvent(evt);
2488
2489
2490
2491         wxAuiTabCtrl* ctrl;
2492         int ctrl_idx;
2493         if (FindTab(wnd, &ctrl, &ctrl_idx))
2494         {
2495             m_tabs.SetActivePage(wnd);
2496
2497             ctrl->SetActivePage(ctrl_idx);
2498             DoSizing();
2499             ctrl->DoShowHide();
2500
2501             int old_curpage = m_curpage;
2502             m_curpage = new_page;
2503
2504
2505             // set fonts
2506             wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2507             size_t i, pane_count = all_panes.GetCount();
2508             for (i = 0; i < pane_count; ++i)
2509             {
2510                 wxAuiPaneInfo& pane = all_panes.Item(i);
2511                 if (pane.name == wxT("dummy"))
2512                     continue;
2513                 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
2514                 if (tabctrl != ctrl)
2515                     tabctrl->SetSelectedFont(m_normal_font);
2516                      else
2517                     tabctrl->SetSelectedFont(m_selected_font);
2518                 tabctrl->Refresh();
2519             }
2520
2521             wnd->SetFocus();
2522
2523             return old_curpage;
2524         }
2525     }
2526
2527     return m_curpage;
2528 }
2529
2530 // GetPageCount() returns the total number of
2531 // pages managed by the multi-notebook
2532 size_t wxAuiNotebook::GetPageCount() const
2533 {
2534     return m_tabs.GetPageCount();
2535 }
2536
2537 // GetPage() returns the wxWindow pointer of the
2538 // specified page
2539 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
2540 {
2541     wxASSERT(page_idx < m_tabs.GetPageCount());
2542
2543     return m_tabs.GetWindowFromIdx(page_idx);
2544 }
2545
2546 // DoSizing() performs all sizing operations in each tab control
2547 void wxAuiNotebook::DoSizing()
2548 {
2549     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2550     size_t i, pane_count = all_panes.GetCount();
2551     for (i = 0; i < pane_count; ++i)
2552     {
2553         if (all_panes.Item(i).name == wxT("dummy"))
2554             continue;
2555
2556         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2557         tabframe->DoSizing();
2558     }
2559 }
2560
2561 // GetActiveTabCtrl() returns the active tab control.  It is
2562 // called to determine which control gets new windows being added
2563 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
2564 {
2565     if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
2566     {
2567         wxAuiTabCtrl* ctrl;
2568         int idx;
2569
2570         // find the tab ctrl with the current page
2571         if (FindTab(m_tabs.GetPage(m_curpage).window,
2572                     &ctrl, &idx))
2573         {
2574             return ctrl;
2575         }
2576     }
2577
2578     // no current page, just find the first tab ctrl
2579     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2580     size_t i, pane_count = all_panes.GetCount();
2581     for (i = 0; i < pane_count; ++i)
2582     {
2583         if (all_panes.Item(i).name == wxT("dummy"))
2584             continue;
2585
2586         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2587         return tabframe->m_tabs;
2588     }
2589
2590     // If there is no tabframe at all, create one
2591     wxTabFrame* tabframe = new wxTabFrame;
2592     tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
2593     tabframe->m_tabs = new wxAuiTabCtrl(this,
2594                                         m_tab_id_counter++,
2595                                         wxDefaultPosition,
2596                                         wxDefaultSize,
2597                                         wxNO_BORDER);
2598     tabframe->m_tabs->SetFlags(m_flags);
2599     tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2600     m_mgr.AddPane(tabframe,
2601                   wxAuiPaneInfo().Center().CaptionVisible(false));
2602
2603     m_mgr.Update();
2604
2605     return tabframe->m_tabs;
2606 }
2607
2608 // FindTab() finds the tab control that currently contains the window as well
2609 // as the index of the window in the tab control.  It returns true if the
2610 // window was found, otherwise false.
2611 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
2612 {
2613     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2614     size_t i, pane_count = all_panes.GetCount();
2615     for (i = 0; i < pane_count; ++i)
2616     {
2617         if (all_panes.Item(i).name == wxT("dummy"))
2618             continue;
2619
2620         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2621
2622         int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
2623         if (page_idx != -1)
2624         {
2625             *ctrl = tabframe->m_tabs;
2626             *idx = page_idx;
2627             return true;
2628         }
2629     }
2630
2631     return false;
2632 }
2633
2634
2635 void wxAuiNotebook::OnEraseBackground(wxEraseEvent&)
2636 {
2637 }
2638
2639 void wxAuiNotebook::OnSize(wxSizeEvent&)
2640 {
2641 }
2642
2643 void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
2644 {
2645     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
2646
2647     wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
2648     wxASSERT(ctrl != NULL);
2649
2650     wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
2651     wxASSERT(wnd != NULL);
2652
2653     int idx = m_tabs.GetIdxFromWindow(wnd);
2654     wxASSERT(idx != -1);
2655
2656     SetSelection(idx);
2657 }
2658
2659 void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
2660 {
2661     m_last_drag_x = 0;
2662 }
2663
2664 void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
2665 {
2666     wxPoint screen_pt = ::wxGetMousePosition();
2667     wxPoint client_pt = ScreenToClient(screen_pt);
2668     wxPoint zero(0,0);
2669
2670     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2671     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
2672
2673     if (dest_tabs == src_tabs)
2674     {
2675         if (src_tabs)
2676         {
2677             src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
2678         }
2679
2680         // always hide the hint for inner-tabctrl drag
2681         m_mgr.HideHint();
2682
2683         // if tab moving is not allowed, leave
2684         if (!(m_flags & wxAUI_NB_TAB_MOVE))
2685         {
2686             return;
2687         }
2688
2689         wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
2690         wxWindow* dest_location_tab;
2691
2692         // this is an inner-tab drag/reposition
2693         if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
2694         {
2695             int src_idx = evt.GetSelection();
2696             int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
2697
2698             // prevent jumpy drag
2699             if ((src_idx == dest_idx) || dest_idx == -1 ||
2700                 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
2701                 (src_idx < dest_idx && m_last_drag_x >= pt.x))
2702             {
2703                 m_last_drag_x = pt.x;
2704                 return;
2705             }
2706
2707
2708             wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
2709             dest_tabs->MovePage(src_tab, dest_idx);
2710             dest_tabs->SetActivePage((size_t)dest_idx);
2711             dest_tabs->DoShowHide();
2712             dest_tabs->Refresh();
2713             m_last_drag_x = pt.x;
2714
2715         }
2716
2717         return;
2718     }
2719
2720
2721     // if external drag is allowed, check if the tab is being dragged
2722     // over a different wxAuiNotebook control
2723     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
2724     {
2725         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
2726
2727         // make sure we are not over the hint window
2728         if (tab_ctrl && !tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
2729         {
2730             while (tab_ctrl)
2731             {
2732                 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
2733                     break;
2734                 tab_ctrl = tab_ctrl->GetParent();
2735             }
2736
2737             if (tab_ctrl)
2738             {
2739                 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
2740
2741                 if (nb != this)
2742                 {
2743                     wxRect hint_rect = tab_ctrl->GetRect();
2744                     tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
2745                     m_mgr.ShowHint(hint_rect);
2746                     return;
2747                 }
2748
2749             }
2750         }
2751     }
2752
2753
2754     // if there are less than two panes, split can't happen, so leave
2755     if (m_tabs.GetPageCount() < 2)
2756         return;
2757
2758     // if tab moving is not allowed, leave
2759     if (!(m_flags & wxAUI_NB_TAB_SPLIT))
2760         return;
2761
2762
2763     if (src_tabs)
2764     {
2765         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
2766     }
2767
2768
2769     if (dest_tabs)
2770     {
2771         wxRect hint_rect = dest_tabs->GetRect();
2772         ClientToScreen(&hint_rect.x, &hint_rect.y);
2773         m_mgr.ShowHint(hint_rect);
2774     }
2775      else
2776     {
2777         m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
2778     }
2779 }
2780
2781
2782
2783 void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
2784 {
2785     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
2786
2787     m_mgr.HideHint();
2788
2789
2790     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2791     wxAuiTabCtrl* dest_tabs = NULL;
2792     if (src_tabs)
2793     {
2794         // set cursor back to an arrow
2795         src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
2796     }
2797
2798     // get the mouse position, which will be used to determine the drop point
2799     wxPoint mouse_screen_pt = ::wxGetMousePosition();
2800     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
2801
2802
2803
2804     // check for an external move
2805     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
2806     {
2807         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
2808
2809         while (tab_ctrl)
2810         {
2811             if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
2812                 break;
2813             tab_ctrl = tab_ctrl->GetParent();
2814         }
2815
2816         if (tab_ctrl)
2817         {
2818             wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
2819
2820             if (nb != this)
2821             {
2822                 // find out from the destination control
2823                 // if it's ok to drop this tab here
2824                 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
2825                 e.SetSelection(evt.GetSelection());
2826                 e.SetOldSelection(evt.GetSelection());
2827                 e.SetEventObject(this);
2828                 e.SetDragSource(this);
2829                 e.Veto(); // dropping must be explicitly approved by control owner
2830
2831                 nb->GetEventHandler()->ProcessEvent(e);
2832
2833                 if (!e.IsAllowed())
2834                 {
2835                     // no answer or negative answer
2836                     m_mgr.HideHint();
2837                     return;
2838                 }
2839
2840                 // drop was allowed
2841                 int src_idx = evt.GetSelection();
2842                 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
2843
2844                 // get main index of the page
2845                 int main_idx = m_tabs.GetIdxFromWindow(src_page);
2846
2847                 // make a copy of the page info
2848                 wxAuiNotebookPage page_info = m_tabs.GetPage((size_t)main_idx);
2849
2850                 // remove the page from the source notebook
2851                 RemovePage(main_idx);
2852
2853                 // reparent the page
2854                 src_page->Reparent(nb);
2855
2856
2857                 // found out the insert idx
2858                 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
2859                 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
2860
2861                 wxWindow* target = NULL;
2862                 int insert_idx = -1;
2863                 dest_tabs->TabHitTest(pt.x, pt.y, &target);
2864                 if (target)
2865                 {
2866                     insert_idx = dest_tabs->GetIdxFromWindow(target);
2867                 }
2868
2869
2870                 // add the page to the new notebook
2871                 if (insert_idx == -1)
2872                     insert_idx = dest_tabs->GetPageCount();
2873                 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
2874                 nb->m_tabs.AddPage(page_info.window, page_info);
2875
2876                 nb->DoSizing();
2877                 dest_tabs->DoShowHide();
2878                 dest_tabs->Refresh();
2879
2880                 // set the selection in the destination tab control
2881                 nb->SetSelection(nb->m_tabs.GetIdxFromWindow(page_info.window));
2882
2883                 return;
2884             }
2885         }
2886     }
2887
2888
2889
2890
2891     // only perform a tab split if it's allowed
2892     if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
2893     {
2894         // If the pointer is in an existing tab frame, do a tab insert
2895         wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
2896         wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
2897         int insert_idx = -1;
2898         if (tab_frame)
2899         {
2900             dest_tabs = tab_frame->m_tabs;
2901
2902             if (dest_tabs == src_tabs)
2903                 return;
2904
2905
2906             wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
2907             wxWindow* target = NULL;
2908             dest_tabs->TabHitTest(pt.x, pt.y, &target);
2909             if (target)
2910             {
2911                 insert_idx = dest_tabs->GetIdxFromWindow(target);
2912             }
2913         }
2914          else
2915         {
2916             // If there is no tabframe at all, create one
2917             wxTabFrame* new_tabs = new wxTabFrame;
2918             new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
2919             new_tabs->m_tabs = new wxAuiTabCtrl(this,
2920                                                 m_tab_id_counter++,
2921                                                 wxDefaultPosition,
2922                                                 wxDefaultSize,
2923                                                 wxNO_BORDER);
2924             new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2925             new_tabs->m_tabs->SetFlags(m_flags);
2926
2927             m_mgr.AddPane(new_tabs,
2928                           wxAuiPaneInfo().Bottom().CaptionVisible(false),
2929                           mouse_client_pt);
2930             m_mgr.Update();
2931             dest_tabs = new_tabs->m_tabs;
2932         }
2933
2934
2935
2936         // remove the page from the source tabs
2937         wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
2938         page_info.active = false;
2939         src_tabs->RemovePage(page_info.window);
2940         if (src_tabs->GetPageCount() > 0)
2941         {
2942             src_tabs->SetActivePage((size_t)0);
2943             src_tabs->DoShowHide();
2944             src_tabs->Refresh();
2945         }
2946
2947
2948
2949         // add the page to the destination tabs
2950         if (insert_idx == -1)
2951             insert_idx = dest_tabs->GetPageCount();
2952         dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
2953
2954         if (src_tabs->GetPageCount() == 0)
2955         {
2956             RemoveEmptyTabFrames();
2957         }
2958
2959         DoSizing();
2960         dest_tabs->DoShowHide();
2961         dest_tabs->Refresh();
2962
2963         SetSelection(m_tabs.GetIdxFromWindow(page_info.window));
2964     }
2965 }
2966
2967
2968
2969 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
2970 {
2971     // if we've just removed the last tab from the source
2972     // tab set, the remove the tab control completely
2973     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2974     size_t i, pane_count = all_panes.GetCount();
2975     for (i = 0; i < pane_count; ++i)
2976     {
2977         if (all_panes.Item(i).name == wxT("dummy"))
2978             continue;
2979
2980         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2981         if (tabframe->m_tab_rect.Contains(pt))
2982             return tabframe->m_tabs;
2983     }
2984
2985     return NULL;
2986 }
2987
2988 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
2989 {
2990     // if we've just removed the last tab from the source
2991     // tab set, the remove the tab control completely
2992     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2993     size_t i, pane_count = all_panes.GetCount();
2994     for (i = 0; i < pane_count; ++i)
2995     {
2996         if (all_panes.Item(i).name == wxT("dummy"))
2997             continue;
2998
2999         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3000         if (tabframe->m_tabs == tab_ctrl)
3001         {
3002             return tabframe;
3003         }
3004     }
3005
3006     return NULL;
3007 }
3008
3009 void wxAuiNotebook::RemoveEmptyTabFrames()
3010 {
3011     // if we've just removed the last tab from the source
3012     // tab set, the remove the tab control completely
3013     wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
3014     size_t i, pane_count = all_panes.GetCount();
3015     for (i = 0; i < pane_count; ++i)
3016     {
3017         if (all_panes.Item(i).name == wxT("dummy"))
3018             continue;
3019
3020         wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
3021         if (tab_frame->m_tabs->GetPageCount() == 0)
3022         {
3023             m_mgr.DetachPane(tab_frame);
3024
3025             // use pending delete because sometimes during
3026             // window closing, refreshs are pending
3027             if (!wxPendingDelete.Member(tab_frame->m_tabs))
3028                 wxPendingDelete.Append(tab_frame->m_tabs);
3029             //tab_frame->m_tabs->Destroy();
3030
3031             delete tab_frame;
3032         }
3033     }
3034
3035
3036     // check to see if there is still a center pane;
3037     // if there isn't, make a frame the center pane
3038     wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
3039     pane_count = panes.GetCount();
3040     wxWindow* first_good = NULL;
3041     bool center_found = false;
3042     for (i = 0; i < pane_count; ++i)
3043     {
3044         if (panes.Item(i).name == wxT("dummy"))
3045             continue;
3046         if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
3047             center_found = true;
3048         if (!first_good)
3049             first_good = panes.Item(i).window;
3050     }
3051
3052     if (!center_found && first_good)
3053     {
3054         m_mgr.GetPane(first_good).Centre();
3055     }
3056
3057     m_mgr.Update();
3058 }
3059
3060 void wxAuiNotebook::OnChildFocus(wxChildFocusEvent& evt)
3061 {
3062     int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
3063     if (idx != -1 && idx != m_curpage)
3064     {
3065         SetSelection(idx);
3066     }
3067 }
3068
3069
3070 void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
3071 {
3072     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3073     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3074
3075     int button_id = evt.GetInt();
3076
3077     if (button_id == wxAUI_BUTTON_CLOSE)
3078     {
3079         int selection = tabs->GetActivePage();
3080
3081         if (selection != -1)
3082         {
3083             wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
3084
3085
3086             // ask owner if it's ok to close the tab
3087             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
3088             e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
3089             e.SetOldSelection(evt.GetSelection());
3090             e.SetEventObject(this);
3091             GetEventHandler()->ProcessEvent(e);
3092             if (!e.IsAllowed())
3093                 return;
3094
3095
3096             if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3097             {
3098                 close_wnd->Close();
3099             }
3100              else
3101             {
3102                 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
3103                 DeletePage(main_idx);
3104             }
3105         }
3106     }
3107 }
3108
3109
3110
3111
3112 #endif // wxUSE_AUI