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