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     m_mgr.UnInit();
2800 }
2801
2802 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
2803 {
2804     m_tabs.SetArtProvider(art);
2805
2806     UpdateTabCtrlHeight();
2807 }
2808
2809 // SetTabCtrlHeight() is the highest-level override of the
2810 // tab height.  A call to this function effectively enforces a
2811 // specified tab ctrl height, overriding all other considerations,
2812 // such as text or bitmap height.  It overrides any call to
2813 // SetUniformBitmapSize().  Specifying a height of -1 reverts
2814 // any previous call and returns to the default behavior
2815
2816 void wxAuiNotebook::SetTabCtrlHeight(int height)
2817 {
2818     m_requested_tabctrl_height = height;
2819
2820     // if window is already initialized, recalculate the tab height
2821     if (m_dummy_wnd)
2822     {
2823         UpdateTabCtrlHeight();
2824     }
2825 }
2826
2827
2828 // SetUniformBitmapSize() ensures that all tabs will have
2829 // the same height, even if some tabs don't have bitmaps
2830 // Passing wxDefaultSize to this function will instruct
2831 // the control to use dynamic tab height-- so when a tab
2832 // with a large bitmap is added, the tab ctrl's height will
2833 // automatically increase to accommodate the bitmap
2834
2835 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
2836 {
2837     m_requested_bmp_size = size;
2838
2839     // if window is already initialized, recalculate the tab height
2840     if (m_dummy_wnd)
2841     {
2842         UpdateTabCtrlHeight();
2843     }
2844 }
2845
2846 // UpdateTabCtrlHeight() does the actual tab resizing. It's meant
2847 // to be used interally
2848 void wxAuiNotebook::UpdateTabCtrlHeight()
2849 {
2850     // get the tab ctrl height we will use
2851     int height = CalculateTabCtrlHeight();
2852
2853     // if the tab control height needs to change, update
2854     // all of our tab controls with the new height
2855     if (m_tab_ctrl_height != height)
2856     {
2857         wxAuiTabArt* art = m_tabs.GetArtProvider();
2858
2859         m_tab_ctrl_height = height;
2860
2861         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2862         size_t i, pane_count = all_panes.GetCount();
2863         for (i = 0; i < pane_count; ++i)
2864         {
2865             wxAuiPaneInfo& pane = all_panes.Item(i);
2866             if (pane.name == wxT("dummy"))
2867                 continue;
2868             wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
2869             wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
2870             tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
2871             tabctrl->SetArtProvider(art->Clone());
2872             tab_frame->DoSizing();
2873         }
2874     }
2875 }
2876
2877 void wxAuiNotebook::UpdateHintWindowSize()
2878 {
2879     wxSize size = CalculateNewSplitSize();
2880
2881     // the placeholder hint window should be set to this size
2882     wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
2883     if (info.IsOk())
2884     {
2885         info.MinSize(size);
2886         info.BestSize(size);
2887         m_dummy_wnd->SetSize(size);
2888     }
2889 }
2890
2891
2892 // calculates the size of the new split
2893 wxSize wxAuiNotebook::CalculateNewSplitSize()
2894 {
2895     // count number of tab controls
2896     int tab_ctrl_count = 0;
2897     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2898     size_t i, pane_count = all_panes.GetCount();
2899     for (i = 0; i < pane_count; ++i)
2900     {
2901         wxAuiPaneInfo& pane = all_panes.Item(i);
2902         if (pane.name == wxT("dummy"))
2903             continue;
2904         tab_ctrl_count++;
2905     }
2906
2907     wxSize new_split_size;
2908
2909     // if there is only one tab control, the first split
2910     // should happen around the middle
2911     if (tab_ctrl_count < 2)
2912     {
2913         new_split_size = GetClientSize();
2914         new_split_size.x /= 2;
2915         new_split_size.y /= 2;
2916     }
2917     else
2918     {
2919         // this is in place of a more complicated calculation
2920         // that needs to be implemented
2921         new_split_size = wxSize(180,180);
2922     }
2923
2924     return new_split_size;
2925 }
2926
2927 int wxAuiNotebook::CalculateTabCtrlHeight()
2928 {
2929     // if a fixed tab ctrl height is specified,
2930     // just return that instead of calculating a
2931     // tab height
2932     if (m_requested_tabctrl_height != -1)
2933         return m_requested_tabctrl_height;
2934
2935     // find out new best tab height
2936     wxAuiTabArt* art = m_tabs.GetArtProvider();
2937
2938     return art->GetBestTabCtrlSize(this,
2939                                    m_tabs.GetPages(),
2940                                    m_requested_bmp_size);
2941 }
2942
2943
2944 wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
2945 {
2946     return m_tabs.GetArtProvider();
2947 }
2948
2949 void wxAuiNotebook::SetWindowStyleFlag(long style)
2950 {
2951     wxControl::SetWindowStyleFlag(style);
2952
2953     m_flags = (unsigned int)style;
2954
2955     // if the control is already initialized
2956     if (m_mgr.GetManagedWindow() == (wxWindow*)this)
2957     {
2958         // let all of the tab children know about the new style
2959
2960         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2961         size_t i, pane_count = all_panes.GetCount();
2962         for (i = 0; i < pane_count; ++i)
2963         {
2964             wxAuiPaneInfo& pane = all_panes.Item(i);
2965             if (pane.name == wxT("dummy"))
2966                 continue;
2967             wxTabFrame* tabframe = (wxTabFrame*)pane.window;
2968             wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
2969             tabctrl->SetFlags(m_flags);
2970             tabframe->DoSizing();
2971             tabctrl->Refresh();
2972             tabctrl->Update();
2973         }
2974     }
2975 }
2976
2977
2978 bool wxAuiNotebook::AddPage(wxWindow* page,
2979                             const wxString& caption,
2980                             bool select,
2981                             const wxBitmap& bitmap)
2982 {
2983     return InsertPage(GetPageCount(), page, caption, select, bitmap);
2984 }
2985
2986 bool wxAuiNotebook::InsertPage(size_t page_idx,
2987                                wxWindow* page,
2988                                const wxString& caption,
2989                                bool select,
2990                                const wxBitmap& bitmap)
2991 {
2992     page->Reparent(this);
2993
2994     wxAuiNotebookPage info;
2995     info.window = page;
2996     info.caption = caption;
2997     info.bitmap = bitmap;
2998     info.active = false;
2999
3000     // if there are currently no tabs, the first added
3001     // tab must be active
3002     if (m_tabs.GetPageCount() == 0)
3003         info.active = true;
3004
3005     m_tabs.InsertPage(page, info, page_idx);
3006
3007     // if that was the first page added, even if
3008     // select is false, it must become the "current page"
3009     // (though no select events will be fired)
3010     if (!select && m_tabs.GetPageCount() == 1)
3011         select = true;
3012         //m_curpage = GetPageIndex(page);
3013
3014     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
3015     if (page_idx >= active_tabctrl->GetPageCount())
3016         active_tabctrl->AddPage(page, info);
3017     else
3018         active_tabctrl->InsertPage(page, info, page_idx);
3019
3020     UpdateTabCtrlHeight();
3021     DoSizing();
3022     active_tabctrl->DoShowHide();
3023
3024     // adjust selected index
3025     if(m_curpage >= (int) page_idx)
3026         m_curpage++;
3027
3028     if (select)
3029     {
3030         SetSelectionToWindow(page);
3031     }
3032
3033     return true;
3034 }
3035
3036
3037 // DeletePage() removes a tab from the multi-notebook,
3038 // and destroys the window as well
3039 bool wxAuiNotebook::DeletePage(size_t page_idx)
3040 {
3041     if (page_idx >= m_tabs.GetPageCount())
3042         return false;
3043
3044     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3045
3046     // hide the window in advance, as this will
3047     // prevent flicker
3048     ShowWnd(wnd, false);
3049
3050     if (!RemovePage(page_idx))
3051         return false;
3052
3053     // actually destroy the window now
3054     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3055     {
3056         // delete the child frame with pending delete, as is
3057         // customary with frame windows
3058         if (!wxPendingDelete.Member(wnd))
3059             wxPendingDelete.Append(wnd);
3060     }
3061     else
3062     {
3063         wnd->Destroy();
3064     }
3065
3066     return true;
3067 }
3068
3069
3070
3071 // RemovePage() removes a tab from the multi-notebook,
3072 // but does not destroy the window
3073 bool wxAuiNotebook::RemovePage(size_t page_idx)
3074 {
3075     // save active window pointer
3076     wxWindow* active_wnd = NULL;
3077     if (m_curpage >= 0)
3078         active_wnd = m_tabs.GetWindowFromIdx(m_curpage);
3079
3080     // save pointer of window being deleted
3081     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3082     wxWindow* new_active = NULL;
3083
3084     // make sure we found the page
3085     if (!wnd)
3086         return false;
3087
3088     // find out which onscreen tab ctrl owns this tab
3089     wxAuiTabCtrl* ctrl;
3090     int ctrl_idx;
3091     if (!FindTab(wnd, &ctrl, &ctrl_idx))
3092         return false;
3093
3094     bool is_curpage = (m_curpage == (int)page_idx);
3095     bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
3096
3097
3098     // remove the tab from main catalog
3099     if (!m_tabs.RemovePage(wnd))
3100         return false;
3101
3102     // remove the tab from the onscreen tab ctrl
3103     ctrl->RemovePage(wnd);
3104
3105     if (is_active_in_split)
3106     {
3107         int ctrl_new_page_count = (int)ctrl->GetPageCount();
3108
3109         if (ctrl_idx >= ctrl_new_page_count)
3110             ctrl_idx = ctrl_new_page_count-1;
3111
3112         if (ctrl_idx >= 0 && ctrl_idx < (int)ctrl->GetPageCount())
3113         {
3114             // set new page as active in the tab split
3115             ctrl->SetActivePage(ctrl_idx);
3116
3117             // if the page deleted was the current page for the
3118             // entire tab control, then record the window
3119             // pointer of the new active page for activation
3120             if (is_curpage)
3121             {
3122                 new_active = ctrl->GetWindowFromIdx(ctrl_idx);
3123             }
3124         }
3125     }
3126     else
3127     {
3128         // we are not deleting the active page, so keep it the same
3129         new_active = active_wnd;
3130     }
3131
3132
3133     if (!new_active)
3134     {
3135         // we haven't yet found a new page to active,
3136         // so select the next page from the main tab
3137         // catalogue
3138
3139         if (page_idx < m_tabs.GetPageCount())
3140         {
3141             new_active = m_tabs.GetPage(page_idx).window;
3142         }
3143
3144         if (!new_active && m_tabs.GetPageCount() > 0)
3145         {
3146             new_active = m_tabs.GetPage(0).window;
3147         }
3148     }
3149
3150
3151     RemoveEmptyTabFrames();
3152
3153     // set new active pane
3154     if (new_active)
3155     {
3156         m_curpage = -1;
3157         SetSelectionToWindow(new_active);
3158     }
3159
3160     return true;
3161 }
3162
3163 // GetPageIndex() returns the index of the page, or -1 if the
3164 // page could not be located in the notebook
3165 int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
3166 {
3167     return m_tabs.GetIdxFromWindow(page_wnd);
3168 }
3169
3170
3171
3172 // SetPageText() changes the tab caption of the specified page
3173 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
3174 {
3175     if (page_idx >= m_tabs.GetPageCount())
3176         return false;
3177
3178     // update our own tab catalog
3179     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3180     page_info.caption = text;
3181
3182     // update what's on screen
3183     wxAuiTabCtrl* ctrl;
3184     int ctrl_idx;
3185     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3186     {
3187         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3188         info.caption = text;
3189         ctrl->Refresh();
3190         ctrl->Update();
3191     }
3192
3193     return true;
3194 }
3195
3196 // returns the page caption
3197 wxString wxAuiNotebook::GetPageText(size_t page_idx) const
3198 {
3199     if (page_idx >= m_tabs.GetPageCount())
3200         return wxEmptyString;
3201
3202     // update our own tab catalog
3203     const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3204     return page_info.caption;
3205 }
3206
3207 bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
3208 {
3209     if (page_idx >= m_tabs.GetPageCount())
3210         return false;
3211
3212     // update our own tab catalog
3213     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3214     page_info.bitmap = bitmap;
3215
3216     // tab height might have changed
3217     UpdateTabCtrlHeight();
3218
3219     // update what's on screen
3220     wxAuiTabCtrl* ctrl;
3221     int ctrl_idx;
3222     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3223     {
3224         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3225         info.bitmap = bitmap;
3226         ctrl->Refresh();
3227         ctrl->Update();
3228     }
3229
3230     return true;
3231 }
3232
3233 // returns the page bitmap
3234 wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
3235 {
3236     if (page_idx >= m_tabs.GetPageCount())
3237         return wxBitmap();
3238
3239     // update our own tab catalog
3240     const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3241     return page_info.bitmap;
3242 }
3243
3244 // GetSelection() returns the index of the currently active page
3245 int wxAuiNotebook::GetSelection() const
3246 {
3247     return m_curpage;
3248 }
3249
3250 // SetSelection() sets the currently active page
3251 size_t wxAuiNotebook::SetSelection(size_t new_page)
3252 {
3253     wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
3254     if (!wnd)
3255         return m_curpage;
3256
3257     // don't change the page unless necessary;
3258     // however, clicking again on a tab should give it the focus.
3259     if ((int)new_page == m_curpage)
3260     {
3261         wxAuiTabCtrl* ctrl;
3262         int ctrl_idx;
3263         if (FindTab(wnd, &ctrl, &ctrl_idx))
3264         {
3265             if (FindFocus() != ctrl)
3266                 ctrl->SetFocus();
3267         }
3268         return m_curpage;
3269     }
3270
3271     wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
3272     evt.SetSelection(new_page);
3273     evt.SetOldSelection(m_curpage);
3274     evt.SetEventObject(this);
3275     if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
3276     {
3277         int old_curpage = m_curpage;
3278         m_curpage = new_page;
3279
3280         // program allows the page change
3281         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
3282         (void)GetEventHandler()->ProcessEvent(evt);
3283
3284
3285         wxAuiTabCtrl* ctrl;
3286         int ctrl_idx;
3287         if (FindTab(wnd, &ctrl, &ctrl_idx))
3288         {
3289             m_tabs.SetActivePage(wnd);
3290
3291             ctrl->SetActivePage(ctrl_idx);
3292             DoSizing();
3293             ctrl->DoShowHide();
3294
3295             ctrl->MakeTabVisible(ctrl_idx, ctrl);
3296
3297             // set fonts
3298             wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3299             size_t i, pane_count = all_panes.GetCount();
3300             for (i = 0; i < pane_count; ++i)
3301             {
3302                 wxAuiPaneInfo& pane = all_panes.Item(i);
3303                 if (pane.name == wxT("dummy"))
3304                     continue;
3305                 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
3306                 if (tabctrl != ctrl)
3307                     tabctrl->SetSelectedFont(m_normal_font);
3308                 else
3309                     tabctrl->SetSelectedFont(m_selected_font);
3310                 tabctrl->Refresh();
3311             }
3312
3313             // Set the focus to the page if we're not currently focused on the tab.
3314             // This is Firefox-like behaviour.
3315             if (wnd->IsShownOnScreen() && FindFocus() != ctrl)
3316                 wnd->SetFocus();
3317
3318             return old_curpage;
3319         }
3320     }
3321
3322     return m_curpage;
3323 }
3324
3325 void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
3326 {
3327     const int idx = m_tabs.GetIdxFromWindow(win);
3328     wxCHECK_RET( idx != wxNOT_FOUND, _T("invalid notebook page") );
3329
3330     SetSelection(idx);
3331 }
3332
3333 // GetPageCount() returns the total number of
3334 // pages managed by the multi-notebook
3335 size_t wxAuiNotebook::GetPageCount() const
3336 {
3337     return m_tabs.GetPageCount();
3338 }
3339
3340 // GetPage() returns the wxWindow pointer of the
3341 // specified page
3342 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
3343 {
3344     wxASSERT(page_idx < m_tabs.GetPageCount());
3345
3346     return m_tabs.GetWindowFromIdx(page_idx);
3347 }
3348
3349 // DoSizing() performs all sizing operations in each tab control
3350 void wxAuiNotebook::DoSizing()
3351 {
3352     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3353     size_t i, pane_count = all_panes.GetCount();
3354     for (i = 0; i < pane_count; ++i)
3355     {
3356         if (all_panes.Item(i).name == wxT("dummy"))
3357             continue;
3358
3359         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3360         tabframe->DoSizing();
3361     }
3362 }
3363
3364 // GetActiveTabCtrl() returns the active tab control.  It is
3365 // called to determine which control gets new windows being added
3366 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
3367 {
3368     if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
3369     {
3370         wxAuiTabCtrl* ctrl;
3371         int idx;
3372
3373         // find the tab ctrl with the current page
3374         if (FindTab(m_tabs.GetPage(m_curpage).window,
3375                     &ctrl, &idx))
3376         {
3377             return ctrl;
3378         }
3379     }
3380
3381     // no current page, just find the first tab ctrl
3382     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3383     size_t i, pane_count = all_panes.GetCount();
3384     for (i = 0; i < pane_count; ++i)
3385     {
3386         if (all_panes.Item(i).name == wxT("dummy"))
3387             continue;
3388
3389         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3390         return tabframe->m_tabs;
3391     }
3392
3393     // If there is no tabframe at all, create one
3394     wxTabFrame* tabframe = new wxTabFrame;
3395     tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
3396     tabframe->m_tabs = new wxAuiTabCtrl(this,
3397                                         m_tab_id_counter++,
3398                                         wxDefaultPosition,
3399                                         wxDefaultSize,
3400                                         wxNO_BORDER|wxWANTS_CHARS);
3401     tabframe->m_tabs->SetFlags(m_flags);
3402     tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3403     m_mgr.AddPane(tabframe,
3404                   wxAuiPaneInfo().Center().CaptionVisible(false));
3405
3406     m_mgr.Update();
3407
3408     return tabframe->m_tabs;
3409 }
3410
3411 // FindTab() finds the tab control that currently contains the window as well
3412 // as the index of the window in the tab control.  It returns true if the
3413 // window was found, otherwise false.
3414 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
3415 {
3416     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3417     size_t i, pane_count = all_panes.GetCount();
3418     for (i = 0; i < pane_count; ++i)
3419     {
3420         if (all_panes.Item(i).name == wxT("dummy"))
3421             continue;
3422
3423         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3424
3425         int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
3426         if (page_idx != -1)
3427         {
3428             *ctrl = tabframe->m_tabs;
3429             *idx = page_idx;
3430             return true;
3431         }
3432     }
3433
3434     return false;
3435 }
3436
3437 void wxAuiNotebook::Split(size_t page, int direction)
3438 {
3439     wxSize cli_size = GetClientSize();
3440
3441     // get the page's window pointer
3442     wxWindow* wnd = GetPage(page);
3443     if (!wnd)
3444         return;
3445
3446     // notebooks with 1 or less pages can't be split
3447     if (GetPageCount() < 2)
3448         return;
3449
3450     // find out which tab control the page currently belongs to
3451     wxAuiTabCtrl *src_tabs, *dest_tabs;
3452     int src_idx = -1;
3453     src_tabs = NULL;
3454     if (!FindTab(wnd, &src_tabs, &src_idx))
3455         return;
3456     if (!src_tabs || src_idx == -1)
3457         return;
3458
3459     // choose a split size
3460     wxSize split_size;
3461     if (GetPageCount() > 2)
3462     {
3463         split_size = CalculateNewSplitSize();
3464     }
3465     else
3466     {
3467         // because there are two panes, always split them
3468         // equally
3469         split_size = GetClientSize();
3470         split_size.x /= 2;
3471         split_size.y /= 2;
3472     }
3473
3474
3475     // create a new tab frame
3476     wxTabFrame* new_tabs = new wxTabFrame;
3477     new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
3478     new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3479     new_tabs->m_tabs = new wxAuiTabCtrl(this,
3480                                         m_tab_id_counter++,
3481                                         wxDefaultPosition,
3482                                         wxDefaultSize,
3483                                         wxNO_BORDER|wxWANTS_CHARS);
3484     new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3485     new_tabs->m_tabs->SetFlags(m_flags);
3486     dest_tabs = new_tabs->m_tabs;
3487
3488     // create a pane info structure with the information
3489     // about where the pane should be added
3490     wxAuiPaneInfo pane_info = wxAuiPaneInfo().Bottom().CaptionVisible(false);
3491     wxPoint mouse_pt;
3492
3493     if (direction == wxLEFT)
3494     {
3495         pane_info.Left();
3496         mouse_pt = wxPoint(0, cli_size.y/2);
3497     }
3498     else if (direction == wxRIGHT)
3499     {
3500         pane_info.Right();
3501         mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
3502     }
3503     else if (direction == wxTOP)
3504     {
3505         pane_info.Top();
3506         mouse_pt = wxPoint(cli_size.x/2, 0);
3507     }
3508     else if (direction == wxBOTTOM)
3509     {
3510         pane_info.Bottom();
3511         mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
3512     }
3513
3514     m_mgr.AddPane(new_tabs, pane_info, mouse_pt);
3515     m_mgr.Update();
3516
3517     // remove the page from the source tabs
3518     wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
3519     page_info.active = false;
3520     src_tabs->RemovePage(page_info.window);
3521     if (src_tabs->GetPageCount() > 0)
3522     {
3523         src_tabs->SetActivePage((size_t)0);
3524         src_tabs->DoShowHide();
3525         src_tabs->Refresh();
3526     }
3527
3528
3529     // add the page to the destination tabs
3530     dest_tabs->InsertPage(page_info.window, page_info, 0);
3531
3532     if (src_tabs->GetPageCount() == 0)
3533     {
3534         RemoveEmptyTabFrames();
3535     }
3536
3537     DoSizing();
3538     dest_tabs->DoShowHide();
3539     dest_tabs->Refresh();
3540
3541     // force the set selection function reset the selection
3542     m_curpage = -1;
3543
3544     // set the active page to the one we just split off
3545     SetSelectionToPage(page_info);
3546
3547     UpdateHintWindowSize();
3548 }
3549
3550
3551 void wxAuiNotebook::OnSize(wxSizeEvent& evt)
3552 {
3553     UpdateHintWindowSize();
3554
3555     evt.Skip();
3556 }
3557
3558 void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
3559 {
3560     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3561
3562     wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
3563     wxASSERT(ctrl != NULL);
3564
3565     wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
3566     wxASSERT(wnd != NULL);
3567
3568     SetSelectionToWindow(wnd);
3569 }
3570
3571 void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
3572 {
3573     m_last_drag_x = 0;
3574 }
3575
3576 void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
3577 {
3578     wxPoint screen_pt = ::wxGetMousePosition();
3579     wxPoint client_pt = ScreenToClient(screen_pt);
3580     wxPoint zero(0,0);
3581
3582     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3583     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
3584
3585     if (dest_tabs == src_tabs)
3586     {
3587         if (src_tabs)
3588         {
3589             src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3590         }
3591
3592         // always hide the hint for inner-tabctrl drag
3593         m_mgr.HideHint();
3594
3595         // if tab moving is not allowed, leave
3596         if (!(m_flags & wxAUI_NB_TAB_MOVE))
3597         {
3598             return;
3599         }
3600
3601         wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
3602         wxWindow* dest_location_tab;
3603
3604         // this is an inner-tab drag/reposition
3605         if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
3606         {
3607             int src_idx = evt.GetSelection();
3608             int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
3609
3610             // prevent jumpy drag
3611             if ((src_idx == dest_idx) || dest_idx == -1 ||
3612                 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
3613                 (src_idx < dest_idx && m_last_drag_x >= pt.x))
3614             {
3615                 m_last_drag_x = pt.x;
3616                 return;
3617             }
3618
3619
3620             wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
3621             dest_tabs->MovePage(src_tab, dest_idx);
3622             dest_tabs->SetActivePage((size_t)dest_idx);
3623             dest_tabs->DoShowHide();
3624             dest_tabs->Refresh();
3625             m_last_drag_x = pt.x;
3626
3627         }
3628
3629         return;
3630     }
3631
3632
3633     // if external drag is allowed, check if the tab is being dragged
3634     // over a different wxAuiNotebook control
3635     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3636     {
3637         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
3638
3639         // if we aren't over any window, stop here
3640         if (!tab_ctrl)
3641             return;
3642
3643         // make sure we are not over the hint window
3644         if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
3645         {
3646             while (tab_ctrl)
3647             {
3648                 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3649                     break;
3650                 tab_ctrl = tab_ctrl->GetParent();
3651             }
3652
3653             if (tab_ctrl)
3654             {
3655                 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3656
3657                 if (nb != this)
3658                 {
3659                     wxRect hint_rect = tab_ctrl->GetClientRect();
3660                     tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
3661                     m_mgr.ShowHint(hint_rect);
3662                     return;
3663                 }
3664             }
3665         }
3666         else
3667         {
3668             if (!dest_tabs)
3669             {
3670                 // we are either over a hint window, or not over a tab
3671                 // window, and there is no where to drag to, so exit
3672                 return;
3673             }
3674         }
3675     }
3676
3677
3678     // if there are less than two panes, split can't happen, so leave
3679     if (m_tabs.GetPageCount() < 2)
3680         return;
3681
3682     // if tab moving is not allowed, leave
3683     if (!(m_flags & wxAUI_NB_TAB_SPLIT))
3684         return;
3685
3686
3687     if (src_tabs)
3688     {
3689         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
3690     }
3691
3692
3693     if (dest_tabs)
3694     {
3695         wxRect hint_rect = dest_tabs->GetRect();
3696         ClientToScreen(&hint_rect.x, &hint_rect.y);
3697         m_mgr.ShowHint(hint_rect);
3698     }
3699     else
3700     {
3701         m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
3702     }
3703 }
3704
3705
3706
3707 void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
3708 {
3709     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3710
3711     m_mgr.HideHint();
3712
3713
3714     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3715     wxCHECK_RET( src_tabs, _T("no source object?") );
3716
3717     src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3718
3719     // get the mouse position, which will be used to determine the drop point
3720     wxPoint mouse_screen_pt = ::wxGetMousePosition();
3721     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
3722
3723
3724
3725     // check for an external move
3726     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3727     {
3728         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
3729
3730         while (tab_ctrl)
3731         {
3732             if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3733                 break;
3734             tab_ctrl = tab_ctrl->GetParent();
3735         }
3736
3737         if (tab_ctrl)
3738         {
3739             wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3740
3741             if (nb != this)
3742             {
3743                 // find out from the destination control
3744                 // if it's ok to drop this tab here
3745                 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
3746                 e.SetSelection(evt.GetSelection());
3747                 e.SetOldSelection(evt.GetSelection());
3748                 e.SetEventObject(this);
3749                 e.SetDragSource(this);
3750                 e.Veto(); // dropping must be explicitly approved by control owner
3751
3752                 nb->GetEventHandler()->ProcessEvent(e);
3753
3754                 if (!e.IsAllowed())
3755                 {
3756                     // no answer or negative answer
3757                     m_mgr.HideHint();
3758                     return;
3759                 }
3760
3761                 // drop was allowed
3762                 int src_idx = evt.GetSelection();
3763                 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
3764
3765                 // Check that it's not an impossible parent relationship
3766                 wxWindow* p = nb;
3767                 while (p && !p->IsTopLevel())
3768                 {
3769                     if (p == src_page)
3770                     {
3771                         return;
3772                     }
3773                     p = p->GetParent();
3774                 }
3775
3776                 // get main index of the page
3777                 int main_idx = m_tabs.GetIdxFromWindow(src_page);
3778                 wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no source page?") );
3779
3780
3781                 // make a copy of the page info
3782                 wxAuiNotebookPage page_info = m_tabs.GetPage(main_idx);
3783
3784                 // remove the page from the source notebook
3785                 RemovePage(main_idx);
3786
3787                 // reparent the page
3788                 src_page->Reparent(nb);
3789
3790
3791                 // found out the insert idx
3792                 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
3793                 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3794
3795                 wxWindow* target = NULL;
3796                 int insert_idx = -1;
3797                 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3798                 if (target)
3799                 {
3800                     insert_idx = dest_tabs->GetIdxFromWindow(target);
3801                 }
3802
3803
3804                 // add the page to the new notebook
3805                 if (insert_idx == -1)
3806                     insert_idx = dest_tabs->GetPageCount();
3807                 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3808                 nb->m_tabs.AddPage(page_info.window, page_info);
3809
3810                 nb->DoSizing();
3811                 dest_tabs->DoShowHide();
3812                 dest_tabs->Refresh();
3813
3814                 // set the selection in the destination tab control
3815                 nb->SetSelectionToPage(page_info);
3816
3817                 return;
3818             }
3819         }
3820     }
3821
3822
3823
3824
3825     // only perform a tab split if it's allowed
3826     wxAuiTabCtrl* dest_tabs = NULL;
3827
3828     if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
3829     {
3830         // If the pointer is in an existing tab frame, do a tab insert
3831         wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
3832         wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
3833         int insert_idx = -1;
3834         if (tab_frame)
3835         {
3836             dest_tabs = tab_frame->m_tabs;
3837
3838             if (dest_tabs == src_tabs)
3839                 return;
3840
3841
3842             wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3843             wxWindow* target = NULL;
3844             dest_tabs->TabHitTest(pt.x, pt.y, &target);
3845             if (target)
3846             {
3847                 insert_idx = dest_tabs->GetIdxFromWindow(target);
3848             }
3849         }
3850         else
3851         {
3852             wxPoint zero(0,0);
3853             wxRect rect = m_mgr.CalculateHintRect(m_dummy_wnd,
3854                                                   mouse_client_pt,
3855                                                   zero);
3856             if (rect.IsEmpty())
3857             {
3858                 // there is no suitable drop location here, exit out
3859                 return;
3860             }
3861
3862             // If there is no tabframe at all, create one
3863             wxTabFrame* new_tabs = new wxTabFrame;
3864             new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
3865             new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3866             new_tabs->m_tabs = new wxAuiTabCtrl(this,
3867                                                 m_tab_id_counter++,
3868                                                 wxDefaultPosition,
3869                                                 wxDefaultSize,
3870                                                 wxNO_BORDER|wxWANTS_CHARS);
3871             new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3872             new_tabs->m_tabs->SetFlags(m_flags);
3873
3874             m_mgr.AddPane(new_tabs,
3875                           wxAuiPaneInfo().Bottom().CaptionVisible(false),
3876                           mouse_client_pt);
3877             m_mgr.Update();
3878             dest_tabs = new_tabs->m_tabs;
3879         }
3880
3881
3882
3883         // remove the page from the source tabs
3884         wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
3885         page_info.active = false;
3886         src_tabs->RemovePage(page_info.window);
3887         if (src_tabs->GetPageCount() > 0)
3888         {
3889             src_tabs->SetActivePage((size_t)0);
3890             src_tabs->DoShowHide();
3891             src_tabs->Refresh();
3892         }
3893
3894
3895
3896         // add the page to the destination tabs
3897         if (insert_idx == -1)
3898             insert_idx = dest_tabs->GetPageCount();
3899         dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3900
3901         if (src_tabs->GetPageCount() == 0)
3902         {
3903             RemoveEmptyTabFrames();
3904         }
3905
3906         DoSizing();
3907         dest_tabs->DoShowHide();
3908         dest_tabs->Refresh();
3909
3910         // force the set selection function reset the selection
3911         m_curpage = -1;
3912
3913         // set the active page to the one we just split off
3914         SetSelectionToPage(page_info);
3915
3916         UpdateHintWindowSize();
3917     }
3918 }
3919
3920
3921
3922 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
3923 {
3924     // if we've just removed the last tab from the source
3925     // tab set, the remove the tab control completely
3926     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3927     size_t i, pane_count = all_panes.GetCount();
3928     for (i = 0; i < pane_count; ++i)
3929     {
3930         if (all_panes.Item(i).name == wxT("dummy"))
3931             continue;
3932
3933         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3934         if (tabframe->m_tab_rect.Contains(pt))
3935             return tabframe->m_tabs;
3936     }
3937
3938     return NULL;
3939 }
3940
3941 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
3942 {
3943     // if we've just removed the last tab from the source
3944     // tab set, the remove the tab control completely
3945     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3946     size_t i, pane_count = all_panes.GetCount();
3947     for (i = 0; i < pane_count; ++i)
3948     {
3949         if (all_panes.Item(i).name == wxT("dummy"))
3950             continue;
3951
3952         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3953         if (tabframe->m_tabs == tab_ctrl)
3954         {
3955             return tabframe;
3956         }
3957     }
3958
3959     return NULL;
3960 }
3961
3962 void wxAuiNotebook::RemoveEmptyTabFrames()
3963 {
3964     // if we've just removed the last tab from the source
3965     // tab set, the remove the tab control completely
3966     wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
3967     size_t i, pane_count = all_panes.GetCount();
3968     for (i = 0; i < pane_count; ++i)
3969     {
3970         if (all_panes.Item(i).name == wxT("dummy"))
3971             continue;
3972
3973         wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
3974         if (tab_frame->m_tabs->GetPageCount() == 0)
3975         {
3976             m_mgr.DetachPane(tab_frame);
3977
3978             // use pending delete because sometimes during
3979             // window closing, refreshs are pending
3980             if (!wxPendingDelete.Member(tab_frame->m_tabs))
3981                 wxPendingDelete.Append(tab_frame->m_tabs);
3982
3983             tab_frame->m_tabs = NULL;
3984
3985             delete tab_frame;
3986         }
3987     }
3988
3989
3990     // check to see if there is still a center pane;
3991     // if there isn't, make a frame the center pane
3992     wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
3993     pane_count = panes.GetCount();
3994     wxWindow* first_good = NULL;
3995     bool center_found = false;
3996     for (i = 0; i < pane_count; ++i)
3997     {
3998         if (panes.Item(i).name == wxT("dummy"))
3999             continue;
4000         if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
4001             center_found = true;
4002         if (!first_good)
4003             first_good = panes.Item(i).window;
4004     }
4005
4006     if (!center_found && first_good)
4007     {
4008         m_mgr.GetPane(first_good).Centre();
4009     }
4010
4011     m_mgr.Update();
4012 }
4013
4014 void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
4015 {
4016     // if we're dragging a tab, don't change the current selection.
4017     // This code prevents a bug that used to happen when the hint window
4018     // was hidden.  In the bug, the focus would return to the notebook
4019     // child, which would then enter this handler and call
4020     // SetSelection, which is not desired turn tab dragging.
4021
4022     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4023     size_t i, pane_count = all_panes.GetCount();
4024     for (i = 0; i < pane_count; ++i)
4025     {
4026         wxAuiPaneInfo& pane = all_panes.Item(i);
4027         if (pane.name == wxT("dummy"))
4028             continue;
4029         wxTabFrame* tabframe = (wxTabFrame*)pane.window;
4030         if (tabframe->m_tabs->IsDragging())
4031             return;
4032     }
4033
4034
4035     // change the tab selection to the child
4036     // which was focused
4037     int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
4038     if (idx != -1 && idx != m_curpage)
4039     {
4040         SetSelection(idx);
4041     }
4042 }
4043
4044 void wxAuiNotebook::OnNavigationKeyNotebook(wxNavigationKeyEvent& event)
4045 {
4046     if ( event.IsWindowChange() ) {
4047         // change pages
4048         // FIXME: the problem with this is that if we have a split notebook,
4049         // we selection may go all over the place.
4050         AdvanceSelection(event.GetDirection());
4051     }
4052     else {
4053         // we get this event in 3 cases
4054         //
4055         // a) one of our pages might have generated it because the user TABbed
4056         // out from it in which case we should propagate the event upwards and
4057         // our parent will take care of setting the focus to prev/next sibling
4058         //
4059         // or
4060         //
4061         // b) the parent panel wants to give the focus to us so that we
4062         // forward it to our selected page. We can't deal with this in
4063         // OnSetFocus() because we don't know which direction the focus came
4064         // from in this case and so can't choose between setting the focus to
4065         // first or last panel child
4066         //
4067         // or
4068         //
4069         // c) we ourselves (see MSWTranslateMessage) generated the event
4070         //
4071         wxWindow * const parent = GetParent();
4072
4073         // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
4074         const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
4075         const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
4076
4077         if ( isFromParent || isFromSelf )
4078         {
4079             // no, it doesn't come from child, case (b) or (c): forward to a
4080             // page but only if direction is backwards (TAB) or from ourselves,
4081             if ( GetSelection() != wxNOT_FOUND &&
4082                     (!event.GetDirection() || isFromSelf) )
4083             {
4084                 // so that the page knows that the event comes from it's parent
4085                 // and is being propagated downwards
4086                 event.SetEventObject(this);
4087
4088                 wxWindow *page = GetPage(GetSelection());
4089                 if ( !page->GetEventHandler()->ProcessEvent(event) )
4090                 {
4091                     page->SetFocus();
4092                 }
4093                 //else: page manages focus inside it itself
4094             }
4095             else // otherwise set the focus to the notebook itself
4096             {
4097                 SetFocus();
4098             }
4099         }
4100         else
4101         {
4102             // it comes from our child, case (a), pass to the parent, but only
4103             // if the direction is forwards. Otherwise set the focus to the
4104             // notebook itself. The notebook is always the 'first' control of a
4105             // page.
4106             if ( !event.GetDirection() )
4107             {
4108                 SetFocus();
4109             }
4110             else if ( parent )
4111             {
4112                 event.SetCurrentFocus(this);
4113                 parent->GetEventHandler()->ProcessEvent(event);
4114             }
4115         }
4116     }
4117 }
4118
4119 void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
4120 {
4121     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
4122     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4123
4124     int button_id = evt.GetInt();
4125
4126     if (button_id == wxAUI_BUTTON_CLOSE)
4127     {
4128         int selection = evt.GetSelection();
4129
4130         if (selection == -1)
4131         {
4132             // if the close button is to the right, use the active
4133             // page selection to determine which page to close
4134             selection = GetSelection();
4135         }
4136
4137         if (selection != -1)
4138         {
4139             wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
4140
4141             // ask owner if it's ok to close the tab
4142             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
4143             e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
4144             e.SetOldSelection(evt.GetSelection());
4145             e.SetEventObject(this);
4146             GetEventHandler()->ProcessEvent(e);
4147             if (!e.IsAllowed())
4148                 return;
4149
4150
4151             if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
4152             {
4153                 close_wnd->Close();
4154             }
4155             else
4156             {
4157                 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
4158                 wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no page to delete?") );
4159
4160                 DeletePage(main_idx);
4161             }
4162         }
4163     }
4164 }
4165
4166
4167 void wxAuiNotebook::OnTabMiddleDown(wxCommandEvent& evt)
4168 {
4169     // patch event through to owner
4170     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4171     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4172
4173     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
4174     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4175     e.SetEventObject(this);
4176     GetEventHandler()->ProcessEvent(e);
4177 }
4178
4179 void wxAuiNotebook::OnTabMiddleUp(wxCommandEvent& evt)
4180 {
4181     // if the wxAUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
4182     // click should act like a tab close action.  However, first
4183     // give the owner an opportunity to handle the middle up event
4184     // for custom action
4185
4186     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4187     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4188
4189     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
4190     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4191     e.SetEventObject(this);
4192     if (GetEventHandler()->ProcessEvent(e))
4193         return;
4194     if (!e.IsAllowed())
4195         return;
4196
4197     // check if we are supposed to close on middle-up
4198     if ((m_flags & wxAUI_NB_MIDDLE_CLICK_CLOSE) == 0)
4199         return;
4200
4201     // simulate the user pressing the close button on the tab
4202     evt.SetInt(wxAUI_BUTTON_CLOSE);
4203     OnTabButton(evt);
4204 }
4205
4206 void wxAuiNotebook::OnTabRightDown(wxCommandEvent& evt)
4207 {
4208     // patch event through to owner
4209     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4210     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4211
4212     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
4213     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4214     e.SetEventObject(this);
4215     GetEventHandler()->ProcessEvent(e);
4216 }
4217
4218 void wxAuiNotebook::OnTabRightUp(wxCommandEvent& evt)
4219 {
4220     // patch event through to owner
4221     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4222     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4223
4224     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
4225     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4226     e.SetEventObject(this);
4227     GetEventHandler()->ProcessEvent(e);
4228 }
4229
4230 // Sets the normal font
4231 void wxAuiNotebook::SetNormalFont(const wxFont& font)
4232 {
4233     m_normal_font = font;
4234     GetArtProvider()->SetNormalFont(font);
4235 }
4236
4237 // Sets the selected tab font
4238 void wxAuiNotebook::SetSelectedFont(const wxFont& font)
4239 {
4240     m_selected_font = font;
4241     GetArtProvider()->SetSelectedFont(font);
4242 }
4243
4244 // Sets the measuring font
4245 void wxAuiNotebook::SetMeasuringFont(const wxFont& font)
4246 {
4247     GetArtProvider()->SetMeasuringFont(font);
4248 }
4249
4250 // Sets the tab font
4251 bool wxAuiNotebook::SetFont(const wxFont& font)
4252 {
4253     wxControl::SetFont(font);
4254
4255     wxFont normalFont(font);
4256     wxFont selectedFont(normalFont);
4257     selectedFont.SetWeight(wxBOLD);
4258
4259     SetNormalFont(normalFont);
4260     SetSelectedFont(selectedFont);
4261     SetMeasuringFont(selectedFont);
4262
4263     return true;
4264 }
4265
4266 // Gets the tab control height
4267 int wxAuiNotebook::GetTabCtrlHeight() const
4268 {
4269     return m_tab_ctrl_height;
4270 }
4271
4272 // Gets the height of the notebook for a given page height
4273 int wxAuiNotebook::GetHeightForPageHeight(int pageHeight)
4274 {
4275     UpdateTabCtrlHeight();
4276
4277     int tabCtrlHeight = GetTabCtrlHeight();
4278     int decorHeight = 2;
4279     return tabCtrlHeight + pageHeight + decorHeight;
4280 }
4281
4282 // Advances the selection, generation page selection events
4283 void wxAuiNotebook::AdvanceSelection(bool forward)
4284 {
4285     if (GetPageCount() <= 1)
4286         return;
4287
4288     int currentSelection = GetSelection();
4289
4290     if (forward)
4291     {
4292         if (currentSelection == (int) (GetPageCount() - 1))
4293             return;
4294         else if (currentSelection == -1)
4295             currentSelection = 0;
4296         else
4297             currentSelection ++;
4298     }
4299     else
4300     {
4301         if (currentSelection <= 0)
4302             return;
4303         else
4304             currentSelection --;
4305     }
4306
4307     SetSelection(currentSelection);
4308 }
4309
4310 // Shows the window menu
4311 bool wxAuiNotebook::ShowWindowMenu()
4312 {
4313     wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
4314
4315     int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
4316
4317     if (idx != -1)
4318     {
4319         wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
4320         e.SetSelection(idx);
4321         e.SetOldSelection(tabCtrl->GetActivePage());
4322         e.SetEventObject(tabCtrl);
4323         GetEventHandler()->ProcessEvent(e);
4324
4325         return true;
4326     }
4327     else
4328         return false;
4329 }
4330
4331 #endif // wxUSE_AUI