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