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     #include "wx/menu.h"
  29 #endif
  30
  31 #include "wx/aui/tabmdi.h"
  32 #include "wx/dcbuffer.h"
  33
  34 #include "wx/renderer.h"
  35
  36 #ifdef __WXMAC__
  37 #include "wx/osx/private.h"
  38 #endif
  39
  40 #include "wx/arrimpl.cpp"
  41 WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray)
  42 WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray)
  43
  44 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, wxAuiNotebookEvent);
  45 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, wxAuiNotebookEvent);
  46 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, wxAuiNotebookEvent);
  47 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, wxAuiNotebookEvent);
  48 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, wxAuiNotebookEvent);
  49 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, wxAuiNotebookEvent);
  50 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, wxAuiNotebookEvent);
  51 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, wxAuiNotebookEvent);
  52 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, wxAuiNotebookEvent);
  53 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, wxAuiNotebookEvent);
  54 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, wxAuiNotebookEvent);
  55 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, wxAuiNotebookEvent);
  56 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, wxAuiNotebookEvent);
  57 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, wxAuiNotebookEvent);
  58 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, wxAuiNotebookEvent);
  59
  60 IMPLEMENT_CLASS(wxAuiNotebook, wxControl)
  61 IMPLEMENT_CLASS(wxAuiTabCtrl, wxControl)
  62 IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxEvent)
  63
  64
  65
  66
  67
  68 // these functions live in dockart.cpp -- they'll eventually
  69 // be moved to a new utility cpp file
  70
  71 wxColor wxAuiStepColour(const wxColor& c, int percent);
  72
  73 wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
  74                              const wxColour& color);
  75
  76 wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size);
  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(wxAuiStepColour(bkcolour, 120)));
  96         dc.SetPen(wxPen(wxAuiStepColour(bkcolour, 75)));
  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
 116
 117 // -- GUI helper classes and functions --
 118
 119 class wxAuiCommandCapture : public wxEvtHandler
 120 {
 121 public:
 122
 123     wxAuiCommandCapture() { m_last_id = 0; }
 124     int GetCommandId() const { return m_last_id; }
 125
 126     bool ProcessEvent(wxEvent& evt)
 127     {
 128         if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
 129         {
 130             m_last_id = evt.GetId();
 131             return true;
 132         }
 133
 134         if (GetNextHandler())
 135             return GetNextHandler()->ProcessEvent(evt);
 136
 137         return false;
 138     }
 139
 140 private:
 141     int m_last_id;
 142 };
 143
 144
 145 // -- bitmaps --
 146
 147 #if defined( __WXMAC__ )
 148  static const unsigned char close_bits[]={
 149      0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
 150      0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
 151      0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
 152 #elif defined( __WXGTK__)
 153  static const unsigned char close_bits[]={
 154      0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
 155      0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
 156      0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
 157 #else
 158  static const unsigned char close_bits[]={
 159      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
 160      0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
 161      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 162 #endif
 163
 164 static const unsigned char left_bits[] = {
 165    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe,
 166    0x1f, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x3f, 0xfe, 0x7f, 0xfe, 0xff, 0xfe,
 167    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 168
 169 static const unsigned char right_bits[] = {
 170    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9f, 0xff, 0x1f, 0xff,
 171    0x1f, 0xfe, 0x1f, 0xfc, 0x1f, 0xfe, 0x1f, 0xff, 0x9f, 0xff, 0xdf, 0xff,
 172    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 173
 174 static const unsigned char list_bits[] = {
 175    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 176    0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
 177    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 178
 179
 180
 181
 182
 183
 184 // -- wxAuiDefaultTabArt class implementation --
 185
 186 wxAuiDefaultTabArt::wxAuiDefaultTabArt()
 187 {
 188     m_normal_font = *wxNORMAL_FONT;
 189     m_selected_font = *wxNORMAL_FONT;
 190     m_selected_font.SetWeight(wxBOLD);
 191     m_measuring_font = m_selected_font;
 192
 193     m_fixed_tab_width = 100;
 194     m_tab_ctrl_height = 0;
 195
 196 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
 197     wxColor base_colour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
 198 #else
 199     wxColor base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 200 #endif
 201
 202     // the base_colour is too pale to use as our base colour,
 203     // so darken it a bit --
 204     if ((255-base_colour.Red()) +
 205         (255-base_colour.Green()) +
 206         (255-base_colour.Blue()) < 60)
 207     {
 208         base_colour = wxAuiStepColour(base_colour, 92);
 209     }
 210
 211     m_base_colour = base_colour;
 212     wxColor border_colour = wxAuiStepColour(base_colour, 75);
 213
 214     m_border_pen = wxPen(border_colour);
 215     m_base_colour_pen = wxPen(m_base_colour);
 216     m_base_colour_brush = wxBrush(m_base_colour);
 217
 218     m_active_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
 219     m_disabled_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
 220
 221     m_active_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
 222     m_disabled_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
 223
 224     m_active_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
 225     m_disabled_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
 226
 227     m_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
 228     m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
 229
 230     m_flags = 0;
 231 }
 232
 233 wxAuiDefaultTabArt::~wxAuiDefaultTabArt()
 234 {
 235 }
 236
 237 wxAuiTabArt* wxAuiDefaultTabArt::Clone()
 238 {
 239     wxAuiDefaultTabArt* art = new wxAuiDefaultTabArt;
 240     art->SetNormalFont(m_normal_font);
 241     art->SetSelectedFont(m_selected_font);
 242     art->SetMeasuringFont(m_measuring_font);
 243
 244     return art;
 245 }
 246
 247 void wxAuiDefaultTabArt::SetFlags(unsigned int flags)
 248 {
 249     m_flags = flags;
 250 }
 251
 252 void wxAuiDefaultTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
 253                                        size_t tab_count)
 254 {
 255     m_fixed_tab_width = 100;
 256
 257     int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
 258
 259     if (m_flags & wxAUI_NB_CLOSE_BUTTON)
 260         tot_width -= m_active_close_bmp.GetWidth();
 261     if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
 262         tot_width -= m_active_windowlist_bmp.GetWidth();
 263
 264     if (tab_count > 0)
 265     {
 266         m_fixed_tab_width = tot_width/(int)tab_count;
 267     }
 268
 269
 270     if (m_fixed_tab_width < 100)
 271         m_fixed_tab_width = 100;
 272
 273     if (m_fixed_tab_width > tot_width/2)
 274         m_fixed_tab_width = tot_width/2;
 275
 276     if (m_fixed_tab_width > 220)
 277         m_fixed_tab_width = 220;
 278
 279     m_tab_ctrl_height = tab_ctrl_size.y;
 280 }
 281
 282
 283 void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
 284                                         wxWindow* WXUNUSED(wnd),
 285                                         const wxRect& rect)
 286 {
 287     // draw background
 288
 289     wxColor top_color       = wxAuiStepColour(m_base_colour, 90);
 290     wxColor bottom_color   = wxAuiStepColour(m_base_colour, 170);
 291     wxRect r;
 292
 293    if (m_flags &wxAUI_NB_BOTTOM)
 294        r = wxRect(rect.x, rect.y, rect.width+2, rect.height);
 295    // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
 296    // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
 297    else //for wxAUI_NB_TOP
 298        r = wxRect(rect.x, rect.y, rect.width+2, rect.height-3);
 299
 300     dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
 301
 302
 303    // draw base lines
 304
 305    dc.SetPen(m_border_pen);
 306    int y = rect.GetHeight();
 307    int w = rect.GetWidth();
 308
 309    if (m_flags &wxAUI_NB_BOTTOM)
 310    {
 311        dc.SetBrush(wxBrush(bottom_color));
 312        dc.DrawRectangle(-1, 0, w+2, 4);
 313    }
 314    // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
 315    // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
 316    else //for wxAUI_NB_TOP
 317    {
 318        dc.SetBrush(m_base_colour_brush);
 319        dc.DrawRectangle(-1, y-4, w+2, 4);
 320    }
 321 }
 322
 323
 324 // DrawTab() draws an individual tab.
 325 //
 326 // dc       - output dc
 327 // in_rect  - rectangle the tab should be confined to
 328 // caption  - tab's caption
 329 // active   - whether or not the tab is active
 330 // out_rect - actual output rectangle
 331 // x_extent - the advance x; where the next tab should start
 332
 333 void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
 334                                  wxWindow* wnd,
 335                                  const wxAuiNotebookPage& page,
 336                                  const wxRect& in_rect,
 337                                  int close_button_state,
 338                                  wxRect* out_tab_rect,
 339                                  wxRect* out_button_rect,
 340                                  int* x_extent)
 341 {
 342     wxCoord normal_textx, normal_texty;
 343     wxCoord selected_textx, selected_texty;
 344     wxCoord texty;
 345
 346     // if the caption is empty, measure some temporary text
 347     wxString caption = page.caption;
 348     if (caption.empty())
 349         caption = wxT("Xj");
 350
 351     dc.SetFont(m_selected_font);
 352     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
 353
 354     dc.SetFont(m_normal_font);
 355     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
 356
 357     // figure out the size of the tab
 358     wxSize tab_size = GetTabSize(dc,
 359                                  wnd,
 360                                  page.caption,
 361                                  page.bitmap,
 362                                  page.active,
 363                                  close_button_state,
 364                                  x_extent);
 365
 366     wxCoord tab_height = m_tab_ctrl_height - 3;
 367     wxCoord tab_width = tab_size.x;
 368     wxCoord tab_x = in_rect.x;
 369     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
 370
 371
 372     caption = page.caption;
 373
 374
 375     // select pen, brush and font for the tab to be drawn
 376
 377     if (page.active)
 378     {
 379         dc.SetFont(m_selected_font);
 380         texty = selected_texty;
 381     }
 382     else
 383     {
 384         dc.SetFont(m_normal_font);
 385         texty = normal_texty;
 386     }
 387
 388
 389     // create points that will make the tab outline
 390
 391     int clip_width = tab_width;
 392     if (tab_x + clip_width > in_rect.x + in_rect.width)
 393         clip_width = (in_rect.x + in_rect.width) - tab_x;
 394
 395 /*
 396     wxPoint clip_points[6];
 397     clip_points[0] = wxPoint(tab_x,              tab_y+tab_height-3);
 398     clip_points[1] = wxPoint(tab_x,              tab_y+2);
 399     clip_points[2] = wxPoint(tab_x+2,            tab_y);
 400     clip_points[3] = wxPoint(tab_x+clip_width-1, tab_y);
 401     clip_points[4] = wxPoint(tab_x+clip_width+1, tab_y+2);
 402     clip_points[5] = wxPoint(tab_x+clip_width+1, tab_y+tab_height-3);
 403
 404     // FIXME: these ports don't provide wxRegion ctor from array of points
 405 #if !defined(__WXDFB__) && !defined(__WXCOCOA__)
 406     // set the clipping region for the tab --
 407     wxRegion clipping_region(WXSIZEOF(clip_points), clip_points);
 408     dc.SetClippingRegion(clipping_region);
 409 #endif // !wxDFB && !wxCocoa
 410 */
 411     // since the above code above doesn't play well with WXDFB or WXCOCOA,
 412     // we'll just use a rectangle for the clipping region for now --
 413     dc.SetClippingRegion(tab_x, tab_y, clip_width+1, tab_height-3);
 414
 415
 416     wxPoint border_points[6];
 417     if (m_flags &wxAUI_NB_BOTTOM)
 418     {
 419         border_points[0] = wxPoint(tab_x,             tab_y);
 420         border_points[1] = wxPoint(tab_x,             tab_y+tab_height-6);
 421         border_points[2] = wxPoint(tab_x+2,           tab_y+tab_height-4);
 422         border_points[3] = wxPoint(tab_x+tab_width-2, tab_y+tab_height-4);
 423         border_points[4] = wxPoint(tab_x+tab_width,   tab_y+tab_height-6);
 424         border_points[5] = wxPoint(tab_x+tab_width,   tab_y);
 425     }
 426     else //if (m_flags & wxAUI_NB_TOP) {}
 427     {
 428         border_points[0] = wxPoint(tab_x,             tab_y+tab_height-4);
 429         border_points[1] = wxPoint(tab_x,             tab_y+2);
 430         border_points[2] = wxPoint(tab_x+2,           tab_y);
 431         border_points[3] = wxPoint(tab_x+tab_width-2, tab_y);
 432         border_points[4] = wxPoint(tab_x+tab_width,   tab_y+2);
 433         border_points[5] = wxPoint(tab_x+tab_width,   tab_y+tab_height-4);
 434     }
 435     // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
 436     // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
 437
 438     int drawn_tab_yoff = border_points[1].y;
 439     int drawn_tab_height = border_points[0].y - border_points[1].y;
 440
 441
 442     if (page.active)
 443     {
 444         // draw active tab
 445
 446         // draw base background color
 447         wxRect r(tab_x, tab_y, tab_width, tab_height);
 448         dc.SetPen(m_base_colour_pen);
 449         dc.SetBrush(m_base_colour_brush);
 450         dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
 451
 452         // this white helps fill out the gradient at the top of the tab
 453         dc.SetPen(*wxWHITE_PEN);
 454         dc.SetBrush(*wxWHITE_BRUSH);
 455         dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
 456
 457         // these two points help the rounded corners appear more antialiased
 458         dc.SetPen(m_base_colour_pen);
 459         dc.DrawPoint(r.x+2, r.y+1);
 460         dc.DrawPoint(r.x+r.width-2, r.y+1);
 461
 462         // set rectangle down a bit for gradient drawing
 463         r.SetHeight(r.GetHeight()/2);
 464         r.x += 2;
 465         r.width -= 2;
 466         r.y += r.height;
 467         r.y -= 2;
 468
 469         // draw gradient background
 470         wxColor top_color = *wxWHITE;
 471         wxColor bottom_color = m_base_colour;
 472         dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
 473     }
 474     else
 475     {
 476         // draw inactive tab
 477
 478         wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
 479
 480         // start the gradent up a bit and leave the inside border inset
 481         // by a pixel for a 3D look.  Only the top half of the inactive
 482         // tab will have a slight gradient
 483         r.x += 3;
 484         r.y++;
 485         r.width -= 4;
 486         r.height /= 2;
 487         r.height--;
 488
 489         // -- draw top gradient fill for glossy look
 490         wxColor top_color = m_base_colour;
 491         wxColor bottom_color = wxAuiStepColour(top_color, 160);
 492         dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
 493
 494         r.y += r.height;
 495         r.y--;
 496
 497         // -- draw bottom fill for glossy look
 498         top_color = m_base_colour;
 499         bottom_color = m_base_colour;
 500         dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
 501     }
 502
 503     // draw tab outline
 504     dc.SetPen(m_border_pen);
 505     dc.SetBrush(*wxTRANSPARENT_BRUSH);
 506     dc.DrawPolygon(WXSIZEOF(border_points), border_points);
 507
 508     // there are two horizontal grey lines at the bottom of the tab control,
 509     // this gets rid of the top one of those lines in the tab control
 510     if (page.active)
 511     {
 512         if (m_flags &wxAUI_NB_BOTTOM)
 513             dc.SetPen(wxPen(wxColour(wxAuiStepColour(m_base_colour, 170))));
 514         // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
 515         // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
 516         else //for wxAUI_NB_TOP
 517             dc.SetPen(m_base_colour_pen);
 518         dc.DrawLine(border_points[0].x+1,
 519                     border_points[0].y,
 520                     border_points[5].x,
 521                     border_points[5].y);
 522     }
 523
 524
 525     int text_offset = tab_x + 8;
 526     int close_button_width = 0;
 527     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
 528     {
 529         close_button_width = m_active_close_bmp.GetWidth();
 530     }
 531
 532     int bitmap_offset = 0;
 533     if (page.bitmap.IsOk())
 534     {
 535         bitmap_offset = tab_x + 8;
 536
 537         // draw bitmap
 538         dc.DrawBitmap(page.bitmap,
 539                       bitmap_offset,
 540                       drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
 541                       true);
 542
 543         text_offset = bitmap_offset + page.bitmap.GetWidth();
 544         text_offset += 3; // bitmap padding
 545
 546     }
 547     else
 548     {
 549         text_offset = tab_x + 8;
 550     }
 551
 552
 553     wxString draw_text = wxAuiChopText(dc,
 554                           caption,
 555                           tab_width - (text_offset-tab_x) - close_button_width);
 556
 557     // draw tab text
 558     dc.DrawText(draw_text,
 559                 text_offset,
 560                 drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);
 561
 562     // draw focus rectangle
 563     if (page.active && (wnd->FindFocus() == wnd))
 564     {
 565         wxRect focusRectText(text_offset, (drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1),
 566             selected_textx, selected_texty);
 567
 568         wxRect focusRect;
 569         wxRect focusRectBitmap;
 570
 571         if (page.bitmap.IsOk())
 572             focusRectBitmap = wxRect(bitmap_offset, drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
 573                                             page.bitmap.GetWidth(), page.bitmap.GetHeight());
 574
 575         if (page.bitmap.IsOk() && draw_text.IsEmpty())
 576             focusRect = focusRectBitmap;
 577         else if (!page.bitmap.IsOk() && !draw_text.IsEmpty())
 578             focusRect = focusRectText;
 579         else if (page.bitmap.IsOk() && !draw_text.IsEmpty())
 580             focusRect = focusRectText.Union(focusRectBitmap);
 581
 582         focusRect.Inflate(2, 2);
 583
 584         wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
 585     }
 586
 587     // draw close button if necessary
 588     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
 589     {
 590         wxBitmap bmp = m_disabled_close_bmp;
 591
 592         if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
 593             close_button_state == wxAUI_BUTTON_STATE_PRESSED)
 594         {
 595             bmp = m_active_close_bmp;
 596         }
 597
 598         wxRect rect(tab_x + tab_width - close_button_width - 1,
 599                     tab_y + (tab_height/2) - (bmp.GetHeight()/2),
 600                     close_button_width,
 601                     tab_height);
 602         IndentPressedBitmap(&rect, close_button_state);
 603         dc.DrawBitmap(bmp, rect.x, rect.y, true);
 604
 605         *out_button_rect = rect;
 606     }
 607
 608     *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
 609
 610     dc.DestroyClippingRegion();
 611 }
 612
 613 int wxAuiDefaultTabArt::GetIndentSize()
 614 {
 615     return 5;
 616 }
 617
 618 wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
 619                                       wxWindow* WXUNUSED(wnd),
 620                                       const wxString& caption,
 621                                       const wxBitmap& bitmap,
 622                                       bool WXUNUSED(active),
 623                                       int close_button_state,
 624                                       int* x_extent)
 625 {
 626     wxCoord measured_textx, measured_texty, tmp;
 627
 628     dc.SetFont(m_measuring_font);
 629     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
 630
 631     dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);
 632
 633     // add padding around the text
 634     wxCoord tab_width = measured_textx;
 635     wxCoord tab_height = measured_texty;
 636
 637     // if the close button is showing, add space for it
 638     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
 639         tab_width += m_active_close_bmp.GetWidth() + 3;
 640
 641     // if there's a bitmap, add space for it
 642     if (bitmap.IsOk())
 643     {
 644         tab_width += bitmap.GetWidth();
 645         tab_width += 3; // right side bitmap padding
 646         tab_height = wxMax(tab_height, bitmap.GetHeight());
 647     }
 648
 649     // add padding
 650     tab_width += 16;
 651     tab_height += 10;
 652
 653     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
 654     {
 655         tab_width = m_fixed_tab_width;
 656     }
 657
 658     *x_extent = tab_width;
 659
 660     return wxSize(tab_width, tab_height);
 661 }
 662
 663
 664 void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
 665                                     wxWindow* WXUNUSED(wnd),
 666                                     const wxRect& in_rect,
 667                                     int bitmap_id,
 668                                     int button_state,
 669                                     int orientation,
 670                                     wxRect* out_rect)
 671 {
 672     wxBitmap bmp;
 673     wxRect rect;
 674
 675     switch (bitmap_id)
 676     {
 677         case wxAUI_BUTTON_CLOSE:
 678             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
 679                 bmp = m_disabled_close_bmp;
 680             else
 681                 bmp = m_active_close_bmp;
 682             break;
 683         case wxAUI_BUTTON_LEFT:
 684             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
 685                 bmp = m_disabled_left_bmp;
 686             else
 687                 bmp = m_active_left_bmp;
 688             break;
 689         case wxAUI_BUTTON_RIGHT:
 690             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
 691                 bmp = m_disabled_right_bmp;
 692             else
 693                 bmp = m_active_right_bmp;
 694             break;
 695         case wxAUI_BUTTON_WINDOWLIST:
 696             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
 697                 bmp = m_disabled_windowlist_bmp;
 698             else
 699                 bmp = m_active_windowlist_bmp;
 700             break;
 701     }
 702
 703
 704     if (!bmp.IsOk())
 705         return;
 706
 707     rect = in_rect;
 708
 709     if (orientation == wxLEFT)
 710     {
 711         rect.SetX(in_rect.x);
 712         rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
 713         rect.SetWidth(bmp.GetWidth());
 714         rect.SetHeight(bmp.GetHeight());
 715     }
 716     else
 717     {
 718         rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
 719                       ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
 720                       bmp.GetWidth(), bmp.GetHeight());
 721     }
 722
 723     IndentPressedBitmap(&rect, button_state);
 724     dc.DrawBitmap(bmp, rect.x, rect.y, true);
 725
 726     *out_rect = rect;
 727 }
 728
 729 int wxAuiDefaultTabArt::ShowDropDown(wxWindow* wnd,
 730                                      const wxAuiNotebookPageArray& pages,
 731                                      int /*active_idx*/)
 732 {
 733     wxMenu menuPopup;
 734
 735     size_t i, count = pages.GetCount();
 736     for (i = 0; i < count; ++i)
 737     {
 738         const wxAuiNotebookPage& page = pages.Item(i);
 739         wxString caption = page.caption;
 740
 741         // if there is no caption, make it a space.  This will prevent
 742         // an assert in the menu code.
 743         if (caption.IsEmpty())
 744             caption = wxT(" ");
 745
 746         wxMenuItem* item = new wxMenuItem(NULL, 1000+i, caption);
 747         if (page.bitmap.IsOk())
 748             item->SetBitmap(page.bitmap);
 749         menuPopup.Append(item);
 750     }
 751
 752     // find out where to put the popup menu of window items
 753     wxPoint pt = ::wxGetMousePosition();
 754     pt = wnd->ScreenToClient(pt);
 755
 756     // find out the screen coordinate at the bottom of the tab ctrl
 757     wxRect cli_rect = wnd->GetClientRect();
 758     pt.y = cli_rect.y + cli_rect.height;
 759
 760     wxAuiCommandCapture* cc = new wxAuiCommandCapture;
 761     wnd->PushEventHandler(cc);
 762     wnd->PopupMenu(&menuPopup, pt);
 763     int command = cc->GetCommandId();
 764     wnd->PopEventHandler(true);
 765
 766     if (command >= 1000)
 767         return command-1000;
 768
 769     return -1;
 770 }
 771
 772 int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
 773                                            const wxAuiNotebookPageArray& pages,
 774                                            const wxSize& required_bmp_size)
 775 {
 776     wxClientDC dc(wnd);
 777     dc.SetFont(m_measuring_font);
 778
 779     // sometimes a standard bitmap size needs to be enforced, especially
 780     // if some tabs have bitmaps and others don't.  This is important because
 781     // it prevents the tab control from resizing when tabs are added.
 782     wxBitmap measure_bmp;
 783     if (required_bmp_size.IsFullySpecified())
 784     {
 785         measure_bmp.Create(required_bmp_size.x,
 786                            required_bmp_size.y);
 787     }
 788
 789
 790     int max_y = 0;
 791     size_t i, page_count = pages.GetCount();
 792     for (i = 0; i < page_count; ++i)
 793     {
 794         wxAuiNotebookPage& page = pages.Item(i);
 795
 796         wxBitmap bmp;
 797         if (measure_bmp.IsOk())
 798             bmp = measure_bmp;
 799         else
 800             bmp = page.bitmap;
 801
 802         // we don't use the caption text because we don't
 803         // want tab heights to be different in the case
 804         // of a very short piece of text on one tab and a very
 805         // tall piece of text on another tab
 806         int x_ext = 0;
 807         wxSize s = GetTabSize(dc,
 808                               wnd,
 809                               wxT("ABCDEFGHIj"),
 810                               bmp,
 811                               true,
 812                               wxAUI_BUTTON_STATE_HIDDEN,
 813                               &x_ext);
 814
 815         max_y = wxMax(max_y, s.y);
 816     }
 817
 818     return max_y+2;
 819 }
 820
 821 void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
 822 {
 823     m_normal_font = font;
 824 }
 825
 826 void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font)
 827 {
 828     m_selected_font = font;
 829 }
 830
 831 void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
 832 {
 833     m_measuring_font = font;
 834 }
 835
 836
 837 // -- wxAuiSimpleTabArt class implementation --
 838
 839 wxAuiSimpleTabArt::wxAuiSimpleTabArt()
 840 {
 841     m_normal_font = *wxNORMAL_FONT;
 842     m_selected_font = *wxNORMAL_FONT;
 843     m_selected_font.SetWeight(wxBOLD);
 844     m_measuring_font = m_selected_font;
 845
 846     m_flags = 0;
 847     m_fixed_tab_width = 100;
 848
 849     wxColour base_colour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
 850
 851     wxColour background_colour = base_colour;
 852     wxColour normaltab_colour = base_colour;
 853     wxColour selectedtab_colour = *wxWHITE;
 854
 855     m_bkbrush = wxBrush(background_colour);
 856     m_normal_bkbrush = wxBrush(normaltab_colour);
 857     m_normal_bkpen = wxPen(normaltab_colour);
 858     m_selected_bkbrush = wxBrush(selectedtab_colour);
 859     m_selected_bkpen = wxPen(selectedtab_colour);
 860
 861     m_active_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
 862     m_disabled_close_bmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
 863
 864     m_active_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
 865     m_disabled_left_bmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
 866
 867     m_active_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
 868     m_disabled_right_bmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
 869
 870     m_active_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
 871     m_disabled_windowlist_bmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
 872
 873 }
 874
 875 wxAuiSimpleTabArt::~wxAuiSimpleTabArt()
 876 {
 877 }
 878
 879 wxAuiTabArt* wxAuiSimpleTabArt::Clone()
 880 {
 881     return static_cast<wxAuiTabArt*>(new wxAuiSimpleTabArt);
 882 }
 883
 884
 885 void wxAuiSimpleTabArt::SetFlags(unsigned int flags)
 886 {
 887     m_flags = flags;
 888 }
 889
 890 void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
 891                                       size_t tab_count)
 892 {
 893     m_fixed_tab_width = 100;
 894
 895     int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
 896
 897     if (m_flags & wxAUI_NB_CLOSE_BUTTON)
 898         tot_width -= m_active_close_bmp.GetWidth();
 899     if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
 900         tot_width -= m_active_windowlist_bmp.GetWidth();
 901
 902     if (tab_count > 0)
 903     {
 904         m_fixed_tab_width = tot_width/(int)tab_count;
 905     }
 906
 907
 908     if (m_fixed_tab_width < 100)
 909         m_fixed_tab_width = 100;
 910
 911     if (m_fixed_tab_width > tot_width/2)
 912         m_fixed_tab_width = tot_width/2;
 913
 914     if (m_fixed_tab_width > 220)
 915         m_fixed_tab_width = 220;
 916 }
 917
 918 void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,
 919                                        wxWindow* WXUNUSED(wnd),
 920                                        const wxRect& rect)
 921 {
 922     // draw background
 923     dc.SetBrush(m_bkbrush);
 924     dc.SetPen(*wxTRANSPARENT_PEN);
 925     dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
 926
 927     // draw base line
 928     dc.SetPen(*wxGREY_PEN);
 929     dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
 930 }
 931
 932
 933 // DrawTab() draws an individual tab.
 934 //
 935 // dc       - output dc
 936 // in_rect  - rectangle the tab should be confined to
 937 // caption  - tab's caption
 938 // active   - whether or not the tab is active
 939 // out_rect - actual output rectangle
 940 // x_extent - the advance x; where the next tab should start
 941
 942 void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
 943                                 wxWindow* wnd,
 944                                 const wxAuiNotebookPage& page,
 945                                 const wxRect& in_rect,
 946                                 int close_button_state,
 947                                 wxRect* out_tab_rect,
 948                                 wxRect* out_button_rect,
 949                                 int* x_extent)
 950 {
 951     wxCoord normal_textx, normal_texty;
 952     wxCoord selected_textx, selected_texty;
 953     wxCoord textx, texty;
 954
 955     // if the caption is empty, measure some temporary text
 956     wxString caption = page.caption;
 957     if (caption.empty())
 958         caption = wxT("Xj");
 959
 960     dc.SetFont(m_selected_font);
 961     dc.GetTextExtent(caption, &selected_textx, &selected_texty);
 962
 963     dc.SetFont(m_normal_font);
 964     dc.GetTextExtent(caption, &normal_textx, &normal_texty);
 965
 966     // figure out the size of the tab
 967     wxSize tab_size = GetTabSize(dc,
 968                                  wnd,
 969                                  page.caption,
 970                                  page.bitmap,
 971                                  page.active,
 972                                  close_button_state,
 973                                  x_extent);
 974
 975     wxCoord tab_height = tab_size.y;
 976     wxCoord tab_width = tab_size.x;
 977     wxCoord tab_x = in_rect.x;
 978     wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
 979
 980     caption = page.caption;
 981
 982     // select pen, brush and font for the tab to be drawn
 983
 984     if (page.active)
 985     {
 986         dc.SetPen(m_selected_bkpen);
 987         dc.SetBrush(m_selected_bkbrush);
 988         dc.SetFont(m_selected_font);
 989         textx = selected_textx;
 990         texty = selected_texty;
 991     }
 992     else
 993     {
 994         dc.SetPen(m_normal_bkpen);
 995         dc.SetBrush(m_normal_bkbrush);
 996         dc.SetFont(m_normal_font);
 997         textx = normal_textx;
 998         texty = normal_texty;
 999     }
1000
1001
1002     // -- draw line --
1003
1004     wxPoint points[7];
1005     points[0].x = tab_x;
1006     points[0].y = tab_y + tab_height - 1;
1007     points[1].x = tab_x + tab_height - 3;
1008     points[1].y = tab_y + 2;
1009     points[2].x = tab_x + tab_height + 3;
1010     points[2].y = tab_y;
1011     points[3].x = tab_x + tab_width - 2;
1012     points[3].y = tab_y;
1013     points[4].x = tab_x + tab_width;
1014     points[4].y = tab_y + 2;
1015     points[5].x = tab_x + tab_width;
1016     points[5].y = tab_y + tab_height - 1;
1017     points[6] = points[0];
1018
1019     dc.SetClippingRegion(in_rect);
1020
1021     dc.DrawPolygon(WXSIZEOF(points) - 1, points);
1022
1023     dc.SetPen(*wxGREY_PEN);
1024
1025     //dc.DrawLines(active ? WXSIZEOF(points) - 1 : WXSIZEOF(points), points);
1026     dc.DrawLines(WXSIZEOF(points), points);
1027
1028
1029     int text_offset;
1030
1031     int close_button_width = 0;
1032     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1033     {
1034         close_button_width = m_active_close_bmp.GetWidth();
1035         text_offset = tab_x + (tab_height/2) + ((tab_width-close_button_width)/2) - (textx/2);
1036     }
1037     else
1038     {
1039         text_offset = tab_x + (tab_height/3) + (tab_width/2) - (textx/2);
1040     }
1041
1042     // set minimum text offset
1043     if (text_offset < tab_x + tab_height)
1044         text_offset = tab_x + tab_height;
1045
1046     // chop text if necessary
1047     wxString draw_text = wxAuiChopText(dc,
1048                           caption,
1049                           tab_width - (text_offset-tab_x) - close_button_width);
1050
1051     // draw tab text
1052     dc.DrawText(draw_text,
1053                  text_offset,
1054                  (tab_y + tab_height)/2 - (texty/2) + 1);
1055
1056
1057     // draw focus rectangle
1058     if (page.active && (wnd->FindFocus() == wnd))
1059     {
1060         wxRect focusRect(text_offset, ((tab_y + tab_height)/2 - (texty/2) + 1),
1061             selected_textx, selected_texty);
1062
1063         focusRect.Inflate(2, 2);
1064
1065         wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
1066     }
1067
1068     // draw close button if necessary
1069     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1070     {
1071         wxBitmap bmp;
1072         if (page.active)
1073             bmp = m_active_close_bmp;
1074         else
1075             bmp = m_disabled_close_bmp;
1076
1077         wxRect rect(tab_x + tab_width - close_button_width - 1,
1078                     tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
1079                     close_button_width,
1080                     tab_height - 1);
1081         DrawButtons(dc, rect, bmp, *wxWHITE, close_button_state);
1082
1083         *out_button_rect = rect;
1084     }
1085
1086
1087     *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
1088
1089     dc.DestroyClippingRegion();
1090 }
1091
1092 int wxAuiSimpleTabArt::GetIndentSize()
1093 {
1094     return 0;
1095 }
1096
1097 wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
1098                                      wxWindow* WXUNUSED(wnd),
1099                                      const wxString& caption,
1100                                      const wxBitmap& WXUNUSED(bitmap),
1101                                      bool WXUNUSED(active),
1102                                      int close_button_state,
1103                                      int* x_extent)
1104 {
1105     wxCoord measured_textx, measured_texty;
1106
1107     dc.SetFont(m_measuring_font);
1108     dc.GetTextExtent(caption, &measured_textx, &measured_texty);
1109
1110     wxCoord tab_height = measured_texty + 4;
1111     wxCoord tab_width = measured_textx + tab_height + 5;
1112
1113     if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1114         tab_width += m_active_close_bmp.GetWidth();
1115
1116     if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
1117     {
1118         tab_width = m_fixed_tab_width;
1119     }
1120
1121     *x_extent = tab_width - (tab_height/2) - 1;
1122
1123     return wxSize(tab_width, tab_height);
1124 }
1125
1126
1127 void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
1128                                    wxWindow* WXUNUSED(wnd),
1129                                    const wxRect& in_rect,
1130                                    int bitmap_id,
1131                                    int button_state,
1132                                    int orientation,
1133                                    wxRect* out_rect)
1134 {
1135     wxBitmap bmp;
1136     wxRect rect;
1137
1138     switch (bitmap_id)
1139     {
1140         case wxAUI_BUTTON_CLOSE:
1141             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1142                 bmp = m_disabled_close_bmp;
1143             else
1144                 bmp = m_active_close_bmp;
1145             break;
1146         case wxAUI_BUTTON_LEFT:
1147             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1148                 bmp = m_disabled_left_bmp;
1149             else
1150                 bmp = m_active_left_bmp;
1151             break;
1152         case wxAUI_BUTTON_RIGHT:
1153             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1154                 bmp = m_disabled_right_bmp;
1155             else
1156                 bmp = m_active_right_bmp;
1157             break;
1158         case wxAUI_BUTTON_WINDOWLIST:
1159             if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1160                 bmp = m_disabled_windowlist_bmp;
1161             else
1162                 bmp = m_active_windowlist_bmp;
1163             break;
1164     }
1165
1166     if (!bmp.IsOk())
1167         return;
1168
1169     rect = in_rect;
1170
1171     if (orientation == wxLEFT)
1172     {
1173         rect.SetX(in_rect.x);
1174         rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
1175         rect.SetWidth(bmp.GetWidth());
1176         rect.SetHeight(bmp.GetHeight());
1177     }
1178     else
1179     {
1180         rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
1181                       ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
1182                       bmp.GetWidth(), bmp.GetHeight());
1183     }
1184
1185
1186     DrawButtons(dc, rect, bmp, *wxWHITE, button_state);
1187
1188     *out_rect = rect;
1189 }
1190
1191 int wxAuiSimpleTabArt::ShowDropDown(wxWindow* wnd,
1192                                     const wxAuiNotebookPageArray& pages,
1193                                     int active_idx)
1194 {
1195     wxMenu menuPopup;
1196
1197     size_t i, count = pages.GetCount();
1198     for (i = 0; i < count; ++i)
1199     {
1200         const wxAuiNotebookPage& page = pages.Item(i);
1201         menuPopup.AppendCheckItem(1000+i, page.caption);
1202     }
1203
1204     if (active_idx != -1)
1205     {
1206         menuPopup.Check(1000+active_idx, true);
1207     }
1208
1209     // find out where to put the popup menu of window
1210     // items.  Subtract 100 for now to center the menu
1211     // a bit, until a better mechanism can be implemented
1212     wxPoint pt = ::wxGetMousePosition();
1213     pt = wnd->ScreenToClient(pt);
1214     if (pt.x < 100)
1215         pt.x = 0;
1216     else
1217         pt.x -= 100;
1218
1219     // find out the screen coordinate at the bottom of the tab ctrl
1220     wxRect cli_rect = wnd->GetClientRect();
1221     pt.y = cli_rect.y + cli_rect.height;
1222
1223     wxAuiCommandCapture* cc = new wxAuiCommandCapture;
1224     wnd->PushEventHandler(cc);
1225     wnd->PopupMenu(&menuPopup, pt);
1226     int command = cc->GetCommandId();
1227     wnd->PopEventHandler(true);
1228
1229     if (command >= 1000)
1230         return command-1000;
1231
1232     return -1;
1233 }
1234
1235 int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
1236                                           const wxAuiNotebookPageArray& WXUNUSED(pages),
1237                                           const wxSize& WXUNUSED(required_bmp_size))
1238 {
1239     wxClientDC dc(wnd);
1240     dc.SetFont(m_measuring_font);
1241     int x_ext = 0;
1242     wxSize s = GetTabSize(dc,
1243                           wnd,
1244                           wxT("ABCDEFGHIj"),
1245                           wxNullBitmap,
1246                           true,
1247                           wxAUI_BUTTON_STATE_HIDDEN,
1248                           &x_ext);
1249     return s.y+3;
1250 }
1251
1252 void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
1253 {
1254     m_normal_font = font;
1255 }
1256
1257 void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
1258 {
1259     m_selected_font = font;
1260 }
1261
1262 void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
1263 {
1264     m_measuring_font = font;
1265 }
1266
1267
1268
1269
1270 // -- wxAuiTabContainer class implementation --
1271
1272
1273 // wxAuiTabContainer is a class which contains information about each
1274 // tab.  It also can render an entire tab control to a specified DC.
1275 // It's not a window class itself, because this code will be used by
1276 // the wxFrameMananger, where it is disadvantageous to have separate
1277 // windows for each tab control in the case of "docked tabs"
1278
1279 // A derived class, wxAuiTabCtrl, is an actual wxWindow-derived window
1280 // which can be used as a tab control in the normal sense.
1281
1282
1283 wxAuiTabContainer::wxAuiTabContainer()
1284 {
1285     m_tab_offset = 0;
1286     m_flags = 0;
1287     m_art = new wxAuiDefaultTabArt;
1288
1289     AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
1290     AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
1291     AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
1292     AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
1293 }
1294
1295 wxAuiTabContainer::~wxAuiTabContainer()
1296 {
1297     delete m_art;
1298 }
1299
1300 void wxAuiTabContainer::SetArtProvider(wxAuiTabArt* art)
1301 {
1302     delete m_art;
1303     m_art = art;
1304
1305     if (m_art)
1306     {
1307         m_art->SetFlags(m_flags);
1308     }
1309 }
1310
1311 wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const
1312 {
1313     return m_art;
1314 }
1315
1316 void wxAuiTabContainer::SetFlags(unsigned int flags)
1317 {
1318     m_flags = flags;
1319
1320     // check for new close button settings
1321     RemoveButton(wxAUI_BUTTON_LEFT);
1322     RemoveButton(wxAUI_BUTTON_RIGHT);
1323     RemoveButton(wxAUI_BUTTON_WINDOWLIST);
1324     RemoveButton(wxAUI_BUTTON_CLOSE);
1325
1326
1327     if (flags & wxAUI_NB_SCROLL_BUTTONS)
1328     {
1329         AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
1330         AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
1331     }
1332
1333     if (flags & wxAUI_NB_WINDOWLIST_BUTTON)
1334     {
1335         AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
1336     }
1337
1338     if (flags & wxAUI_NB_CLOSE_BUTTON)
1339     {
1340         AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
1341     }
1342
1343     if (m_art)
1344     {
1345         m_art->SetFlags(m_flags);
1346     }
1347 }
1348
1349 unsigned int wxAuiTabContainer::GetFlags() const
1350 {
1351     return m_flags;
1352 }
1353
1354
1355 void wxAuiTabContainer::SetNormalFont(const wxFont& font)
1356 {
1357     m_art->SetNormalFont(font);
1358 }
1359
1360 void wxAuiTabContainer::SetSelectedFont(const wxFont& font)
1361 {
1362     m_art->SetSelectedFont(font);
1363 }
1364
1365 void wxAuiTabContainer::SetMeasuringFont(const wxFont& font)
1366 {
1367     m_art->SetMeasuringFont(font);
1368 }
1369
1370 void wxAuiTabContainer::SetRect(const wxRect& rect)
1371 {
1372     m_rect = rect;
1373
1374     if (m_art)
1375     {
1376         m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());
1377     }
1378 }
1379
1380 bool wxAuiTabContainer::AddPage(wxWindow* page,
1381                                 const wxAuiNotebookPage& info)
1382 {
1383     wxAuiNotebookPage page_info;
1384     page_info = info;
1385     page_info.window = page;
1386
1387     m_pages.Add(page_info);
1388
1389     // let the art provider know how many pages we have
1390     if (m_art)
1391     {
1392         m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1393     }
1394
1395     return true;
1396 }
1397
1398 bool wxAuiTabContainer::InsertPage(wxWindow* page,
1399                                    const wxAuiNotebookPage& info,
1400                                    size_t idx)
1401 {
1402     wxAuiNotebookPage page_info;
1403     page_info = info;
1404     page_info.window = page;
1405
1406     if (idx >= m_pages.GetCount())
1407         m_pages.Add(page_info);
1408     else
1409         m_pages.Insert(page_info, idx);
1410
1411     // let the art provider know how many pages we have
1412     if (m_art)
1413     {
1414         m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1415     }
1416
1417     return true;
1418 }
1419
1420 bool wxAuiTabContainer::MovePage(wxWindow* page,
1421                                  size_t new_idx)
1422 {
1423     int idx = GetIdxFromWindow(page);
1424     if (idx == -1)
1425         return false;
1426
1427     // get page entry, make a copy of it
1428     wxAuiNotebookPage p = GetPage(idx);
1429
1430     // remove old page entry
1431     RemovePage(page);
1432
1433     // insert page where it should be
1434     InsertPage(page, p, new_idx);
1435
1436     return true;
1437 }
1438
1439 bool wxAuiTabContainer::RemovePage(wxWindow* wnd)
1440 {
1441     size_t i, page_count = m_pages.GetCount();
1442     for (i = 0; i < page_count; ++i)
1443     {
1444         wxAuiNotebookPage& page = m_pages.Item(i);
1445         if (page.window == wnd)
1446         {
1447             m_pages.RemoveAt(i);
1448
1449             // let the art provider know how many pages we have
1450             if (m_art)
1451             {
1452                 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1453             }
1454
1455             return true;
1456         }
1457     }
1458
1459     return false;
1460 }
1461
1462 bool wxAuiTabContainer::SetActivePage(wxWindow* wnd)
1463 {
1464     bool found = false;
1465
1466     size_t i, page_count = m_pages.GetCount();
1467     for (i = 0; i < page_count; ++i)
1468     {
1469         wxAuiNotebookPage& page = m_pages.Item(i);
1470         if (page.window == wnd)
1471         {
1472             page.active = true;
1473             found = true;
1474         }
1475         else
1476         {
1477             page.active = false;
1478         }
1479     }
1480
1481     return found;
1482 }
1483
1484 void wxAuiTabContainer::SetNoneActive()
1485 {
1486     size_t i, page_count = m_pages.GetCount();
1487     for (i = 0; i < page_count; ++i)
1488     {
1489         wxAuiNotebookPage& page = m_pages.Item(i);
1490         page.active = false;
1491     }
1492 }
1493
1494 bool wxAuiTabContainer::SetActivePage(size_t page)
1495 {
1496     if (page >= m_pages.GetCount())
1497         return false;
1498
1499     return SetActivePage(m_pages.Item(page).window);
1500 }
1501
1502 int wxAuiTabContainer::GetActivePage() const
1503 {
1504     size_t i, page_count = m_pages.GetCount();
1505     for (i = 0; i < page_count; ++i)
1506     {
1507         wxAuiNotebookPage& page = m_pages.Item(i);
1508         if (page.active)
1509             return i;
1510     }
1511
1512     return -1;
1513 }
1514
1515 wxWindow* wxAuiTabContainer::GetWindowFromIdx(size_t idx) const
1516 {
1517     if (idx >= m_pages.GetCount())
1518         return NULL;
1519
1520     return m_pages[idx].window;
1521 }
1522
1523 int wxAuiTabContainer::GetIdxFromWindow(wxWindow* wnd) const
1524 {
1525     const size_t page_count = m_pages.GetCount();
1526     for ( size_t i = 0; i < page_count; ++i )
1527     {
1528         wxAuiNotebookPage& page = m_pages.Item(i);
1529         if (page.window == wnd)
1530             return i;
1531     }
1532     return wxNOT_FOUND;
1533 }
1534
1535 wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx)
1536 {
1537     wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
1538
1539     return m_pages[idx];
1540 }
1541
1542 const wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx) const
1543 {
1544     wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
1545
1546     return m_pages[idx];
1547 }
1548
1549 wxAuiNotebookPageArray& wxAuiTabContainer::GetPages()
1550 {
1551     return m_pages;
1552 }
1553
1554 size_t wxAuiTabContainer::GetPageCount() const
1555 {
1556     return m_pages.GetCount();
1557 }
1558
1559 void wxAuiTabContainer::AddButton(int id,
1560                                   int location,
1561                                   const wxBitmap& normal_bitmap,
1562                                   const wxBitmap& disabled_bitmap)
1563 {
1564     wxAuiTabContainerButton button;
1565     button.id = id;
1566     button.bitmap = normal_bitmap;
1567     button.dis_bitmap = disabled_bitmap;
1568     button.location = location;
1569     button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
1570
1571     m_buttons.Add(button);
1572 }
1573
1574 void wxAuiTabContainer::RemoveButton(int id)
1575 {
1576     size_t i, button_count = m_buttons.GetCount();
1577
1578     for (i = 0; i < button_count; ++i)
1579     {
1580         if (m_buttons.Item(i).id == id)
1581         {
1582             m_buttons.RemoveAt(i);
1583             return;
1584         }
1585     }
1586 }
1587
1588
1589
1590 size_t wxAuiTabContainer::GetTabOffset() const
1591 {
1592     return m_tab_offset;
1593 }
1594
1595 void wxAuiTabContainer::SetTabOffset(size_t offset)
1596 {
1597     m_tab_offset = offset;
1598 }
1599
1600
1601
1602
1603 // Render() renders the tab catalog to the specified DC
1604 // It is a virtual function and can be overridden to
1605 // provide custom drawing capabilities
1606 void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
1607 {
1608     if (!raw_dc || !raw_dc->IsOk())
1609         return;
1610
1611     wxMemoryDC dc;
1612
1613     // use the same layout direction as the window DC uses to ensure that the
1614     // text is rendered correctly
1615     dc.SetLayoutDirection(raw_dc->GetLayoutDirection());
1616
1617     wxBitmap bmp;
1618     size_t i;
1619     size_t page_count = m_pages.GetCount();
1620     size_t button_count = m_buttons.GetCount();
1621
1622     // create off-screen bitmap
1623     bmp.Create(m_rect.GetWidth(), m_rect.GetHeight());
1624     dc.SelectObject(bmp);
1625
1626     if (!dc.IsOk())
1627         return;
1628
1629     // find out if size of tabs is larger than can be
1630     // afforded on screen
1631     int total_width = 0;
1632     int visible_width = 0;
1633     for (i = 0; i < page_count; ++i)
1634     {
1635         wxAuiNotebookPage& page = m_pages.Item(i);
1636
1637         // determine if a close button is on this tab
1638         bool close_button = false;
1639         if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1640             ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1641         {
1642             close_button = true;
1643         }
1644
1645
1646         int x_extent = 0;
1647         wxSize size = m_art->GetTabSize(dc,
1648                             wnd,
1649                             page.caption,
1650                             page.bitmap,
1651                             page.active,
1652                             close_button ?
1653                               wxAUI_BUTTON_STATE_NORMAL :
1654                               wxAUI_BUTTON_STATE_HIDDEN,
1655                             &x_extent);
1656
1657         if (i+1 < page_count)
1658             total_width += x_extent;
1659         else
1660             total_width += size.x;
1661
1662         if (i >= m_tab_offset)
1663         {
1664             if (i+1 < page_count)
1665                 visible_width += x_extent;
1666             else
1667                 visible_width += size.x;
1668         }
1669     }
1670
1671     if (total_width > m_rect.GetWidth() || m_tab_offset != 0)
1672     {
1673         // show left/right buttons
1674         for (i = 0; i < button_count; ++i)
1675         {
1676             wxAuiTabContainerButton& button = m_buttons.Item(i);
1677             if (button.id == wxAUI_BUTTON_LEFT ||
1678                 button.id == wxAUI_BUTTON_RIGHT)
1679             {
1680                 button.cur_state &= ~wxAUI_BUTTON_STATE_HIDDEN;
1681             }
1682         }
1683     }
1684     else
1685     {
1686         // hide left/right buttons
1687         for (i = 0; i < button_count; ++i)
1688         {
1689             wxAuiTabContainerButton& button = m_buttons.Item(i);
1690             if (button.id == wxAUI_BUTTON_LEFT ||
1691                 button.id == wxAUI_BUTTON_RIGHT)
1692             {
1693                 button.cur_state |= wxAUI_BUTTON_STATE_HIDDEN;
1694             }
1695         }
1696     }
1697
1698     // determine whether left button should be enabled
1699     for (i = 0; i < button_count; ++i)
1700     {
1701         wxAuiTabContainerButton& button = m_buttons.Item(i);
1702         if (button.id == wxAUI_BUTTON_LEFT)
1703         {
1704             if (m_tab_offset == 0)
1705                 button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
1706             else
1707                 button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
1708         }
1709         if (button.id == wxAUI_BUTTON_RIGHT)
1710         {
1711             if (visible_width < m_rect.GetWidth() - ((int)button_count*16))
1712                 button.cur_state |= wxAUI_BUTTON_STATE_DISABLED;
1713             else
1714                 button.cur_state &= ~wxAUI_BUTTON_STATE_DISABLED;
1715         }
1716     }
1717
1718
1719
1720     // draw background
1721     m_art->DrawBackground(dc, wnd, m_rect);
1722
1723     // draw buttons
1724     int left_buttons_width = 0;
1725     int right_buttons_width = 0;
1726
1727     int offset = 0;
1728
1729     // draw the buttons on the right side
1730     offset = m_rect.x + m_rect.width;
1731     for (i = 0; i < button_count; ++i)
1732     {
1733         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1734
1735         if (button.location != wxRIGHT)
1736             continue;
1737         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1738             continue;
1739
1740         wxRect button_rect = m_rect;
1741         button_rect.SetY(1);
1742         button_rect.SetWidth(offset);
1743
1744         m_art->DrawButton(dc,
1745                           wnd,
1746                           button_rect,
1747                           button.id,
1748                           button.cur_state,
1749                           wxRIGHT,
1750                           &button.rect);
1751
1752         offset -= button.rect.GetWidth();
1753         right_buttons_width += button.rect.GetWidth();
1754     }
1755
1756
1757
1758     offset = 0;
1759
1760     // draw the buttons on the left side
1761
1762     for (i = 0; i < button_count; ++i)
1763     {
1764         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1765
1766         if (button.location != wxLEFT)
1767             continue;
1768         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1769             continue;
1770
1771         wxRect button_rect(offset, 1, 1000, m_rect.height);
1772
1773         m_art->DrawButton(dc,
1774                           wnd,
1775                           button_rect,
1776                           button.id,
1777                           button.cur_state,
1778                           wxLEFT,
1779                           &button.rect);
1780
1781         offset += button.rect.GetWidth();
1782         left_buttons_width += button.rect.GetWidth();
1783     }
1784
1785     offset = left_buttons_width;
1786
1787     if (offset == 0)
1788         offset += m_art->GetIndentSize();
1789
1790
1791     // prepare the tab-close-button array
1792     // make sure tab button entries which aren't used are marked as hidden
1793     for (i = page_count; i < m_tab_close_buttons.GetCount(); ++i)
1794         m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1795
1796     // make sure there are enough tab button entries to accommodate all tabs
1797     while (m_tab_close_buttons.GetCount() < page_count)
1798     {
1799         wxAuiTabContainerButton tempbtn;
1800         tempbtn.id = wxAUI_BUTTON_CLOSE;
1801         tempbtn.location = wxCENTER;
1802         tempbtn.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1803         m_tab_close_buttons.Add(tempbtn);
1804     }
1805
1806
1807     // buttons before the tab offset must be set to hidden
1808     for (i = 0; i < m_tab_offset; ++i)
1809     {
1810         m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1811     }
1812
1813
1814     // draw the tabs
1815
1816     size_t active = 999;
1817     int active_offset = 0;
1818     wxRect active_rect;
1819
1820     int x_extent = 0;
1821     wxRect rect = m_rect;
1822     rect.y = 0;
1823     rect.height = m_rect.height;
1824
1825     for (i = m_tab_offset; i < page_count; ++i)
1826     {
1827         wxAuiNotebookPage& page = m_pages.Item(i);
1828         wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
1829
1830         // determine if a close button is on this tab
1831         if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1832             ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1833         {
1834             if (tab_button.cur_state == wxAUI_BUTTON_STATE_HIDDEN)
1835             {
1836                 tab_button.id = wxAUI_BUTTON_CLOSE;
1837                 tab_button.cur_state = wxAUI_BUTTON_STATE_NORMAL;
1838                 tab_button.location = wxCENTER;
1839             }
1840         }
1841         else
1842         {
1843             tab_button.cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1844         }
1845
1846         rect.x = offset;
1847         rect.width = m_rect.width - right_buttons_width - offset - 2;
1848
1849         if (rect.width <= 0)
1850             break;
1851
1852         m_art->DrawTab(dc,
1853                        wnd,
1854                        page,
1855                        rect,
1856                        tab_button.cur_state,
1857                        &page.rect,
1858                        &tab_button.rect,
1859                        &x_extent);
1860
1861         if (page.active)
1862         {
1863             active = i;
1864             active_offset = offset;
1865             active_rect = rect;
1866         }
1867
1868         offset += x_extent;
1869     }
1870
1871
1872     // make sure to deactivate buttons which are off the screen to the right
1873     for (++i; i < m_tab_close_buttons.GetCount(); ++i)
1874     {
1875         m_tab_close_buttons.Item(i).cur_state = wxAUI_BUTTON_STATE_HIDDEN;
1876     }
1877
1878
1879     // draw the active tab again so it stands in the foreground
1880     if (active >= m_tab_offset && active < m_pages.GetCount())
1881     {
1882         wxAuiNotebookPage& page = m_pages.Item(active);
1883
1884         wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(active);
1885
1886         rect.x = active_offset;
1887         m_art->DrawTab(dc,
1888                        wnd,
1889                        page,
1890                        active_rect,
1891                        tab_button.cur_state,
1892                        &page.rect,
1893                        &tab_button.rect,
1894                        &x_extent);
1895     }
1896
1897
1898     raw_dc->Blit(m_rect.x, m_rect.y,
1899                  m_rect.GetWidth(), m_rect.GetHeight(),
1900                  &dc, 0, 0);
1901 }
1902
1903 // Is the tab visible?
1904 bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWindow* wnd)
1905 {
1906     if (!dc || !dc->IsOk())
1907         return false;
1908
1909     size_t i;
1910     size_t page_count = m_pages.GetCount();
1911     size_t button_count = m_buttons.GetCount();
1912
1913     // Hasn't been rendered yet; assume it's visible
1914     if (m_tab_close_buttons.GetCount() < page_count)
1915         return true;
1916
1917     // First check if both buttons are disabled - if so, there's no need to
1918     // check further for visibility.
1919     int arrowButtonVisibleCount = 0;
1920     for (i = 0; i < button_count; ++i)
1921     {
1922         wxAuiTabContainerButton& button = m_buttons.Item(i);
1923         if (button.id == wxAUI_BUTTON_LEFT ||
1924             button.id == wxAUI_BUTTON_RIGHT)
1925         {
1926             if ((button.cur_state & wxAUI_BUTTON_STATE_HIDDEN) == 0)
1927                 arrowButtonVisibleCount ++;
1928         }
1929     }
1930
1931     // Tab must be visible
1932     if (arrowButtonVisibleCount == 0)
1933         return true;
1934
1935     // If tab is less than the given offset, it must be invisible by definition
1936     if (tabPage < tabOffset)
1937         return false;
1938
1939     // draw buttons
1940     int left_buttons_width = 0;
1941     int right_buttons_width = 0;
1942
1943     int offset = 0;
1944
1945     // calculate size of the buttons on the right side
1946     offset = m_rect.x + m_rect.width;
1947     for (i = 0; i < button_count; ++i)
1948     {
1949         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1950
1951         if (button.location != wxRIGHT)
1952             continue;
1953         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1954             continue;
1955
1956         offset -= button.rect.GetWidth();
1957         right_buttons_width += button.rect.GetWidth();
1958     }
1959
1960     offset = 0;
1961
1962     // calculate size of the buttons on the left side
1963     for (i = 0; i < button_count; ++i)
1964     {
1965         wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1966
1967         if (button.location != wxLEFT)
1968             continue;
1969         if (button.cur_state & wxAUI_BUTTON_STATE_HIDDEN)
1970             continue;
1971
1972         offset += button.rect.GetWidth();
1973         left_buttons_width += button.rect.GetWidth();
1974     }
1975
1976     offset = left_buttons_width;
1977
1978     if (offset == 0)
1979         offset += m_art->GetIndentSize();
1980
1981     wxRect active_rect;
1982
1983     wxRect rect = m_rect;
1984     rect.y = 0;
1985     rect.height = m_rect.height;
1986
1987     // See if the given page is visible at the given tab offset (effectively scroll position)
1988     for (i = tabOffset; i < page_count; ++i)
1989     {
1990         wxAuiNotebookPage& page = m_pages.Item(i);
1991         wxAuiTabContainerButton& tab_button = m_tab_close_buttons.Item(i);
1992
1993         rect.x = offset;
1994         rect.width = m_rect.width - right_buttons_width - offset - 2;
1995
1996         if (rect.width <= 0)
1997             return false; // haven't found the tab, and we've run out of space, so return false
1998
1999         int x_extent = 0;
2000         wxSize size = m_art->GetTabSize(*dc,
2001                             wnd,
2002                             page.caption,
2003                             page.bitmap,
2004                             page.active,
2005                             tab_button.cur_state,
2006                             &x_extent);
2007
2008         offset += x_extent;
2009
2010         if (i == (size_t) tabPage)
2011         {
2012             // If not all of the tab is visible, and supposing there's space to display it all,
2013             // we could do better so we return false.
2014             if (((m_rect.width - right_buttons_width - offset - 2) <= 0) && ((m_rect.width - right_buttons_width - left_buttons_width) > x_extent))
2015                 return false;
2016             else
2017                 return true;
2018         }
2019     }
2020
2021     // Shouldn't really get here, but if it does, assume the tab is visible to prevent
2022     // further looping in calling code.
2023     return true;
2024 }
2025
2026 // Make the tab visible if it wasn't already
2027 void wxAuiTabContainer::MakeTabVisible(int tabPage, wxWindow* win)
2028 {
2029     wxClientDC dc(win);
2030     if (!IsTabVisible(tabPage, GetTabOffset(), & dc, win))
2031     {
2032         int i;
2033         for (i = 0; i < (int) m_pages.GetCount(); i++)
2034         {
2035             if (IsTabVisible(tabPage, i, & dc, win))
2036             {
2037                 SetTabOffset(i);
2038                 win->Refresh();
2039                 return;
2040             }
2041         }
2042     }
2043 }
2044
2045 // TabHitTest() tests if a tab was hit, passing the window pointer
2046 // back if that condition was fulfilled.  The function returns
2047 // true if a tab was hit, otherwise false
2048 bool wxAuiTabContainer::TabHitTest(int x, int y, wxWindow** hit) const
2049 {
2050     if (!m_rect.Contains(x,y))
2051         return false;
2052
2053     wxAuiTabContainerButton* btn = NULL;
2054     if (ButtonHitTest(x, y, &btn))
2055     {
2056         if (m_buttons.Index(*btn) != wxNOT_FOUND)
2057             return false;
2058     }
2059
2060     size_t i, page_count = m_pages.GetCount();
2061
2062     for (i = m_tab_offset; i < page_count; ++i)
2063     {
2064         wxAuiNotebookPage& page = m_pages.Item(i);
2065         if (page.rect.Contains(x,y))
2066         {
2067             if (hit)
2068                 *hit = page.window;
2069             return true;
2070         }
2071     }
2072
2073     return false;
2074 }
2075
2076 // ButtonHitTest() tests if a button was hit. The function returns
2077 // true if a button was hit, otherwise false
2078 bool wxAuiTabContainer::ButtonHitTest(int x, int y,
2079                                       wxAuiTabContainerButton** hit) const
2080 {
2081     if (!m_rect.Contains(x,y))
2082         return false;
2083
2084     size_t i, button_count;
2085
2086
2087     button_count = m_buttons.GetCount();
2088     for (i = 0; i < button_count; ++i)
2089     {
2090         wxAuiTabContainerButton& button = m_buttons.Item(i);
2091         if (button.rect.Contains(x,y) &&
2092             !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
2093                                    wxAUI_BUTTON_STATE_DISABLED)))
2094         {
2095             if (hit)
2096                 *hit = &button;
2097             return true;
2098         }
2099     }
2100
2101     button_count = m_tab_close_buttons.GetCount();
2102     for (i = 0; i < button_count; ++i)
2103     {
2104         wxAuiTabContainerButton& button = m_tab_close_buttons.Item(i);
2105         if (button.rect.Contains(x,y) &&
2106             !(button.cur_state & (wxAUI_BUTTON_STATE_HIDDEN |
2107                                    wxAUI_BUTTON_STATE_DISABLED)))
2108         {
2109             if (hit)
2110                 *hit = &button;
2111             return true;
2112         }
2113     }
2114
2115     return false;
2116 }
2117
2118
2119
2120 // the utility function ShowWnd() is the same as show,
2121 // except it handles wxAuiMDIChildFrame windows as well,
2122 // as the Show() method on this class is "unplugged"
2123 static void ShowWnd(wxWindow* wnd, bool show)
2124 {
2125 #if wxUSE_MDI
2126     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2127     {
2128         wxAuiMDIChildFrame* cf = (wxAuiMDIChildFrame*)wnd;
2129         cf->DoShow(show);
2130     }
2131     else
2132 #endif
2133     {
2134         wnd->Show(show);
2135     }
2136 }
2137
2138
2139 // DoShowHide() this function shows the active window, then
2140 // hides all of the other windows (in that order)
2141 void wxAuiTabContainer::DoShowHide()
2142 {
2143     wxAuiNotebookPageArray& pages = GetPages();
2144     size_t i, page_count = pages.GetCount();
2145
2146     // show new active page first
2147     for (i = 0; i < page_count; ++i)
2148     {
2149         wxAuiNotebookPage& page = pages.Item(i);
2150         if (page.active)
2151         {
2152             ShowWnd(page.window, true);
2153             break;
2154         }
2155     }
2156
2157     // hide all other pages
2158     for (i = 0; i < page_count; ++i)
2159     {
2160         wxAuiNotebookPage& page = pages.Item(i);
2161         if (!page.active)
2162             ShowWnd(page.window, false);
2163     }
2164 }
2165
2166
2167
2168
2169
2170
2171 // -- wxAuiTabCtrl class implementation --
2172
2173
2174
2175 BEGIN_EVENT_TABLE(wxAuiTabCtrl, wxControl)
2176     EVT_PAINT(wxAuiTabCtrl::OnPaint)
2177     EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
2178     EVT_SIZE(wxAuiTabCtrl::OnSize)
2179     EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
2180     EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDClick)
2181     EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
2182     EVT_MIDDLE_DOWN(wxAuiTabCtrl::OnMiddleDown)
2183     EVT_MIDDLE_UP(wxAuiTabCtrl::OnMiddleUp)
2184     EVT_RIGHT_DOWN(wxAuiTabCtrl::OnRightDown)
2185     EVT_RIGHT_UP(wxAuiTabCtrl::OnRightUp)
2186     EVT_MOTION(wxAuiTabCtrl::OnMotion)
2187     EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
2188     EVT_AUINOTEBOOK_BUTTON(wxID_ANY, wxAuiTabCtrl::OnButton)
2189     EVT_SET_FOCUS(wxAuiTabCtrl::OnSetFocus)
2190     EVT_KILL_FOCUS(wxAuiTabCtrl::OnKillFocus)
2191     EVT_CHAR(wxAuiTabCtrl::OnChar)
2192     EVT_MOUSE_CAPTURE_LOST(wxAuiTabCtrl::OnCaptureLost)
2193 END_EVENT_TABLE()
2194
2195
2196 wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent,
2197                            wxWindowID id,
2198                            const wxPoint& pos,
2199                            const wxSize& size,
2200                            long style) : wxControl(parent, id, pos, size, style)
2201 {
2202     SetName(wxT("wxAuiTabCtrl"));
2203     m_click_pt = wxDefaultPosition;
2204     m_is_dragging = false;
2205     m_hover_button = NULL;
2206     m_pressed_button = NULL;
2207 }
2208
2209 wxAuiTabCtrl::~wxAuiTabCtrl()
2210 {
2211 }
2212
2213 void wxAuiTabCtrl::OnPaint(wxPaintEvent&)
2214 {
2215     wxPaintDC dc(this);
2216
2217     dc.SetFont(GetFont());
2218
2219     if (GetPageCount() > 0)
2220         Render(&dc, this);
2221 }
2222
2223 void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
2224 {
2225 }
2226
2227 void wxAuiTabCtrl::OnSize(wxSizeEvent& evt)
2228 {
2229     wxSize s = evt.GetSize();
2230     wxRect r(0, 0, s.GetWidth(), s.GetHeight());
2231     SetRect(r);
2232 }
2233
2234 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
2235 {
2236     CaptureMouse();
2237     m_click_pt = wxDefaultPosition;
2238     m_is_dragging = false;
2239     m_click_tab = NULL;
2240     m_pressed_button = NULL;
2241
2242
2243     wxWindow* wnd;
2244     if (TabHitTest(evt.m_x, evt.m_y, &wnd))
2245     {
2246         int new_selection = GetIdxFromWindow(wnd);
2247
2248         // wxAuiNotebooks always want to receive this event
2249         // even if the tab is already active, because they may
2250         // have multiple tab controls
2251         if (new_selection != GetActivePage() ||
2252             GetParent()->IsKindOf(CLASSINFO(wxAuiNotebook)))
2253         {
2254             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2255             e.SetSelection(new_selection);
2256             e.SetOldSelection(GetActivePage());
2257             e.SetEventObject(this);
2258             GetEventHandler()->ProcessEvent(e);
2259         }
2260
2261         m_click_pt.x = evt.m_x;
2262         m_click_pt.y = evt.m_y;
2263         m_click_tab = wnd;
2264     }
2265
2266     if (m_hover_button)
2267     {
2268         m_pressed_button = m_hover_button;
2269         m_pressed_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
2270         Refresh();
2271         Update();
2272     }
2273 }
2274
2275 void wxAuiTabCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
2276 {
2277 }
2278
2279 void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
2280 {
2281     if (GetCapture() == this)
2282         ReleaseMouse();
2283
2284     if (m_is_dragging)
2285     {
2286         m_is_dragging = false;
2287
2288         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
2289         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2290         evt.SetOldSelection(evt.GetSelection());
2291         evt.SetEventObject(this);
2292         GetEventHandler()->ProcessEvent(evt);
2293
2294         return;
2295     }
2296
2297     if (m_pressed_button)
2298     {
2299         // make sure we're still clicking the button
2300         wxAuiTabContainerButton* button = NULL;
2301         if (!ButtonHitTest(evt.m_x, evt.m_y, &button))
2302             return;
2303
2304         if (button != m_pressed_button)
2305         {
2306             m_pressed_button = NULL;
2307             return;
2308         }
2309
2310         Refresh();
2311         Update();
2312
2313         if (!(m_pressed_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
2314         {
2315             wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
2316             evt.SetSelection(GetIdxFromWindow(m_click_tab));
2317             evt.SetInt(m_pressed_button->id);
2318             evt.SetEventObject(this);
2319             GetEventHandler()->ProcessEvent(evt);
2320         }
2321
2322         m_pressed_button = NULL;
2323     }
2324
2325     m_click_pt = wxDefaultPosition;
2326     m_is_dragging = false;
2327     m_click_tab = NULL;
2328 }
2329
2330 void wxAuiTabCtrl::OnMiddleUp(wxMouseEvent& evt)
2331 {
2332     wxWindow* wnd = NULL;
2333     if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2334         return;
2335
2336     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
2337     e.SetEventObject(this);
2338     e.SetSelection(GetIdxFromWindow(wnd));
2339     GetEventHandler()->ProcessEvent(e);
2340 }
2341
2342 void wxAuiTabCtrl::OnMiddleDown(wxMouseEvent& evt)
2343 {
2344     wxWindow* wnd = NULL;
2345     if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2346         return;
2347
2348     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
2349     e.SetEventObject(this);
2350     e.SetSelection(GetIdxFromWindow(wnd));
2351     GetEventHandler()->ProcessEvent(e);
2352 }
2353
2354 void wxAuiTabCtrl::OnRightUp(wxMouseEvent& evt)
2355 {
2356     wxWindow* wnd = NULL;
2357     if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2358         return;
2359
2360     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
2361     e.SetEventObject(this);
2362     e.SetSelection(GetIdxFromWindow(wnd));
2363     GetEventHandler()->ProcessEvent(e);
2364 }
2365
2366 void wxAuiTabCtrl::OnRightDown(wxMouseEvent& evt)
2367 {
2368     wxWindow* wnd = NULL;
2369     if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2370         return;
2371
2372     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
2373     e.SetEventObject(this);
2374     e.SetSelection(GetIdxFromWindow(wnd));
2375     GetEventHandler()->ProcessEvent(e);
2376 }
2377
2378 void wxAuiTabCtrl::OnLeftDClick(wxMouseEvent& evt)
2379 {
2380     wxWindow* wnd;
2381     wxAuiTabContainerButton* button;
2382     if (!TabHitTest(evt.m_x, evt.m_y, &wnd) && !ButtonHitTest(evt.m_x, evt.m_y, &button))
2383     {
2384         wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
2385         e.SetEventObject(this);
2386         GetEventHandler()->ProcessEvent(e);
2387     }
2388 }
2389
2390 void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
2391 {
2392     wxPoint pos = evt.GetPosition();
2393
2394     // check if the mouse is hovering above a button
2395     wxAuiTabContainerButton* button;
2396     if (ButtonHitTest(pos.x, pos.y, &button))
2397     {
2398         if (m_hover_button && button != m_hover_button)
2399         {
2400             m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2401             m_hover_button = NULL;
2402             Refresh();
2403             Update();
2404         }
2405
2406         if (button->cur_state != wxAUI_BUTTON_STATE_HOVER)
2407         {
2408             button->cur_state = wxAUI_BUTTON_STATE_HOVER;
2409             Refresh();
2410             Update();
2411             m_hover_button = button;
2412             return;
2413         }
2414     }
2415     else
2416     {
2417         if (m_hover_button)
2418         {
2419             m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2420             m_hover_button = NULL;
2421             Refresh();
2422             Update();
2423         }
2424     }
2425
2426
2427     if (!evt.LeftIsDown() || m_click_pt == wxDefaultPosition)
2428         return;
2429
2430     if (m_is_dragging)
2431     {
2432         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
2433         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2434         evt.SetOldSelection(evt.GetSelection());
2435         evt.SetEventObject(this);
2436         GetEventHandler()->ProcessEvent(evt);
2437         return;
2438     }
2439
2440
2441     int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
2442     int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
2443
2444     if (abs(pos.x - m_click_pt.x) > drag_x_threshold ||
2445         abs(pos.y - m_click_pt.y) > drag_y_threshold)
2446     {
2447         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
2448         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2449         evt.SetOldSelection(evt.GetSelection());
2450         evt.SetEventObject(this);
2451         GetEventHandler()->ProcessEvent(evt);
2452
2453         m_is_dragging = true;
2454     }
2455 }
2456
2457 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
2458 {
2459     if (m_hover_button)
2460     {
2461         m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2462         m_hover_button = NULL;
2463         Refresh();
2464         Update();
2465     }
2466 }
2467
2468 void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
2469 {
2470     int button = event.GetInt();
2471
2472     if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
2473     {
2474         if (button == wxAUI_BUTTON_LEFT)
2475         {
2476             if (GetTabOffset() > 0)
2477             {
2478                 SetTabOffset(GetTabOffset()-1);
2479                 Refresh();
2480                 Update();
2481             }
2482         }
2483         else
2484         {
2485             SetTabOffset(GetTabOffset()+1);
2486             Refresh();
2487             Update();
2488         }
2489     }
2490     else if (button == wxAUI_BUTTON_WINDOWLIST)
2491     {
2492         int idx = GetArtProvider()->ShowDropDown(this, m_pages, GetActivePage());
2493
2494         if (idx != -1)
2495         {
2496             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2497             e.SetSelection(idx);
2498             e.SetOldSelection(GetActivePage());
2499             e.SetEventObject(this);
2500             GetEventHandler()->ProcessEvent(e);
2501         }
2502     }
2503     else
2504     {
2505         event.Skip();
2506     }
2507 }
2508
2509 void wxAuiTabCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
2510 {
2511     Refresh();
2512 }
2513
2514 void wxAuiTabCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
2515 {
2516     Refresh();
2517 }
2518
2519 void wxAuiTabCtrl::OnChar(wxKeyEvent& event)
2520 {
2521     if (GetActivePage() == -1)
2522     {
2523         event.Skip();
2524         return;
2525     }
2526
2527     // We can't leave tab processing to the system; on Windows, tabs and keys
2528     // get eaten by the system and not processed properly if we specify both
2529     // wxTAB_TRAVERSAL and wxWANTS_CHARS. And if we specify just wxTAB_TRAVERSAL,
2530     // we don't key arrow key events.
2531
2532     int key = event.GetKeyCode();
2533
2534     if (key == WXK_NUMPAD_PAGEUP)
2535         key = WXK_PAGEUP;
2536     if (key == WXK_NUMPAD_PAGEDOWN)
2537         key = WXK_PAGEDOWN;
2538     if (key == WXK_NUMPAD_HOME)
2539         key = WXK_HOME;
2540     if (key == WXK_NUMPAD_END)
2541         key = WXK_END;
2542     if (key == WXK_NUMPAD_LEFT)
2543         key = WXK_LEFT;
2544     if (key == WXK_NUMPAD_RIGHT)
2545         key = WXK_RIGHT;
2546
2547     if (key == WXK_TAB || key == WXK_PAGEUP || key == WXK_PAGEDOWN)
2548     {
2549         bool bCtrlDown = event.ControlDown();
2550         bool bShiftDown = event.ShiftDown();
2551
2552         bool bForward = (key == WXK_TAB && !bShiftDown) || (key == WXK_PAGEDOWN);
2553         bool bWindowChange = (key == WXK_PAGEUP) || (key == WXK_PAGEDOWN) || bCtrlDown;
2554         bool bFromTab = (key == WXK_TAB);
2555
2556         wxAuiNotebook* nb = wxDynamicCast(GetParent(), wxAuiNotebook);
2557         if (!nb)
2558         {
2559             event.Skip();
2560             return;
2561         }
2562
2563         wxNavigationKeyEvent keyEvent;
2564         keyEvent.SetDirection(bForward);
2565         keyEvent.SetWindowChange(bWindowChange);
2566         keyEvent.SetFromTab(bFromTab);
2567         keyEvent.SetEventObject(nb);
2568
2569         if (!nb->GetEventHandler()->ProcessEvent(keyEvent))
2570         {
2571             // Not processed? Do an explicit tab into the page.
2572             wxWindow* win = GetWindowFromIdx(GetActivePage());
2573             if (win)
2574                 win->SetFocus();
2575         }
2576         return;
2577     }
2578
2579     if (m_pages.GetCount() < 2)
2580     {
2581         event.Skip();
2582         return;
2583     }
2584
2585     int newPage = -1;
2586
2587     int forwardKey, backwardKey;
2588     if (GetLayoutDirection() == wxLayout_RightToLeft)
2589     {
2590         forwardKey = WXK_LEFT;
2591         backwardKey = WXK_RIGHT;
2592     }
2593     else
2594      {
2595         forwardKey = WXK_RIGHT;
2596         backwardKey = WXK_LEFT;
2597     }
2598
2599     if (key == forwardKey)
2600     {
2601         if (m_pages.GetCount() > 1)
2602         {
2603             if (GetActivePage() == -1)
2604                 newPage = 0;
2605             else if (GetActivePage() < (int) (m_pages.GetCount() - 1))
2606                 newPage = GetActivePage() + 1;
2607         }
2608     }
2609     else if (key == backwardKey)
2610     {
2611         if (m_pages.GetCount() > 1)
2612         {
2613             if (GetActivePage() == -1)
2614                 newPage = (int) (m_pages.GetCount() - 1);
2615             else if (GetActivePage() > 0)
2616                 newPage = GetActivePage() - 1;
2617         }
2618     }
2619     else if (key == WXK_HOME)
2620     {
2621         newPage = 0;
2622     }
2623     else if (key == WXK_END)
2624     {
2625         newPage = (int) (m_pages.GetCount() - 1);
2626     }
2627     else
2628         event.Skip();
2629
2630     if (newPage != -1)
2631     {
2632         wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2633         e.SetSelection(newPage);
2634         e.SetOldSelection(newPage);
2635         e.SetEventObject(this);
2636         this->GetEventHandler()->ProcessEvent(e);
2637     }
2638     else
2639         event.Skip();
2640 }
2641
2642 // wxTabFrame is an interesting case.  It's important that all child pages
2643 // of the multi-notebook control are all actually children of that control
2644 // (and not grandchildren).  wxTabFrame facilitates this.  There is one
2645 // instance of wxTabFrame for each tab control inside the multi-notebook.
2646 // It's important to know that wxTabFrame is not a real window, but it merely
2647 // used to capture the dimensions/positioning of the internal tab control and
2648 // it's managed page windows
2649
2650 class wxTabFrame : public wxWindow
2651 {
2652 public:
2653
2654     wxTabFrame()
2655     {
2656         m_tabs = NULL;
2657         m_rect = wxRect(0,0,200,200);
2658         m_tab_ctrl_height = 20;
2659     }
2660
2661     ~wxTabFrame()
2662     {
2663         wxDELETE(m_tabs);
2664     }
2665
2666     void SetTabCtrlHeight(int h)
2667     {
2668         m_tab_ctrl_height = h;
2669     }
2670
2671 protected:
2672     void DoSetSize(int x, int y,
2673                    int width, int height,
2674                    int WXUNUSED(sizeFlags = wxSIZE_AUTO))
2675     {
2676         m_rect = wxRect(x, y, width, height);
2677         DoSizing();
2678     }
2679
2680     void DoGetClientSize(int* x, int* y) const
2681     {
2682         *x = m_rect.width;
2683         *y = m_rect.height;
2684     }
2685
2686 public:
2687     bool Show( bool WXUNUSED(show = true) ) { return false; }
2688
2689     void DoSizing()
2690     {
2691         if (!m_tabs)
2692             return;
2693
2694         if (m_tabs->IsFrozen() || m_tabs->GetParent()->IsFrozen())
2695             return;
2696
2697         m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2698         if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
2699         {
2700             m_tab_rect = wxRect (m_rect.x, m_rect.y + m_rect.height - m_tab_ctrl_height, m_rect.width, m_tab_ctrl_height);
2701             m_tabs->SetSize     (m_rect.x, m_rect.y + m_rect.height - m_tab_ctrl_height, m_rect.width, m_tab_ctrl_height);
2702             m_tabs->SetRect     (wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
2703         }
2704         else //TODO: if (GetFlags() & wxAUI_NB_TOP)
2705         {
2706             m_tab_rect = wxRect (m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2707             m_tabs->SetSize     (m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2708             m_tabs->SetRect     (wxRect(0, 0,        m_rect.width, m_tab_ctrl_height));
2709         }
2710         // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
2711         // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
2712
2713         m_tabs->Refresh();
2714         m_tabs->Update();
2715
2716         wxAuiNotebookPageArray& pages = m_tabs->GetPages();
2717         size_t i, page_count = pages.GetCount();
2718
2719         for (i = 0; i < page_count; ++i)
2720         {
2721             int height = m_rect.height - m_tab_ctrl_height;
2722             if ( height < 0 )
2723             {
2724                 // avoid passing negative height to wxWindow::SetSize(), this
2725                 // results in assert failures/GTK+ warnings
2726                 height = 0;
2727             }
2728
2729             wxAuiNotebookPage& page = pages.Item(i);
2730             if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
2731             {
2732                 page.window->SetSize(m_rect.x, m_rect.y, m_rect.width, height);
2733             }
2734             else //TODO: if (GetFlags() & wxAUI_NB_TOP)
2735             {
2736                 page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
2737                                      m_rect.width, height);
2738             }
2739             // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
2740             // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
2741
2742 #if wxUSE_MDI
2743             if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2744             {
2745                 wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
2746                 wnd->ApplyMDIChildFrameRect();
2747             }
2748 #endif
2749         }
2750     }
2751
2752 protected:
2753     void DoGetSize(int* x, int* y) const
2754     {
2755         if (x)
2756             *x = m_rect.GetWidth();
2757         if (y)
2758             *y = m_rect.GetHeight();
2759     }
2760
2761 public:
2762     void Update()
2763     {
2764         // does nothing
2765     }
2766
2767     wxRect m_rect;
2768     wxRect m_tab_rect;
2769     wxAuiTabCtrl* m_tabs;
2770     int m_tab_ctrl_height;
2771 };
2772
2773
2774 const int wxAuiBaseTabCtrlId = 5380;
2775
2776
2777 // -- wxAuiNotebook class implementation --
2778
2779 #define EVT_AUI_RANGE(id1, id2, event, func) \
2780     wx__DECLARE_EVT2(event, id1, id2, wxAuiNotebookEventHandler(func))
2781
2782 BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
2783     EVT_SIZE(wxAuiNotebook::OnSize)
2784     EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocusNotebook)
2785     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2786                       wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
2787                       wxAuiNotebook::OnTabClicked)
2788     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2789                       wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
2790                       wxAuiNotebook::OnTabBeginDrag)
2791     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2792                       wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
2793                       wxAuiNotebook::OnTabEndDrag)
2794     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2795                       wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
2796                       wxAuiNotebook::OnTabDragMotion)
2797     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2798                       wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
2799                       wxAuiNotebook::OnTabButton)
2800     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2801                       wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN,
2802                       wxAuiNotebook::OnTabMiddleDown)
2803     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2804                       wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP,
2805                       wxAuiNotebook::OnTabMiddleUp)
2806     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2807                       wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN,
2808                       wxAuiNotebook::OnTabRightDown)
2809     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2810                       wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
2811                       wxAuiNotebook::OnTabRightUp)
2812     EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2813                       wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK,
2814                       wxAuiNotebook::OnTabBgDClick)
2815     EVT_NAVIGATION_KEY(wxAuiNotebook::OnNavigationKeyNotebook)
2816
2817 #ifdef wxHAS_NATIVE_TAB_TRAVERSAL
2818     WX_EVENT_TABLE_CONTROL_CONTAINER(wxAuiNotebook)
2819 #else
2820     // Avoid clash with container event handler functions
2821     EVT_SET_FOCUS(wxAuiNotebook::OnFocus)
2822 #endif
2823 END_EVENT_TABLE()
2824
2825 WX_DELEGATE_TO_CONTROL_CONTAINER(wxAuiNotebook, wxControl)
2826
2827 wxAuiNotebook::wxAuiNotebook()
2828 {
2829     m_curpage = -1;
2830     m_tab_id_counter = wxAuiBaseTabCtrlId;
2831     m_dummy_wnd = NULL;
2832     m_tab_ctrl_height = 20;
2833     m_requested_bmp_size = wxDefaultSize;
2834     m_requested_tabctrl_height = -1;
2835 }
2836
2837 wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
2838                              wxWindowID id,
2839                              const wxPoint& pos,
2840                              const wxSize& size,
2841                              long style) : wxControl(parent, id, pos, size, style)
2842 {
2843     m_dummy_wnd = NULL;
2844     m_requested_bmp_size = wxDefaultSize;
2845     m_requested_tabctrl_height = -1;
2846     InitNotebook(style);
2847 }
2848
2849 bool wxAuiNotebook::Create(wxWindow* parent,
2850                            wxWindowID id,
2851                            const wxPoint& pos,
2852                            const wxSize& size,
2853                            long style)
2854 {
2855     if (!wxControl::Create(parent, id, pos, size, style))
2856         return false;
2857
2858     InitNotebook(style);
2859
2860     return true;
2861 }
2862
2863 // InitNotebook() contains common initialization
2864 // code called by all constructors
2865 void wxAuiNotebook::InitNotebook(long style)
2866 {
2867     WX_INIT_CONTROL_CONTAINER();
2868     // SetCanFocus(false);
2869
2870     SetName(wxT("wxAuiNotebook"));
2871     m_curpage = -1;
2872     m_tab_id_counter = wxAuiBaseTabCtrlId;
2873     m_dummy_wnd = NULL;
2874     m_flags = (unsigned int)style;
2875     m_tab_ctrl_height = 20;
2876
2877     m_normal_font = *wxNORMAL_FONT;
2878     m_selected_font = *wxNORMAL_FONT;
2879     m_selected_font.SetWeight(wxBOLD);
2880
2881     SetArtProvider(new wxAuiDefaultTabArt);
2882
2883     m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
2884     m_dummy_wnd->SetSize(200, 200);
2885     m_dummy_wnd->Show(false);
2886
2887     m_mgr.SetManagedWindow(this);
2888     m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
2889     m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
2890
2891     m_mgr.AddPane(m_dummy_wnd,
2892               wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
2893
2894     m_mgr.Update();
2895 }
2896
2897 wxAuiNotebook::~wxAuiNotebook()
2898 {
2899     // Indicate we're deleting pages
2900     SendDestroyEvent();
2901
2902     while ( GetPageCount() > 0 )
2903         DeletePage(0);
2904
2905     m_mgr.UnInit();
2906 }
2907
2908 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
2909 {
2910     m_tabs.SetArtProvider(art);
2911
2912     UpdateTabCtrlHeight();
2913 }
2914
2915 // SetTabCtrlHeight() is the highest-level override of the
2916 // tab height.  A call to this function effectively enforces a
2917 // specified tab ctrl height, overriding all other considerations,
2918 // such as text or bitmap height.  It overrides any call to
2919 // SetUniformBitmapSize().  Specifying a height of -1 reverts
2920 // any previous call and returns to the default behavior
2921
2922 void wxAuiNotebook::SetTabCtrlHeight(int height)
2923 {
2924     m_requested_tabctrl_height = height;
2925
2926     // if window is already initialized, recalculate the tab height
2927     if (m_dummy_wnd)
2928     {
2929         UpdateTabCtrlHeight();
2930     }
2931 }
2932
2933
2934 // SetUniformBitmapSize() ensures that all tabs will have
2935 // the same height, even if some tabs don't have bitmaps
2936 // Passing wxDefaultSize to this function will instruct
2937 // the control to use dynamic tab height-- so when a tab
2938 // with a large bitmap is added, the tab ctrl's height will
2939 // automatically increase to accommodate the bitmap
2940
2941 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
2942 {
2943     m_requested_bmp_size = size;
2944
2945     // if window is already initialized, recalculate the tab height
2946     if (m_dummy_wnd)
2947     {
2948         UpdateTabCtrlHeight();
2949     }
2950 }
2951
2952 // UpdateTabCtrlHeight() does the actual tab resizing. It's meant
2953 // to be used interally
2954 void wxAuiNotebook::UpdateTabCtrlHeight()
2955 {
2956     // get the tab ctrl height we will use
2957     int height = CalculateTabCtrlHeight();
2958
2959     // if the tab control height needs to change, update
2960     // all of our tab controls with the new height
2961     if (m_tab_ctrl_height != height)
2962     {
2963         wxAuiTabArt* art = m_tabs.GetArtProvider();
2964
2965         m_tab_ctrl_height = height;
2966
2967         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2968         size_t i, pane_count = all_panes.GetCount();
2969         for (i = 0; i < pane_count; ++i)
2970         {
2971             wxAuiPaneInfo& pane = all_panes.Item(i);
2972             if (pane.name == wxT("dummy"))
2973                 continue;
2974             wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
2975             wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
2976             tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
2977             tabctrl->SetArtProvider(art->Clone());
2978             tab_frame->DoSizing();
2979         }
2980     }
2981 }
2982
2983 void wxAuiNotebook::UpdateHintWindowSize()
2984 {
2985     wxSize size = CalculateNewSplitSize();
2986
2987     // the placeholder hint window should be set to this size
2988     wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
2989     if (info.IsOk())
2990     {
2991         info.MinSize(size);
2992         info.BestSize(size);
2993         m_dummy_wnd->SetSize(size);
2994     }
2995 }
2996
2997
2998 // calculates the size of the new split
2999 wxSize wxAuiNotebook::CalculateNewSplitSize()
3000 {
3001     // count number of tab controls
3002     int tab_ctrl_count = 0;
3003     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3004     size_t i, pane_count = all_panes.GetCount();
3005     for (i = 0; i < pane_count; ++i)
3006     {
3007         wxAuiPaneInfo& pane = all_panes.Item(i);
3008         if (pane.name == wxT("dummy"))
3009             continue;
3010         tab_ctrl_count++;
3011     }
3012
3013     wxSize new_split_size;
3014
3015     // if there is only one tab control, the first split
3016     // should happen around the middle
3017     if (tab_ctrl_count < 2)
3018     {
3019         new_split_size = GetClientSize();
3020         new_split_size.x /= 2;
3021         new_split_size.y /= 2;
3022     }
3023     else
3024     {
3025         // this is in place of a more complicated calculation
3026         // that needs to be implemented
3027         new_split_size = wxSize(180,180);
3028     }
3029
3030     return new_split_size;
3031 }
3032
3033 int wxAuiNotebook::CalculateTabCtrlHeight()
3034 {
3035     // if a fixed tab ctrl height is specified,
3036     // just return that instead of calculating a
3037     // tab height
3038     if (m_requested_tabctrl_height != -1)
3039         return m_requested_tabctrl_height;
3040
3041     // find out new best tab height
3042     wxAuiTabArt* art = m_tabs.GetArtProvider();
3043
3044     return art->GetBestTabCtrlSize(this,
3045                                    m_tabs.GetPages(),
3046                                    m_requested_bmp_size);
3047 }
3048
3049
3050 wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
3051 {
3052     return m_tabs.GetArtProvider();
3053 }
3054
3055 void wxAuiNotebook::SetWindowStyleFlag(long style)
3056 {
3057     wxControl::SetWindowStyleFlag(style);
3058
3059     m_flags = (unsigned int)style;
3060
3061     // if the control is already initialized
3062     if (m_mgr.GetManagedWindow() == (wxWindow*)this)
3063     {
3064         // let all of the tab children know about the new style
3065
3066         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3067         size_t i, pane_count = all_panes.GetCount();
3068         for (i = 0; i < pane_count; ++i)
3069         {
3070             wxAuiPaneInfo& pane = all_panes.Item(i);
3071             if (pane.name == wxT("dummy"))
3072                 continue;
3073             wxTabFrame* tabframe = (wxTabFrame*)pane.window;
3074             wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
3075             tabctrl->SetFlags(m_flags);
3076             tabframe->DoSizing();
3077             tabctrl->Refresh();
3078             tabctrl->Update();
3079         }
3080     }
3081 }
3082
3083
3084 bool wxAuiNotebook::AddPage(wxWindow* page,
3085                             const wxString& caption,
3086                             bool select,
3087                             const wxBitmap& bitmap)
3088 {
3089     return InsertPage(GetPageCount(), page, caption, select, bitmap);
3090 }
3091
3092 bool wxAuiNotebook::InsertPage(size_t page_idx,
3093                                wxWindow* page,
3094                                const wxString& caption,
3095                                bool select,
3096                                const wxBitmap& bitmap)
3097 {
3098     wxASSERT_MSG(page, wxT("page pointer must be non-NULL"));
3099     if (!page)
3100         return false;
3101
3102     page->Reparent(this);
3103
3104     wxAuiNotebookPage info;
3105     info.window = page;
3106     info.caption = caption;
3107     info.bitmap = bitmap;
3108     info.active = false;
3109
3110     // if there are currently no tabs, the first added
3111     // tab must be active
3112     if (m_tabs.GetPageCount() == 0)
3113         info.active = true;
3114
3115     m_tabs.InsertPage(page, info, page_idx);
3116
3117     // if that was the first page added, even if
3118     // select is false, it must become the "current page"
3119     // (though no select events will be fired)
3120     if (!select && m_tabs.GetPageCount() == 1)
3121         select = true;
3122         //m_curpage = GetPageIndex(page);
3123
3124     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
3125     if (page_idx >= active_tabctrl->GetPageCount())
3126         active_tabctrl->AddPage(page, info);
3127     else
3128         active_tabctrl->InsertPage(page, info, page_idx);
3129
3130     UpdateTabCtrlHeight();
3131     DoSizing();
3132     active_tabctrl->DoShowHide();
3133
3134     // adjust selected index
3135     if(m_curpage >= (int) page_idx)
3136         m_curpage++;
3137
3138     if (select)
3139     {
3140         SetSelectionToWindow(page);
3141     }
3142
3143     return true;
3144 }
3145
3146
3147 // DeletePage() removes a tab from the multi-notebook,
3148 // and destroys the window as well
3149 bool wxAuiNotebook::DeletePage(size_t page_idx)
3150 {
3151     if (page_idx >= m_tabs.GetPageCount())
3152         return false;
3153
3154     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3155
3156     // hide the window in advance, as this will
3157     // prevent flicker
3158     ShowWnd(wnd, false);
3159
3160     if (!RemovePage(page_idx))
3161         return false;
3162
3163 #if wxUSE_MDI
3164     // actually destroy the window now
3165     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3166     {
3167         // delete the child frame with pending delete, as is
3168         // customary with frame windows
3169         if (!wxPendingDelete.Member(wnd))
3170             wxPendingDelete.Append(wnd);
3171     }
3172     else
3173 #endif
3174     {
3175         wnd->Destroy();
3176     }
3177
3178     return true;
3179 }
3180
3181
3182
3183 // RemovePage() removes a tab from the multi-notebook,
3184 // but does not destroy the window
3185 bool wxAuiNotebook::RemovePage(size_t page_idx)
3186 {
3187     // save active window pointer
3188     wxWindow* active_wnd = NULL;
3189     if (m_curpage >= 0)
3190         active_wnd = m_tabs.GetWindowFromIdx(m_curpage);
3191
3192     // save pointer of window being deleted
3193     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3194     wxWindow* new_active = NULL;
3195
3196     // make sure we found the page
3197     if (!wnd)
3198         return false;
3199
3200     // find out which onscreen tab ctrl owns this tab
3201     wxAuiTabCtrl* ctrl;
3202     int ctrl_idx;
3203     if (!FindTab(wnd, &ctrl, &ctrl_idx))
3204         return false;
3205
3206     bool is_curpage = (m_curpage == (int)page_idx);
3207     bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
3208
3209
3210     // remove the tab from main catalog
3211     if (!m_tabs.RemovePage(wnd))
3212         return false;
3213
3214     // remove the tab from the onscreen tab ctrl
3215     ctrl->RemovePage(wnd);
3216
3217     if (is_active_in_split)
3218     {
3219         int ctrl_new_page_count = (int)ctrl->GetPageCount();
3220
3221         if (ctrl_idx >= ctrl_new_page_count)
3222             ctrl_idx = ctrl_new_page_count-1;
3223
3224         if (ctrl_idx >= 0 && ctrl_idx < (int)ctrl->GetPageCount())
3225         {
3226             // set new page as active in the tab split
3227             ctrl->SetActivePage(ctrl_idx);
3228
3229             // if the page deleted was the current page for the
3230             // entire tab control, then record the window
3231             // pointer of the new active page for activation
3232             if (is_curpage)
3233             {
3234                 new_active = ctrl->GetWindowFromIdx(ctrl_idx);
3235             }
3236         }
3237     }
3238     else
3239     {
3240         // we are not deleting the active page, so keep it the same
3241         new_active = active_wnd;
3242     }
3243
3244
3245     if (!new_active)
3246     {
3247         // we haven't yet found a new page to active,
3248         // so select the next page from the main tab
3249         // catalogue
3250
3251         if (page_idx < m_tabs.GetPageCount())
3252         {
3253             new_active = m_tabs.GetPage(page_idx).window;
3254         }
3255
3256         if (!new_active && m_tabs.GetPageCount() > 0)
3257         {
3258             new_active = m_tabs.GetPage(0).window;
3259         }
3260     }
3261
3262
3263     RemoveEmptyTabFrames();
3264
3265     m_curpage = wxNOT_FOUND;
3266
3267     // set new active pane unless we're being destroyed anyhow
3268     if (new_active && !m_isBeingDeleted)
3269         SetSelectionToWindow(new_active);
3270
3271     return true;
3272 }
3273
3274 // GetPageIndex() returns the index of the page, or -1 if the
3275 // page could not be located in the notebook
3276 int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
3277 {
3278     return m_tabs.GetIdxFromWindow(page_wnd);
3279 }
3280
3281
3282
3283 // SetPageText() changes the tab caption of the specified page
3284 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
3285 {
3286     if (page_idx >= m_tabs.GetPageCount())
3287         return false;
3288
3289     // update our own tab catalog
3290     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3291     page_info.caption = text;
3292
3293     // update what's on screen
3294     wxAuiTabCtrl* ctrl;
3295     int ctrl_idx;
3296     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3297     {
3298         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3299         info.caption = text;
3300         ctrl->Refresh();
3301         ctrl->Update();
3302     }
3303
3304     return true;
3305 }
3306
3307 // returns the page caption
3308 wxString wxAuiNotebook::GetPageText(size_t page_idx) const
3309 {
3310     if (page_idx >= m_tabs.GetPageCount())
3311         return wxEmptyString;
3312
3313     // update our own tab catalog
3314     const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3315     return page_info.caption;
3316 }
3317
3318 bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
3319 {
3320     if (page_idx >= m_tabs.GetPageCount())
3321         return false;
3322
3323     // update our own tab catalog
3324     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3325     page_info.bitmap = bitmap;
3326
3327     // tab height might have changed
3328     UpdateTabCtrlHeight();
3329
3330     // update what's on screen
3331     wxAuiTabCtrl* ctrl;
3332     int ctrl_idx;
3333     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3334     {
3335         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3336         info.bitmap = bitmap;
3337         ctrl->Refresh();
3338         ctrl->Update();
3339     }
3340
3341     return true;
3342 }
3343
3344 // returns the page bitmap
3345 wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
3346 {
3347     if (page_idx >= m_tabs.GetPageCount())
3348         return wxBitmap();
3349
3350     // update our own tab catalog
3351     const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3352     return page_info.bitmap;
3353 }
3354
3355 // GetSelection() returns the index of the currently active page
3356 int wxAuiNotebook::GetSelection() const
3357 {
3358     return m_curpage;
3359 }
3360
3361 // SetSelection() sets the currently active page
3362 size_t wxAuiNotebook::SetSelection(size_t new_page)
3363 {
3364     wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
3365     if (!wnd)
3366         return m_curpage;
3367
3368     // don't change the page unless necessary;
3369     // however, clicking again on a tab should give it the focus.
3370     if ((int)new_page == m_curpage)
3371     {
3372         wxAuiTabCtrl* ctrl;
3373         int ctrl_idx;
3374         if (FindTab(wnd, &ctrl, &ctrl_idx))
3375         {
3376             if (FindFocus() != ctrl)
3377                 ctrl->SetFocus();
3378         }
3379         return m_curpage;
3380     }
3381
3382     wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
3383     evt.SetSelection(new_page);
3384     evt.SetOldSelection(m_curpage);
3385     evt.SetEventObject(this);
3386     if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
3387     {
3388         int old_curpage = m_curpage;
3389         m_curpage = new_page;
3390
3391         // program allows the page change
3392         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
3393         (void)GetEventHandler()->ProcessEvent(evt);
3394
3395
3396         wxAuiTabCtrl* ctrl;
3397         int ctrl_idx;
3398         if (FindTab(wnd, &ctrl, &ctrl_idx))
3399         {
3400             m_tabs.SetActivePage(wnd);
3401
3402             ctrl->SetActivePage(ctrl_idx);
3403             DoSizing();
3404             ctrl->DoShowHide();
3405
3406             ctrl->MakeTabVisible(ctrl_idx, ctrl);
3407
3408             // set fonts
3409             wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3410             size_t i, pane_count = all_panes.GetCount();
3411             for (i = 0; i < pane_count; ++i)
3412             {
3413                 wxAuiPaneInfo& pane = all_panes.Item(i);
3414                 if (pane.name == wxT("dummy"))
3415                     continue;
3416                 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
3417                 if (tabctrl != ctrl)
3418                     tabctrl->SetSelectedFont(m_normal_font);
3419                 else
3420                     tabctrl->SetSelectedFont(m_selected_font);
3421                 tabctrl->Refresh();
3422             }
3423
3424             // Set the focus to the page if we're not currently focused on the tab.
3425             // This is Firefox-like behaviour.
3426             if (wnd->IsShownOnScreen() && FindFocus() != ctrl)
3427                 wnd->SetFocus();
3428
3429             return old_curpage;
3430         }
3431     }
3432
3433     return m_curpage;
3434 }
3435
3436 void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
3437 {
3438     const int idx = m_tabs.GetIdxFromWindow(win);
3439     wxCHECK_RET( idx != wxNOT_FOUND, wxT("invalid notebook page") );
3440
3441
3442     // since a tab was clicked, let the parent know that we received
3443     // the focus, even if we will assign that focus immediately
3444     // to the child tab in the SetSelection call below
3445     // (the child focus event will also let wxAuiManager, if any,
3446     // know that the notebook control has been activated)
3447
3448     wxWindow* parent = GetParent();
3449     if (parent)
3450     {
3451         wxChildFocusEvent eventFocus(this);
3452         parent->GetEventHandler()->ProcessEvent(eventFocus);
3453     }
3454
3455
3456     SetSelection(idx);
3457 }
3458
3459 // GetPageCount() returns the total number of
3460 // pages managed by the multi-notebook
3461 size_t wxAuiNotebook::GetPageCount() const
3462 {
3463     return m_tabs.GetPageCount();
3464 }
3465
3466 // GetPage() returns the wxWindow pointer of the
3467 // specified page
3468 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
3469 {
3470     wxASSERT(page_idx < m_tabs.GetPageCount());
3471
3472     return m_tabs.GetWindowFromIdx(page_idx);
3473 }
3474
3475 // DoSizing() performs all sizing operations in each tab control
3476 void wxAuiNotebook::DoSizing()
3477 {
3478     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3479     size_t i, pane_count = all_panes.GetCount();
3480     for (i = 0; i < pane_count; ++i)
3481     {
3482         if (all_panes.Item(i).name == wxT("dummy"))
3483             continue;
3484
3485         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3486         tabframe->DoSizing();
3487     }
3488 }
3489
3490 // GetActiveTabCtrl() returns the active tab control.  It is
3491 // called to determine which control gets new windows being added
3492 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
3493 {
3494     if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
3495     {
3496         wxAuiTabCtrl* ctrl;
3497         int idx;
3498
3499         // find the tab ctrl with the current page
3500         if (FindTab(m_tabs.GetPage(m_curpage).window,
3501                     &ctrl, &idx))
3502         {
3503             return ctrl;
3504         }
3505     }
3506
3507     // no current page, just find the first tab ctrl
3508     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3509     size_t i, pane_count = all_panes.GetCount();
3510     for (i = 0; i < pane_count; ++i)
3511     {
3512         if (all_panes.Item(i).name == wxT("dummy"))
3513             continue;
3514
3515         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3516         return tabframe->m_tabs;
3517     }
3518
3519     // If there is no tabframe at all, create one
3520     wxTabFrame* tabframe = new wxTabFrame;
3521     tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
3522     tabframe->m_tabs = new wxAuiTabCtrl(this,
3523                                         m_tab_id_counter++,
3524                                         wxDefaultPosition,
3525                                         wxDefaultSize,
3526                                         wxNO_BORDER|wxWANTS_CHARS);
3527     tabframe->m_tabs->SetFlags(m_flags);
3528     tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3529     m_mgr.AddPane(tabframe,
3530                   wxAuiPaneInfo().Center().CaptionVisible(false));
3531
3532     m_mgr.Update();
3533
3534     return tabframe->m_tabs;
3535 }
3536
3537 // FindTab() finds the tab control that currently contains the window as well
3538 // as the index of the window in the tab control.  It returns true if the
3539 // window was found, otherwise false.
3540 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
3541 {
3542     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3543     size_t i, pane_count = all_panes.GetCount();
3544     for (i = 0; i < pane_count; ++i)
3545     {
3546         if (all_panes.Item(i).name == wxT("dummy"))
3547             continue;
3548
3549         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3550
3551         int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
3552         if (page_idx != -1)
3553         {
3554             *ctrl = tabframe->m_tabs;
3555             *idx = page_idx;
3556             return true;
3557         }
3558     }
3559
3560     return false;
3561 }
3562
3563 void wxAuiNotebook::Split(size_t page, int direction)
3564 {
3565     wxSize cli_size = GetClientSize();
3566
3567     // get the page's window pointer
3568     wxWindow* wnd = GetPage(page);
3569     if (!wnd)
3570         return;
3571
3572     // notebooks with 1 or less pages can't be split
3573     if (GetPageCount() < 2)
3574         return;
3575
3576     // find out which tab control the page currently belongs to
3577     wxAuiTabCtrl *src_tabs, *dest_tabs;
3578     int src_idx = -1;
3579     src_tabs = NULL;
3580     if (!FindTab(wnd, &src_tabs, &src_idx))
3581         return;
3582     if (!src_tabs || src_idx == -1)
3583         return;
3584
3585     // choose a split size
3586     wxSize split_size;
3587     if (GetPageCount() > 2)
3588     {
3589         split_size = CalculateNewSplitSize();
3590     }
3591     else
3592     {
3593         // because there are two panes, always split them
3594         // equally
3595         split_size = GetClientSize();
3596         split_size.x /= 2;
3597         split_size.y /= 2;
3598     }
3599
3600
3601     // create a new tab frame
3602     wxTabFrame* new_tabs = new wxTabFrame;
3603     new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
3604     new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3605     new_tabs->m_tabs = new wxAuiTabCtrl(this,
3606                                         m_tab_id_counter++,
3607                                         wxDefaultPosition,
3608                                         wxDefaultSize,
3609                                         wxNO_BORDER|wxWANTS_CHARS);
3610     new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3611     new_tabs->m_tabs->SetFlags(m_flags);
3612     dest_tabs = new_tabs->m_tabs;
3613
3614     // create a pane info structure with the information
3615     // about where the pane should be added
3616     wxAuiPaneInfo pane_info = wxAuiPaneInfo().Bottom().CaptionVisible(false);
3617     wxPoint mouse_pt;
3618
3619     if (direction == wxLEFT)
3620     {
3621         pane_info.Left();
3622         mouse_pt = wxPoint(0, cli_size.y/2);
3623     }
3624     else if (direction == wxRIGHT)
3625     {
3626         pane_info.Right();
3627         mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
3628     }
3629     else if (direction == wxTOP)
3630     {
3631         pane_info.Top();
3632         mouse_pt = wxPoint(cli_size.x/2, 0);
3633     }
3634     else if (direction == wxBOTTOM)
3635     {
3636         pane_info.Bottom();
3637         mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
3638     }
3639
3640     m_mgr.AddPane(new_tabs, pane_info, mouse_pt);
3641     m_mgr.Update();
3642
3643     // remove the page from the source tabs
3644     wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
3645     page_info.active = false;
3646     src_tabs->RemovePage(page_info.window);
3647     if (src_tabs->GetPageCount() > 0)
3648     {
3649         src_tabs->SetActivePage((size_t)0);
3650         src_tabs->DoShowHide();
3651         src_tabs->Refresh();
3652     }
3653
3654
3655     // add the page to the destination tabs
3656     dest_tabs->InsertPage(page_info.window, page_info, 0);
3657
3658     if (src_tabs->GetPageCount() == 0)
3659     {
3660         RemoveEmptyTabFrames();
3661     }
3662
3663     DoSizing();
3664     dest_tabs->DoShowHide();
3665     dest_tabs->Refresh();
3666
3667     // force the set selection function reset the selection
3668     m_curpage = -1;
3669
3670     // set the active page to the one we just split off
3671     SetSelectionToPage(page_info);
3672
3673     UpdateHintWindowSize();
3674 }
3675
3676
3677 void wxAuiNotebook::OnSize(wxSizeEvent& evt)
3678 {
3679     UpdateHintWindowSize();
3680
3681     evt.Skip();
3682 }
3683
3684 void wxAuiNotebook::OnTabClicked(wxAuiNotebookEvent& evt)
3685 {
3686     wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
3687     wxASSERT(ctrl != NULL);
3688
3689     wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
3690     wxASSERT(wnd != NULL);
3691
3692     SetSelectionToWindow(wnd);
3693 }
3694
3695 void wxAuiNotebook::OnTabBgDClick(wxAuiNotebookEvent& WXUNUSED(evt))
3696 {
3697     // notify owner that the tabbar background has been double-clicked
3698     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
3699     e.SetEventObject(this);
3700     GetEventHandler()->ProcessEvent(e);
3701 }
3702
3703 void wxAuiNotebook::OnTabBeginDrag(wxAuiNotebookEvent&)
3704 {
3705     m_last_drag_x = 0;
3706 }
3707
3708 void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
3709 {
3710     wxPoint screen_pt = ::wxGetMousePosition();
3711     wxPoint client_pt = ScreenToClient(screen_pt);
3712     wxPoint zero(0,0);
3713
3714     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3715     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
3716
3717     if (dest_tabs == src_tabs)
3718     {
3719         if (src_tabs)
3720         {
3721             src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3722         }
3723
3724         // always hide the hint for inner-tabctrl drag
3725         m_mgr.HideHint();
3726
3727         // if tab moving is not allowed, leave
3728         if (!(m_flags & wxAUI_NB_TAB_MOVE))
3729         {
3730             return;
3731         }
3732
3733         wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
3734         wxWindow* dest_location_tab;
3735
3736         // this is an inner-tab drag/reposition
3737         if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
3738         {
3739             int src_idx = evt.GetSelection();
3740             int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
3741
3742             // prevent jumpy drag
3743             if ((src_idx == dest_idx) || dest_idx == -1 ||
3744                 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
3745                 (src_idx < dest_idx && m_last_drag_x >= pt.x))
3746             {
3747                 m_last_drag_x = pt.x;
3748                 return;
3749             }
3750
3751
3752             wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
3753             dest_tabs->MovePage(src_tab, dest_idx);
3754             dest_tabs->SetActivePage((size_t)dest_idx);
3755             dest_tabs->DoShowHide();
3756             dest_tabs->Refresh();
3757             m_last_drag_x = pt.x;
3758
3759         }
3760
3761         return;
3762     }
3763
3764
3765     // if external drag is allowed, check if the tab is being dragged
3766     // over a different wxAuiNotebook control
3767     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3768     {
3769         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
3770
3771         // if we aren't over any window, stop here
3772         if (!tab_ctrl)
3773             return;
3774
3775         // make sure we are not over the hint window
3776         if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
3777         {
3778             while (tab_ctrl)
3779             {
3780                 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3781                     break;
3782                 tab_ctrl = tab_ctrl->GetParent();
3783             }
3784
3785             if (tab_ctrl)
3786             {
3787                 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3788
3789                 if (nb != this)
3790                 {
3791                     wxRect hint_rect = tab_ctrl->GetClientRect();
3792                     tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
3793                     m_mgr.ShowHint(hint_rect);
3794                     return;
3795                 }
3796             }
3797         }
3798         else
3799         {
3800             if (!dest_tabs)
3801             {
3802                 // we are either over a hint window, or not over a tab
3803                 // window, and there is no where to drag to, so exit
3804                 return;
3805             }
3806         }
3807     }
3808
3809
3810     // if there are less than two panes, split can't happen, so leave
3811     if (m_tabs.GetPageCount() < 2)
3812         return;
3813
3814     // if tab moving is not allowed, leave
3815     if (!(m_flags & wxAUI_NB_TAB_SPLIT))
3816         return;
3817
3818
3819     if (src_tabs)
3820     {
3821         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
3822     }
3823
3824
3825     if (dest_tabs)
3826     {
3827         wxRect hint_rect = dest_tabs->GetRect();
3828         ClientToScreen(&hint_rect.x, &hint_rect.y);
3829         m_mgr.ShowHint(hint_rect);
3830     }
3831     else
3832     {
3833         m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
3834     }
3835 }
3836
3837
3838
3839 void wxAuiNotebook::OnTabEndDrag(wxAuiNotebookEvent& evt)
3840 {
3841     m_mgr.HideHint();
3842
3843
3844     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3845     wxCHECK_RET( src_tabs, wxT("no source object?") );
3846
3847     src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3848
3849     // get the mouse position, which will be used to determine the drop point
3850     wxPoint mouse_screen_pt = ::wxGetMousePosition();
3851     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
3852
3853
3854
3855     // check for an external move
3856     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3857     {
3858         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
3859
3860         while (tab_ctrl)
3861         {
3862             if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3863                 break;
3864             tab_ctrl = tab_ctrl->GetParent();
3865         }
3866
3867         if (tab_ctrl)
3868         {
3869             wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3870
3871             if (nb != this)
3872             {
3873                 // find out from the destination control
3874                 // if it's ok to drop this tab here
3875                 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
3876                 e.SetSelection(evt.GetSelection());
3877                 e.SetOldSelection(evt.GetSelection());
3878                 e.SetEventObject(this);
3879                 e.SetDragSource(this);
3880                 e.Veto(); // dropping must be explicitly approved by control owner
3881
3882                 nb->GetEventHandler()->ProcessEvent(e);
3883
3884                 if (!e.IsAllowed())
3885                 {
3886                     // no answer or negative answer
3887                     m_mgr.HideHint();
3888                     return;
3889                 }
3890
3891                 // drop was allowed
3892                 int src_idx = evt.GetSelection();
3893                 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
3894
3895                 // Check that it's not an impossible parent relationship
3896                 wxWindow* p = nb;
3897                 while (p && !p->IsTopLevel())
3898                 {
3899                     if (p == src_page)
3900                     {
3901                         return;
3902                     }
3903                     p = p->GetParent();
3904                 }
3905
3906                 // get main index of the page
3907                 int main_idx = m_tabs.GetIdxFromWindow(src_page);
3908                 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no source page?") );
3909
3910
3911                 // make a copy of the page info
3912                 wxAuiNotebookPage page_info = m_tabs.GetPage(main_idx);
3913
3914                 // remove the page from the source notebook
3915                 RemovePage(main_idx);
3916
3917                 // reparent the page
3918                 src_page->Reparent(nb);
3919
3920
3921                 // found out the insert idx
3922                 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
3923                 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3924
3925                 wxWindow* target = NULL;
3926                 int insert_idx = -1;
3927                 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3928                 if (target)
3929                 {
3930                     insert_idx = dest_tabs->GetIdxFromWindow(target);
3931                 }
3932
3933
3934                 // add the page to the new notebook
3935                 if (insert_idx == -1)
3936                     insert_idx = dest_tabs->GetPageCount();
3937                 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3938                 nb->m_tabs.AddPage(page_info.window, page_info);
3939
3940                 nb->DoSizing();
3941                 dest_tabs->DoShowHide();
3942                 dest_tabs->Refresh();
3943
3944                 // set the selection in the destination tab control
3945                 nb->SetSelectionToPage(page_info);
3946
3947                 // notify owner that the tab has been dragged
3948                 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
3949                 e2.SetSelection(evt.GetSelection());
3950                 e2.SetOldSelection(evt.GetSelection());
3951                 e2.SetEventObject(this);
3952                 GetEventHandler()->ProcessEvent(e2);
3953
3954                 return;
3955             }
3956         }
3957     }
3958
3959
3960
3961
3962     // only perform a tab split if it's allowed
3963     wxAuiTabCtrl* dest_tabs = NULL;
3964
3965     if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
3966     {
3967         // If the pointer is in an existing tab frame, do a tab insert
3968         wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
3969         wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
3970         int insert_idx = -1;
3971         if (tab_frame)
3972         {
3973             dest_tabs = tab_frame->m_tabs;
3974
3975             if (dest_tabs == src_tabs)
3976                 return;
3977
3978
3979             wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3980             wxWindow* target = NULL;
3981             dest_tabs->TabHitTest(pt.x, pt.y, &target);
3982             if (target)
3983             {
3984                 insert_idx = dest_tabs->GetIdxFromWindow(target);
3985             }
3986         }
3987         else
3988         {
3989             wxPoint zero(0,0);
3990             wxRect rect = m_mgr.CalculateHintRect(m_dummy_wnd,
3991                                                   mouse_client_pt,
3992                                                   zero);
3993             if (rect.IsEmpty())
3994             {
3995                 // there is no suitable drop location here, exit out
3996                 return;
3997             }
3998
3999             // If there is no tabframe at all, create one
4000             wxTabFrame* new_tabs = new wxTabFrame;
4001             new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
4002             new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
4003             new_tabs->m_tabs = new wxAuiTabCtrl(this,
4004                                                 m_tab_id_counter++,
4005                                                 wxDefaultPosition,
4006                                                 wxDefaultSize,
4007                                                 wxNO_BORDER|wxWANTS_CHARS);
4008             new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
4009             new_tabs->m_tabs->SetFlags(m_flags);
4010
4011             m_mgr.AddPane(new_tabs,
4012                           wxAuiPaneInfo().Bottom().CaptionVisible(false),
4013                           mouse_client_pt);
4014             m_mgr.Update();
4015             dest_tabs = new_tabs->m_tabs;
4016         }
4017
4018
4019
4020         // remove the page from the source tabs
4021         wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
4022         page_info.active = false;
4023         src_tabs->RemovePage(page_info.window);
4024         if (src_tabs->GetPageCount() > 0)
4025         {
4026             src_tabs->SetActivePage((size_t)0);
4027             src_tabs->DoShowHide();
4028             src_tabs->Refresh();
4029         }
4030
4031
4032
4033         // add the page to the destination tabs
4034         if (insert_idx == -1)
4035             insert_idx = dest_tabs->GetPageCount();
4036         dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
4037
4038         if (src_tabs->GetPageCount() == 0)
4039         {
4040             RemoveEmptyTabFrames();
4041         }
4042
4043         DoSizing();
4044         dest_tabs->DoShowHide();
4045         dest_tabs->Refresh();
4046
4047         // force the set selection function reset the selection
4048         m_curpage = -1;
4049
4050         // set the active page to the one we just split off
4051         SetSelectionToPage(page_info);
4052
4053         UpdateHintWindowSize();
4054     }
4055
4056     // notify owner that the tab has been dragged
4057     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
4058     e.SetSelection(evt.GetSelection());
4059     e.SetOldSelection(evt.GetSelection());
4060     e.SetEventObject(this);
4061     GetEventHandler()->ProcessEvent(e);
4062 }
4063
4064
4065
4066 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
4067 {
4068     // if we've just removed the last tab from the source
4069     // tab set, the remove the tab control completely
4070     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4071     size_t i, pane_count = all_panes.GetCount();
4072     for (i = 0; i < pane_count; ++i)
4073     {
4074         if (all_panes.Item(i).name == wxT("dummy"))
4075             continue;
4076
4077         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
4078         if (tabframe->m_tab_rect.Contains(pt))
4079             return tabframe->m_tabs;
4080     }
4081
4082     return NULL;
4083 }
4084
4085 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
4086 {
4087     // if we've just removed the last tab from the source
4088     // tab set, the remove the tab control completely
4089     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4090     size_t i, pane_count = all_panes.GetCount();
4091     for (i = 0; i < pane_count; ++i)
4092     {
4093         if (all_panes.Item(i).name == wxT("dummy"))
4094             continue;
4095
4096         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
4097         if (tabframe->m_tabs == tab_ctrl)
4098         {
4099             return tabframe;
4100         }
4101     }
4102
4103     return NULL;
4104 }
4105
4106 void wxAuiNotebook::RemoveEmptyTabFrames()
4107 {
4108     // if we've just removed the last tab from the source
4109     // tab set, the remove the tab control completely
4110     wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
4111     size_t i, pane_count = all_panes.GetCount();
4112     for (i = 0; i < pane_count; ++i)
4113     {
4114         if (all_panes.Item(i).name == wxT("dummy"))
4115             continue;
4116
4117         wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
4118         if (tab_frame->m_tabs->GetPageCount() == 0)
4119         {
4120             m_mgr.DetachPane(tab_frame);
4121
4122             // use pending delete because sometimes during
4123             // window closing, refreshs are pending
4124             if (!wxPendingDelete.Member(tab_frame->m_tabs))
4125                 wxPendingDelete.Append(tab_frame->m_tabs);
4126
4127             tab_frame->m_tabs = NULL;
4128
4129             delete tab_frame;
4130         }
4131     }
4132
4133
4134     // check to see if there is still a center pane;
4135     // if there isn't, make a frame the center pane
4136     wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
4137     pane_count = panes.GetCount();
4138     wxWindow* first_good = NULL;
4139     bool center_found = false;
4140     for (i = 0; i < pane_count; ++i)
4141     {
4142         if (panes.Item(i).name == wxT("dummy"))
4143             continue;
4144         if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
4145             center_found = true;
4146         if (!first_good)
4147             first_good = panes.Item(i).window;
4148     }
4149
4150     if (!center_found && first_good)
4151     {
4152         m_mgr.GetPane(first_good).Centre();
4153     }
4154
4155     if (!m_isBeingDeleted)
4156         m_mgr.Update();
4157 }
4158
4159 void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
4160 {
4161     evt.Skip();
4162
4163     // if we're dragging a tab, don't change the current selection.
4164     // This code prevents a bug that used to happen when the hint window
4165     // was hidden.  In the bug, the focus would return to the notebook
4166     // child, which would then enter this handler and call
4167     // SetSelection, which is not desired turn tab dragging.
4168
4169     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4170     size_t i, pane_count = all_panes.GetCount();
4171     for (i = 0; i < pane_count; ++i)
4172     {
4173         wxAuiPaneInfo& pane = all_panes.Item(i);
4174         if (pane.name == wxT("dummy"))
4175             continue;
4176         wxTabFrame* tabframe = (wxTabFrame*)pane.window;
4177         if (tabframe->m_tabs->IsDragging())
4178             return;
4179     }
4180
4181
4182     // change the tab selection to the child
4183     // which was focused
4184     int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
4185     if (idx != -1 && idx != m_curpage)
4186     {
4187         SetSelection(idx);
4188     }
4189 }
4190
4191 void wxAuiNotebook::OnNavigationKeyNotebook(wxNavigationKeyEvent& event)
4192 {
4193     if ( event.IsWindowChange() ) {
4194         // change pages
4195         // FIXME: the problem with this is that if we have a split notebook,
4196         // we selection may go all over the place.
4197         AdvanceSelection(event.GetDirection());
4198     }
4199     else {
4200         // we get this event in 3 cases
4201         //
4202         // a) one of our pages might have generated it because the user TABbed
4203         // out from it in which case we should propagate the event upwards and
4204         // our parent will take care of setting the focus to prev/next sibling
4205         //
4206         // or
4207         //
4208         // b) the parent panel wants to give the focus to us so that we
4209         // forward it to our selected page. We can't deal with this in
4210         // OnSetFocus() because we don't know which direction the focus came
4211         // from in this case and so can't choose between setting the focus to
4212         // first or last panel child
4213         //
4214         // or
4215         //
4216         // c) we ourselves (see MSWTranslateMessage) generated the event
4217         //
4218         wxWindow * const parent = GetParent();
4219
4220         // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
4221         const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
4222         const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
4223
4224         if ( isFromParent || isFromSelf )
4225         {
4226             // no, it doesn't come from child, case (b) or (c): forward to a
4227             // page but only if direction is backwards (TAB) or from ourselves,
4228             if ( GetSelection() != wxNOT_FOUND &&
4229                     (!event.GetDirection() || isFromSelf) )
4230             {
4231                 // so that the page knows that the event comes from it's parent
4232                 // and is being propagated downwards
4233                 event.SetEventObject(this);
4234
4235                 wxWindow *page = GetPage(GetSelection());
4236                 if ( !page->GetEventHandler()->ProcessEvent(event) )
4237                 {
4238                     page->SetFocus();
4239                 }
4240                 //else: page manages focus inside it itself
4241             }
4242             else // otherwise set the focus to the notebook itself
4243             {
4244                 SetFocus();
4245             }
4246         }
4247         else
4248         {
4249             // it comes from our child, case (a), pass to the parent, but only
4250             // if the direction is forwards. Otherwise set the focus to the
4251             // notebook itself. The notebook is always the 'first' control of a
4252             // page.
4253             if ( !event.GetDirection() )
4254             {
4255                 SetFocus();
4256             }
4257             else if ( parent )
4258             {
4259                 event.SetCurrentFocus(this);
4260                 parent->GetEventHandler()->ProcessEvent(event);
4261             }
4262         }
4263     }
4264 }
4265
4266 void wxAuiNotebook::OnTabButton(wxAuiNotebookEvent& evt)
4267 {
4268     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4269
4270     int button_id = evt.GetInt();
4271
4272     if (button_id == wxAUI_BUTTON_CLOSE)
4273     {
4274         int selection = evt.GetSelection();
4275
4276         if (selection == -1)
4277         {
4278             // if the close button is to the right, use the active
4279             // page selection to determine which page to close
4280             selection = tabs->GetActivePage();
4281         }
4282
4283         if (selection != -1)
4284         {
4285             wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
4286
4287             // ask owner if it's ok to close the tab
4288             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
4289             e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
4290             const int idx = m_tabs.GetIdxFromWindow(close_wnd);
4291             e.SetSelection(idx);
4292             e.SetOldSelection(evt.GetSelection());
4293             e.SetEventObject(this);
4294             GetEventHandler()->ProcessEvent(e);
4295             if (!e.IsAllowed())
4296                 return;
4297
4298
4299 #if wxUSE_MDI
4300             if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
4301             {
4302                 close_wnd->Close();
4303             }
4304             else
4305 #endif
4306             {
4307                 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
4308                 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no page to delete?") );
4309
4310                 DeletePage(main_idx);
4311             }
4312
4313             // notify owner that the tab has been closed
4314             wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, m_windowId);
4315             e2.SetSelection(idx);
4316             e2.SetEventObject(this);
4317             GetEventHandler()->ProcessEvent(e2);
4318         }
4319     }
4320 }
4321
4322
4323 void wxAuiNotebook::OnTabMiddleDown(wxAuiNotebookEvent& evt)
4324 {
4325     // patch event through to owner
4326     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4327     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4328
4329     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
4330     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4331     e.SetEventObject(this);
4332     GetEventHandler()->ProcessEvent(e);
4333 }
4334
4335 void wxAuiNotebook::OnTabMiddleUp(wxAuiNotebookEvent& evt)
4336 {
4337     // if the wxAUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
4338     // click should act like a tab close action.  However, first
4339     // give the owner an opportunity to handle the middle up event
4340     // for custom action
4341
4342     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4343     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4344
4345     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
4346     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4347     e.SetEventObject(this);
4348     if (GetEventHandler()->ProcessEvent(e))
4349         return;
4350     if (!e.IsAllowed())
4351         return;
4352
4353     // check if we are supposed to close on middle-up
4354     if ((m_flags & wxAUI_NB_MIDDLE_CLICK_CLOSE) == 0)
4355         return;
4356
4357     // simulate the user pressing the close button on the tab
4358     evt.SetInt(wxAUI_BUTTON_CLOSE);
4359     OnTabButton(evt);
4360 }
4361
4362 void wxAuiNotebook::OnTabRightDown(wxAuiNotebookEvent& evt)
4363 {
4364     // patch event through to owner
4365     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4366     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4367
4368     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
4369     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4370     e.SetEventObject(this);
4371     GetEventHandler()->ProcessEvent(e);
4372 }
4373
4374 void wxAuiNotebook::OnTabRightUp(wxAuiNotebookEvent& evt)
4375 {
4376     // patch event through to owner
4377     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4378     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4379
4380     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
4381     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4382     e.SetEventObject(this);
4383     GetEventHandler()->ProcessEvent(e);
4384 }
4385
4386 // Sets the normal font
4387 void wxAuiNotebook::SetNormalFont(const wxFont& font)
4388 {
4389     m_normal_font = font;
4390     GetArtProvider()->SetNormalFont(font);
4391 }
4392
4393 // Sets the selected tab font
4394 void wxAuiNotebook::SetSelectedFont(const wxFont& font)
4395 {
4396     m_selected_font = font;
4397     GetArtProvider()->SetSelectedFont(font);
4398 }
4399
4400 // Sets the measuring font
4401 void wxAuiNotebook::SetMeasuringFont(const wxFont& font)
4402 {
4403     GetArtProvider()->SetMeasuringFont(font);
4404 }
4405
4406 // Sets the tab font
4407 bool wxAuiNotebook::SetFont(const wxFont& font)
4408 {
4409     wxControl::SetFont(font);
4410
4411     wxFont normalFont(font);
4412     wxFont selectedFont(normalFont);
4413     selectedFont.SetWeight(wxBOLD);
4414
4415     SetNormalFont(normalFont);
4416     SetSelectedFont(selectedFont);
4417     SetMeasuringFont(selectedFont);
4418
4419     return true;
4420 }
4421
4422 // Gets the tab control height
4423 int wxAuiNotebook::GetTabCtrlHeight() const
4424 {
4425     return m_tab_ctrl_height;
4426 }
4427
4428 // Gets the height of the notebook for a given page height
4429 int wxAuiNotebook::GetHeightForPageHeight(int pageHeight)
4430 {
4431     UpdateTabCtrlHeight();
4432
4433     int tabCtrlHeight = GetTabCtrlHeight();
4434     int decorHeight = 2;
4435     return tabCtrlHeight + pageHeight + decorHeight;
4436 }
4437
4438 // Advances the selection, generation page selection events
4439 void wxAuiNotebook::AdvanceSelection(bool forward)
4440 {
4441     if (GetPageCount() <= 1)
4442         return;
4443
4444     int currentSelection = GetSelection();
4445
4446     if (forward)
4447     {
4448         if (currentSelection == (int) (GetPageCount() - 1))
4449             return;
4450         else if (currentSelection == -1)
4451             currentSelection = 0;
4452         else
4453             currentSelection ++;
4454     }
4455     else
4456     {
4457         if (currentSelection <= 0)
4458             return;
4459         else
4460             currentSelection --;
4461     }
4462
4463     SetSelection(currentSelection);
4464 }
4465
4466 // Shows the window menu
4467 bool wxAuiNotebook::ShowWindowMenu()
4468 {
4469     wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
4470
4471     int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
4472
4473     if (idx != -1)
4474     {
4475         wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
4476         e.SetSelection(idx);
4477         e.SetOldSelection(tabCtrl->GetActivePage());
4478         e.SetEventObject(tabCtrl);
4479         GetEventHandler()->ProcessEvent(e);
4480
4481         return true;
4482     }
4483     else
4484         return false;
4485 }
4486
4487 void wxAuiNotebook::Thaw()
4488 {
4489     DoSizing();
4490
4491     wxControl::Thaw();
4492 }
4493
4494 #endif // wxUSE_AUI