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