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     m_click_pt = wxDefaultPosition;
2172     m_is_dragging = false;
2173     m_hover_button = NULL;
2174     m_pressed_button = NULL;
2175 }
2176
2177 wxAuiTabCtrl::~wxAuiTabCtrl()
2178 {
2179 }
2180
2181 void wxAuiTabCtrl::OnPaint(wxPaintEvent&)
2182 {
2183     wxPaintDC dc(this);
2184
2185     dc.SetFont(GetFont());
2186
2187     if (GetPageCount() > 0)
2188         Render(&dc, this);
2189 }
2190
2191 void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
2192 {
2193 }
2194
2195 void wxAuiTabCtrl::OnSize(wxSizeEvent& evt)
2196 {
2197     wxSize s = evt.GetSize();
2198     wxRect r(0, 0, s.GetWidth(), s.GetHeight());
2199     SetRect(r);
2200 }
2201
2202 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
2203 {
2204     // Set the focus
2205     if (FindFocus() != this)
2206     {
2207         SetFocus();
2208         Refresh();
2209     }
2210
2211     CaptureMouse();
2212     m_click_pt = wxDefaultPosition;
2213     m_is_dragging = false;
2214     m_click_tab = NULL;
2215     m_pressed_button = NULL;
2216
2217
2218     wxWindow* wnd;
2219     if (TabHitTest(evt.m_x, evt.m_y, &wnd))
2220     {
2221         int new_selection = GetIdxFromWindow(wnd);
2222
2223         // wxAuiNotebooks always want to receive this event
2224         // even if the tab is already active, because they may
2225         // have multiple tab controls
2226         if (new_selection != GetActivePage() ||
2227             GetParent()->IsKindOf(CLASSINFO(wxAuiNotebook)))
2228         {
2229             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2230             e.SetSelection(new_selection);
2231             e.SetOldSelection(GetActivePage());
2232             e.SetEventObject(this);
2233             GetEventHandler()->ProcessEvent(e);
2234         }
2235
2236         m_click_pt.x = evt.m_x;
2237         m_click_pt.y = evt.m_y;
2238         m_click_tab = wnd;
2239     }
2240
2241     if (m_hover_button)
2242     {
2243         m_pressed_button = m_hover_button;
2244         m_pressed_button->cur_state = wxAUI_BUTTON_STATE_PRESSED;
2245         Refresh();
2246         Update();
2247     }
2248 }
2249
2250 void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
2251 {
2252     if (GetCapture() == this)
2253         ReleaseMouse();
2254
2255     if (m_is_dragging)
2256     {
2257         m_is_dragging = false;
2258
2259         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
2260         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2261         evt.SetOldSelection(evt.GetSelection());
2262         evt.SetEventObject(this);
2263         GetEventHandler()->ProcessEvent(evt);
2264
2265         return;
2266     }
2267
2268     if (m_pressed_button)
2269     {
2270         // make sure we're still clicking the button
2271         wxAuiTabContainerButton* button = NULL;
2272         if (!ButtonHitTest(evt.m_x, evt.m_y, &button))
2273             return;
2274
2275         if (button != m_pressed_button)
2276         {
2277             m_pressed_button = NULL;
2278             return;
2279         }
2280
2281         Refresh();
2282         Update();
2283
2284         if (!(m_pressed_button->cur_state & wxAUI_BUTTON_STATE_DISABLED))
2285         {
2286             wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
2287             evt.SetSelection(GetIdxFromWindow(m_click_tab));
2288             evt.SetInt(m_pressed_button->id);
2289             evt.SetEventObject(this);
2290             GetEventHandler()->ProcessEvent(evt);
2291         }
2292
2293         m_pressed_button = NULL;
2294     }
2295
2296     m_click_pt = wxDefaultPosition;
2297     m_is_dragging = false;
2298     m_click_tab = NULL;
2299 }
2300
2301 void wxAuiTabCtrl::OnMiddleUp(wxMouseEvent& evt)
2302 {
2303     wxWindow* wnd = NULL;
2304     if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2305         return;
2306
2307     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
2308     e.SetEventObject(this);
2309     e.SetSelection(GetIdxFromWindow(wnd));
2310     GetEventHandler()->ProcessEvent(e);
2311 }
2312
2313 void wxAuiTabCtrl::OnMiddleDown(wxMouseEvent& evt)
2314 {
2315     wxWindow* wnd = NULL;
2316     if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2317         return;
2318
2319     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
2320     e.SetEventObject(this);
2321     e.SetSelection(GetIdxFromWindow(wnd));
2322     GetEventHandler()->ProcessEvent(e);
2323 }
2324
2325 void wxAuiTabCtrl::OnRightUp(wxMouseEvent& evt)
2326 {
2327     wxWindow* wnd = NULL;
2328     if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2329         return;
2330
2331     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
2332     e.SetEventObject(this);
2333     e.SetSelection(GetIdxFromWindow(wnd));
2334     GetEventHandler()->ProcessEvent(e);
2335 }
2336
2337 void wxAuiTabCtrl::OnRightDown(wxMouseEvent& evt)
2338 {
2339     wxWindow* wnd = NULL;
2340     if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2341         return;
2342
2343     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
2344     e.SetEventObject(this);
2345     e.SetSelection(GetIdxFromWindow(wnd));
2346     GetEventHandler()->ProcessEvent(e);
2347 }
2348
2349 void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
2350 {
2351     wxPoint pos = evt.GetPosition();
2352
2353     // check if the mouse is hovering above a button
2354     wxAuiTabContainerButton* button;
2355     if (ButtonHitTest(pos.x, pos.y, &button))
2356     {
2357         if (m_hover_button && button != m_hover_button)
2358         {
2359             m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2360             m_hover_button = NULL;
2361             Refresh();
2362             Update();
2363         }
2364
2365         if (button->cur_state != wxAUI_BUTTON_STATE_HOVER)
2366         {
2367             button->cur_state = wxAUI_BUTTON_STATE_HOVER;
2368             Refresh();
2369             Update();
2370             m_hover_button = button;
2371             return;
2372         }
2373     }
2374     else
2375     {
2376         if (m_hover_button)
2377         {
2378             m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2379             m_hover_button = NULL;
2380             Refresh();
2381             Update();
2382         }
2383     }
2384
2385
2386     if (!evt.LeftIsDown() || m_click_pt == wxDefaultPosition)
2387         return;
2388
2389     if (m_is_dragging)
2390     {
2391         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
2392         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2393         evt.SetOldSelection(evt.GetSelection());
2394         evt.SetEventObject(this);
2395         GetEventHandler()->ProcessEvent(evt);
2396         return;
2397     }
2398
2399
2400     int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
2401     int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
2402
2403     if (abs(pos.x - m_click_pt.x) > drag_x_threshold ||
2404         abs(pos.y - m_click_pt.y) > drag_y_threshold)
2405     {
2406         wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
2407         evt.SetSelection(GetIdxFromWindow(m_click_tab));
2408         evt.SetOldSelection(evt.GetSelection());
2409         evt.SetEventObject(this);
2410         GetEventHandler()->ProcessEvent(evt);
2411
2412         m_is_dragging = true;
2413     }
2414 }
2415
2416 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
2417 {
2418     if (m_hover_button)
2419     {
2420         m_hover_button->cur_state = wxAUI_BUTTON_STATE_NORMAL;
2421         m_hover_button = NULL;
2422         Refresh();
2423         Update();
2424     }
2425 }
2426
2427 void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
2428 {
2429     int button = event.GetInt();
2430
2431     if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
2432     {
2433         if (button == wxAUI_BUTTON_LEFT)
2434         {
2435             if (GetTabOffset() > 0)
2436             {
2437                 SetTabOffset(GetTabOffset()-1);
2438                 Refresh();
2439                 Update();
2440             }
2441         }
2442         else
2443         {
2444             SetTabOffset(GetTabOffset()+1);
2445             Refresh();
2446             Update();
2447         }
2448     }
2449     else if (button == wxAUI_BUTTON_WINDOWLIST)
2450     {
2451         int idx = GetArtProvider()->ShowDropDown(this, m_pages, GetActivePage());
2452
2453         if (idx != -1)
2454         {
2455             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2456             e.SetSelection(idx);
2457             e.SetOldSelection(GetActivePage());
2458             e.SetEventObject(this);
2459             GetEventHandler()->ProcessEvent(e);
2460         }
2461     }
2462     else
2463     {
2464         event.Skip();
2465     }
2466 }
2467
2468 void wxAuiTabCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
2469 {
2470     Refresh();
2471 }
2472
2473 void wxAuiTabCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
2474 {
2475     Refresh();
2476 }
2477
2478 void wxAuiTabCtrl::OnChar(wxKeyEvent& event)
2479 {
2480     if (GetActivePage() == -1)
2481     {
2482         event.Skip();
2483         return;
2484     }
2485
2486     // We can't leave tab processing to the system; on Windows, tabs and keys
2487     // get eaten by the system and not processed properly if we specify both
2488     // wxTAB_TRAVERSAL and wxWANTS_CHARS. And if we specify just wxTAB_TRAVERSAL,
2489     // we don't key arrow key events.
2490
2491     int key = event.GetKeyCode();
2492
2493     if (key == WXK_NUMPAD_PAGEUP)
2494         key = WXK_PAGEUP;
2495     if (key == WXK_NUMPAD_PAGEDOWN)
2496         key = WXK_PAGEDOWN;
2497     if (key == WXK_NUMPAD_HOME)
2498         key = WXK_HOME;
2499     if (key == WXK_NUMPAD_END)
2500         key = WXK_END;
2501     if (key == WXK_NUMPAD_LEFT)
2502         key = WXK_LEFT;
2503     if (key == WXK_NUMPAD_RIGHT)
2504         key = WXK_RIGHT;
2505
2506     if (key == WXK_TAB || key == WXK_PAGEUP || key == WXK_PAGEDOWN)
2507     {
2508         bool bCtrlDown = event.ControlDown();
2509         bool bShiftDown = event.ShiftDown();
2510
2511         bool bForward = (key == WXK_TAB && !bShiftDown) || (key == WXK_PAGEDOWN);
2512         bool bWindowChange = (key == WXK_PAGEUP) || (key == WXK_PAGEDOWN) || bCtrlDown;
2513         bool bFromTab = (key == WXK_TAB);
2514
2515         wxAuiNotebook* nb = wxDynamicCast(GetParent(), wxAuiNotebook);
2516         if (!nb)
2517         {
2518             event.Skip();
2519             return;
2520         }
2521
2522         wxNavigationKeyEvent keyEvent;
2523         keyEvent.SetDirection(bForward);
2524         keyEvent.SetWindowChange(bWindowChange);
2525         keyEvent.SetFromTab(bFromTab);
2526         keyEvent.SetEventObject(nb);
2527
2528         if (!nb->GetEventHandler()->ProcessEvent(keyEvent))
2529         {
2530             // Not processed? Do an explicit tab into the page.
2531             wxWindow* win = GetWindowFromIdx(GetActivePage());
2532             if (win)
2533                 win->SetFocus();
2534         }
2535         return;
2536     }
2537
2538     if (m_pages.GetCount() < 2)
2539     {
2540         event.Skip();
2541         return;
2542     }
2543
2544     int newPage = -1;
2545
2546     if (key == WXK_RIGHT)
2547     {
2548         if (m_pages.GetCount() > 1)
2549         {
2550             if (GetActivePage() == -1)
2551                 newPage = 0;
2552             else if (GetActivePage() < (int) (m_pages.GetCount() - 1))
2553                 newPage = GetActivePage() + 1;
2554         }
2555     }
2556     else if (key == WXK_LEFT)
2557     {
2558         if (m_pages.GetCount() > 1)
2559         {
2560             if (GetActivePage() == -1)
2561                 newPage = (int) (m_pages.GetCount() - 1);
2562             else if (GetActivePage() > 0)
2563                 newPage = GetActivePage() - 1;
2564         }
2565     }
2566     else if (key == WXK_HOME)
2567     {
2568         newPage = 0;
2569     }
2570     else if (key == WXK_END)
2571     {
2572         newPage = (int) (m_pages.GetCount() - 1);
2573     }
2574     else
2575         event.Skip();
2576
2577     if (newPage != -1)
2578     {
2579         wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2580         e.SetSelection(newPage);
2581         e.SetOldSelection(newPage);
2582         e.SetEventObject(this);
2583         this->GetEventHandler()->ProcessEvent(e);
2584     }
2585     else
2586         event.Skip();
2587 }
2588
2589 // wxTabFrame is an interesting case.  It's important that all child pages
2590 // of the multi-notebook control are all actually children of that control
2591 // (and not grandchildren).  wxTabFrame facilitates this.  There is one
2592 // instance of wxTabFrame for each tab control inside the multi-notebook.
2593 // It's important to know that wxTabFrame is not a real window, but it merely
2594 // used to capture the dimensions/positioning of the internal tab control and
2595 // it's managed page windows
2596
2597 class wxTabFrame : public wxWindow
2598 {
2599 public:
2600
2601     wxTabFrame()
2602     {
2603         m_tabs = NULL;
2604         m_rect = wxRect(0,0,200,200);
2605         m_tab_ctrl_height = 20;
2606     }
2607
2608     ~wxTabFrame()
2609     {
2610         wxDELETE(m_tabs);
2611     }
2612
2613     void SetTabCtrlHeight(int h)
2614     {
2615         m_tab_ctrl_height = h;
2616     }
2617
2618 protected:
2619     void DoSetSize(int x, int y,
2620                    int width, int height,
2621                    int WXUNUSED(sizeFlags = wxSIZE_AUTO))
2622     {
2623         m_rect = wxRect(x, y, width, height);
2624         DoSizing();
2625     }
2626
2627     void DoGetClientSize(int* x, int* y) const
2628     {
2629         *x = m_rect.width;
2630         *y = m_rect.height;
2631     }
2632
2633 public:
2634     bool Show( bool WXUNUSED(show = true) ) { return false; }
2635
2636     void DoSizing()
2637     {
2638         if (!m_tabs)
2639             return;
2640
2641         m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2642         m_tabs->SetSize(m_rect.x, m_rect.y, m_rect.width, m_tab_ctrl_height);
2643         m_tabs->SetRect(wxRect(0, 0, m_rect.width, m_tab_ctrl_height));
2644         m_tabs->Refresh();
2645         m_tabs->Update();
2646
2647         wxAuiNotebookPageArray& pages = m_tabs->GetPages();
2648         size_t i, page_count = pages.GetCount();
2649
2650         for (i = 0; i < page_count; ++i)
2651         {
2652             wxAuiNotebookPage& page = pages.Item(i);
2653             page.window->SetSize(m_rect.x, m_rect.y + m_tab_ctrl_height,
2654                                  m_rect.width, m_rect.height - m_tab_ctrl_height);
2655
2656             if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2657             {
2658                 wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
2659                 wnd->ApplyMDIChildFrameRect();
2660             }
2661         }
2662     }
2663
2664 protected:
2665     void DoGetSize(int* x, int* y) const
2666     {
2667         if (x)
2668             *x = m_rect.GetWidth();
2669         if (y)
2670             *y = m_rect.GetHeight();
2671     }
2672
2673 public:
2674     void Update()
2675     {
2676         // does nothing
2677     }
2678
2679     wxRect m_rect;
2680     wxRect m_tab_rect;
2681     wxAuiTabCtrl* m_tabs;
2682     int m_tab_ctrl_height;
2683 };
2684
2685
2686 const int wxAuiBaseTabCtrlId = 5380;
2687
2688
2689 // -- wxAuiNotebook class implementation --
2690
2691 BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
2692     EVT_SIZE(wxAuiNotebook::OnSize)
2693     EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocus)
2694     EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2695                       wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
2696                       wxAuiNotebook::OnTabClicked)
2697     EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2698                       wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
2699                       wxAuiNotebook::OnTabBeginDrag)
2700     EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2701                       wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
2702                       wxAuiNotebook::OnTabEndDrag)
2703     EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2704                       wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
2705                       wxAuiNotebook::OnTabDragMotion)
2706     EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2707                       wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
2708                       wxAuiNotebook::OnTabButton)
2709     EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2710                       wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN,
2711                       wxAuiNotebook::OnTabMiddleDown)
2712     EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2713                       wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP,
2714                       wxAuiNotebook::OnTabMiddleUp)
2715     EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2716                       wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN,
2717                       wxAuiNotebook::OnTabRightDown)
2718     EVT_COMMAND_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2719                       wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
2720                       wxAuiNotebook::OnTabRightUp)
2721     EVT_NAVIGATION_KEY(wxAuiNotebook::OnNavigationKey)
2722 END_EVENT_TABLE()
2723
2724 wxAuiNotebook::wxAuiNotebook()
2725 {
2726     m_curpage = -1;
2727     m_tab_id_counter = wxAuiBaseTabCtrlId;
2728     m_dummy_wnd = NULL;
2729     m_tab_ctrl_height = 20;
2730     m_requested_bmp_size = wxDefaultSize;
2731     m_requested_tabctrl_height = -1;
2732 }
2733
2734 wxAuiNotebook::wxAuiNotebook(wxWindow *parent,
2735                              wxWindowID id,
2736                              const wxPoint& pos,
2737                              const wxSize& size,
2738                              long style) : wxControl(parent, id, pos, size, style)
2739 {
2740     m_dummy_wnd = NULL;
2741     m_requested_bmp_size = wxDefaultSize;
2742     m_requested_tabctrl_height = -1;
2743     InitNotebook(style);
2744 }
2745
2746 bool wxAuiNotebook::Create(wxWindow* parent,
2747                            wxWindowID id,
2748                            const wxPoint& pos,
2749                            const wxSize& size,
2750                            long style)
2751 {
2752     if (!wxControl::Create(parent, id, pos, size, style))
2753         return false;
2754
2755     InitNotebook(style);
2756
2757     return true;
2758 }
2759
2760 // InitNotebook() contains common initialization
2761 // code called by all constructors
2762 void wxAuiNotebook::InitNotebook(long style)
2763 {
2764     m_curpage = -1;
2765     m_tab_id_counter = wxAuiBaseTabCtrlId;
2766     m_dummy_wnd = NULL;
2767     m_flags = (unsigned int)style;
2768     m_tab_ctrl_height = 20;
2769
2770     m_normal_font = *wxNORMAL_FONT;
2771     m_selected_font = *wxNORMAL_FONT;
2772     m_selected_font.SetWeight(wxBOLD);
2773
2774     SetArtProvider(new wxAuiDefaultTabArt);
2775
2776     m_dummy_wnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
2777     m_dummy_wnd->SetSize(200, 200);
2778     m_dummy_wnd->Show(false);
2779
2780     m_mgr.SetManagedWindow(this);
2781     m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
2782     m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
2783
2784     m_mgr.AddPane(m_dummy_wnd,
2785               wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
2786
2787     m_mgr.Update();
2788 }
2789
2790 wxAuiNotebook::~wxAuiNotebook()
2791 {
2792     m_mgr.UnInit();
2793 }
2794
2795 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
2796 {
2797     m_tabs.SetArtProvider(art);
2798
2799     UpdateTabCtrlHeight();
2800 }
2801
2802 // SetTabCtrlHeight() is the highest-level override of the
2803 // tab height.  A call to this function effectively enforces a
2804 // specified tab ctrl height, overriding all other considerations,
2805 // such as text or bitmap height.  It overrides any call to
2806 // SetUniformBitmapSize().  Specifying a height of -1 reverts
2807 // any previous call and returns to the default behavior
2808
2809 void wxAuiNotebook::SetTabCtrlHeight(int height)
2810 {
2811     m_requested_tabctrl_height = height;
2812
2813     // if window is already initialized, recalculate the tab height
2814     if (m_dummy_wnd)
2815     {
2816         UpdateTabCtrlHeight();
2817     }
2818 }
2819
2820
2821 // SetUniformBitmapSize() ensures that all tabs will have
2822 // the same height, even if some tabs don't have bitmaps
2823 // Passing wxDefaultSize to this function will instruct
2824 // the control to use dynamic tab height-- so when a tab
2825 // with a large bitmap is added, the tab ctrl's height will
2826 // automatically increase to accommodate the bitmap
2827
2828 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
2829 {
2830     m_requested_bmp_size = size;
2831
2832     // if window is already initialized, recalculate the tab height
2833     if (m_dummy_wnd)
2834     {
2835         UpdateTabCtrlHeight();
2836     }
2837 }
2838
2839 // UpdateTabCtrlHeight() does the actual tab resizing. It's meant
2840 // to be used interally
2841 void wxAuiNotebook::UpdateTabCtrlHeight()
2842 {
2843     // get the tab ctrl height we will use
2844     int height = CalculateTabCtrlHeight();
2845
2846     // if the tab control height needs to change, update
2847     // all of our tab controls with the new height
2848     if (m_tab_ctrl_height != height)
2849     {
2850         wxAuiTabArt* art = m_tabs.GetArtProvider();
2851
2852         m_tab_ctrl_height = height;
2853
2854         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2855         size_t i, pane_count = all_panes.GetCount();
2856         for (i = 0; i < pane_count; ++i)
2857         {
2858             wxAuiPaneInfo& pane = all_panes.Item(i);
2859             if (pane.name == wxT("dummy"))
2860                 continue;
2861             wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
2862             wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
2863             tab_frame->SetTabCtrlHeight(m_tab_ctrl_height);
2864             tabctrl->SetArtProvider(art->Clone());
2865             tab_frame->DoSizing();
2866         }
2867     }
2868 }
2869
2870 void wxAuiNotebook::UpdateHintWindowSize()
2871 {
2872     wxSize size = CalculateNewSplitSize();
2873
2874     // the placeholder hint window should be set to this size
2875     wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
2876     if (info.IsOk())
2877     {
2878         info.MinSize(size);
2879         info.BestSize(size);
2880         m_dummy_wnd->SetSize(size);
2881     }
2882 }
2883
2884
2885 // calculates the size of the new split
2886 wxSize wxAuiNotebook::CalculateNewSplitSize()
2887 {
2888     // count number of tab controls
2889     int tab_ctrl_count = 0;
2890     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2891     size_t i, pane_count = all_panes.GetCount();
2892     for (i = 0; i < pane_count; ++i)
2893     {
2894         wxAuiPaneInfo& pane = all_panes.Item(i);
2895         if (pane.name == wxT("dummy"))
2896             continue;
2897         tab_ctrl_count++;
2898     }
2899
2900     wxSize new_split_size;
2901
2902     // if there is only one tab control, the first split
2903     // should happen around the middle
2904     if (tab_ctrl_count < 2)
2905     {
2906         new_split_size = GetClientSize();
2907         new_split_size.x /= 2;
2908         new_split_size.y /= 2;
2909     }
2910     else
2911     {
2912         // this is in place of a more complicated calculation
2913         // that needs to be implemented
2914         new_split_size = wxSize(180,180);
2915     }
2916
2917     return new_split_size;
2918 }
2919
2920 int wxAuiNotebook::CalculateTabCtrlHeight()
2921 {
2922     // if a fixed tab ctrl height is specified,
2923     // just return that instead of calculating a
2924     // tab height
2925     if (m_requested_tabctrl_height != -1)
2926         return m_requested_tabctrl_height;
2927
2928     // find out new best tab height
2929     wxAuiTabArt* art = m_tabs.GetArtProvider();
2930
2931     return art->GetBestTabCtrlSize(this,
2932                                    m_tabs.GetPages(),
2933                                    m_requested_bmp_size);
2934 }
2935
2936
2937 wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
2938 {
2939     return m_tabs.GetArtProvider();
2940 }
2941
2942 void wxAuiNotebook::SetWindowStyleFlag(long style)
2943 {
2944     wxControl::SetWindowStyleFlag(style);
2945
2946     m_flags = (unsigned int)style;
2947
2948     // if the control is already initialized
2949     if (m_mgr.GetManagedWindow() == (wxWindow*)this)
2950     {
2951         // let all of the tab children know about the new style
2952
2953         wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2954         size_t i, pane_count = all_panes.GetCount();
2955         for (i = 0; i < pane_count; ++i)
2956         {
2957             wxAuiPaneInfo& pane = all_panes.Item(i);
2958             if (pane.name == wxT("dummy"))
2959                 continue;
2960             wxTabFrame* tabframe = (wxTabFrame*)pane.window;
2961             wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
2962             tabctrl->SetFlags(m_flags);
2963             tabframe->DoSizing();
2964             tabctrl->Refresh();
2965             tabctrl->Update();
2966         }
2967     }
2968 }
2969
2970
2971 bool wxAuiNotebook::AddPage(wxWindow* page,
2972                             const wxString& caption,
2973                             bool select,
2974                             const wxBitmap& bitmap)
2975 {
2976     return InsertPage(GetPageCount(), page, caption, select, bitmap);
2977 }
2978
2979 bool wxAuiNotebook::InsertPage(size_t page_idx,
2980                                wxWindow* page,
2981                                const wxString& caption,
2982                                bool select,
2983                                const wxBitmap& bitmap)
2984 {
2985     wxAuiNotebookPage info;
2986     info.window = page;
2987     info.caption = caption;
2988     info.bitmap = bitmap;
2989     info.active = false;
2990
2991     // if there are currently no tabs, the first added
2992     // tab must be active
2993     if (m_tabs.GetPageCount() == 0)
2994         info.active = true;
2995
2996     m_tabs.InsertPage(page, info, page_idx);
2997
2998     // if that was the first page added, even if
2999     // select is false, it must become the "current page"
3000     // (though no select events will be fired)
3001     if (!select && m_tabs.GetPageCount() == 1)
3002         select = true;
3003         //m_curpage = GetPageIndex(page);
3004
3005     wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
3006     if (page_idx >= active_tabctrl->GetPageCount())
3007         active_tabctrl->AddPage(page, info);
3008     else
3009         active_tabctrl->InsertPage(page, info, page_idx);
3010
3011     UpdateTabCtrlHeight();
3012     DoSizing();
3013     active_tabctrl->DoShowHide();
3014
3015     if (select)
3016     {
3017         SetSelectionToWindow(page);
3018     }
3019
3020     return true;
3021 }
3022
3023
3024 // DeletePage() removes a tab from the multi-notebook,
3025 // and destroys the window as well
3026 bool wxAuiNotebook::DeletePage(size_t page_idx)
3027 {
3028     if (page_idx >= m_tabs.GetPageCount())
3029         return false;
3030
3031     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3032
3033     // hide the window in advance, as this will
3034     // prevent flicker
3035     ShowWnd(wnd, false);
3036
3037     if (!RemovePage(page_idx))
3038         return false;
3039
3040     // actually destroy the window now
3041     if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3042     {
3043         // delete the child frame with pending delete, as is
3044         // customary with frame windows
3045         if (!wxPendingDelete.Member(wnd))
3046             wxPendingDelete.Append(wnd);
3047     }
3048     else
3049     {
3050         wnd->Destroy();
3051     }
3052
3053     return true;
3054 }
3055
3056
3057
3058 // RemovePage() removes a tab from the multi-notebook,
3059 // but does not destroy the window
3060 bool wxAuiNotebook::RemovePage(size_t page_idx)
3061 {
3062     // save active window pointer
3063     wxWindow* active_wnd = NULL;
3064     if (m_curpage >= 0)
3065         active_wnd = m_tabs.GetWindowFromIdx(m_curpage);
3066
3067     // save pointer of window being deleted
3068     wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3069     wxWindow* new_active = NULL;
3070
3071     // make sure we found the page
3072     if (!wnd)
3073         return false;
3074
3075     // find out which onscreen tab ctrl owns this tab
3076     wxAuiTabCtrl* ctrl;
3077     int ctrl_idx;
3078     if (!FindTab(wnd, &ctrl, &ctrl_idx))
3079         return false;
3080
3081     bool is_curpage = (m_curpage == (int)page_idx);
3082     bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
3083
3084
3085     // remove the tab from main catalog
3086     if (!m_tabs.RemovePage(wnd))
3087         return false;
3088
3089     // remove the tab from the onscreen tab ctrl
3090     ctrl->RemovePage(wnd);
3091
3092     if (is_active_in_split)
3093     {
3094         int ctrl_new_page_count = (int)ctrl->GetPageCount();
3095
3096         if (ctrl_idx >= ctrl_new_page_count)
3097             ctrl_idx = ctrl_new_page_count-1;
3098
3099         if (ctrl_idx >= 0 && ctrl_idx < (int)ctrl->GetPageCount())
3100         {
3101             // set new page as active in the tab split
3102             ctrl->SetActivePage(ctrl_idx);
3103
3104             // if the page deleted was the current page for the
3105             // entire tab control, then record the window
3106             // pointer of the new active page for activation
3107             if (is_curpage)
3108             {
3109                 new_active = ctrl->GetWindowFromIdx(ctrl_idx);
3110             }
3111         }
3112     }
3113     else
3114     {
3115         // we are not deleting the active page, so keep it the same
3116         new_active = active_wnd;
3117     }
3118
3119
3120     if (!new_active)
3121     {
3122         // we haven't yet found a new page to active,
3123         // so select the next page from the main tab
3124         // catalogue
3125
3126         if (page_idx < m_tabs.GetPageCount())
3127         {
3128             new_active = m_tabs.GetPage(page_idx).window;
3129         }
3130
3131         if (!new_active && m_tabs.GetPageCount() > 0)
3132         {
3133             new_active = m_tabs.GetPage(0).window;
3134         }
3135     }
3136
3137
3138     RemoveEmptyTabFrames();
3139
3140     // set new active pane
3141     if (new_active)
3142     {
3143         m_curpage = -1;
3144         SetSelectionToWindow(new_active);
3145     }
3146
3147     return true;
3148 }
3149
3150 // GetPageIndex() returns the index of the page, or -1 if the
3151 // page could not be located in the notebook
3152 int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
3153 {
3154     return m_tabs.GetIdxFromWindow(page_wnd);
3155 }
3156
3157
3158
3159 // SetPageText() changes the tab caption of the specified page
3160 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
3161 {
3162     if (page_idx >= m_tabs.GetPageCount())
3163         return false;
3164
3165     // update our own tab catalog
3166     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3167     page_info.caption = text;
3168
3169     // update what's on screen
3170     wxAuiTabCtrl* ctrl;
3171     int ctrl_idx;
3172     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3173     {
3174         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3175         info.caption = text;
3176         ctrl->Refresh();
3177         ctrl->Update();
3178     }
3179
3180     return true;
3181 }
3182
3183 // returns the page caption
3184 wxString wxAuiNotebook::GetPageText(size_t page_idx) const
3185 {
3186     if (page_idx >= m_tabs.GetPageCount())
3187         return wxEmptyString;
3188
3189     // update our own tab catalog
3190     const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3191     return page_info.caption;
3192 }
3193
3194 bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
3195 {
3196     if (page_idx >= m_tabs.GetPageCount())
3197         return false;
3198
3199     // update our own tab catalog
3200     wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3201     page_info.bitmap = bitmap;
3202
3203     // tab height might have changed
3204     UpdateTabCtrlHeight();
3205
3206     // update what's on screen
3207     wxAuiTabCtrl* ctrl;
3208     int ctrl_idx;
3209     if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3210     {
3211         wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3212         info.bitmap = bitmap;
3213         ctrl->Refresh();
3214         ctrl->Update();
3215     }
3216
3217     return true;
3218 }
3219
3220 // returns the page bitmap
3221 wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
3222 {
3223     if (page_idx >= m_tabs.GetPageCount())
3224         return wxBitmap();
3225
3226     // update our own tab catalog
3227     const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3228     return page_info.bitmap;
3229 }
3230
3231 // GetSelection() returns the index of the currently active page
3232 int wxAuiNotebook::GetSelection() const
3233 {
3234     return m_curpage;
3235 }
3236
3237 // SetSelection() sets the currently active page
3238 size_t wxAuiNotebook::SetSelection(size_t new_page)
3239 {
3240     // don't change the page unless necessary
3241     if ((int)new_page == m_curpage)
3242         return m_curpage;
3243
3244     wxWindow* wnd = m_tabs.GetWindowFromIdx(new_page);
3245     if (!wnd)
3246         return m_curpage;
3247
3248     wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
3249     evt.SetSelection(new_page);
3250     evt.SetOldSelection(m_curpage);
3251     evt.SetEventObject(this);
3252     if (!GetEventHandler()->ProcessEvent(evt) || evt.IsAllowed())
3253     {
3254         int old_curpage = m_curpage;
3255         m_curpage = new_page;
3256
3257         // program allows the page change
3258         evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
3259         (void)GetEventHandler()->ProcessEvent(evt);
3260
3261
3262         wxAuiTabCtrl* ctrl;
3263         int ctrl_idx;
3264         if (FindTab(wnd, &ctrl, &ctrl_idx))
3265         {
3266             m_tabs.SetActivePage(wnd);
3267
3268             ctrl->SetActivePage(ctrl_idx);
3269             DoSizing();
3270             ctrl->DoShowHide();
3271
3272             ctrl->MakeTabVisible(ctrl_idx, ctrl);
3273
3274             // set fonts
3275             wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3276             size_t i, pane_count = all_panes.GetCount();
3277             for (i = 0; i < pane_count; ++i)
3278             {
3279                 wxAuiPaneInfo& pane = all_panes.Item(i);
3280                 if (pane.name == wxT("dummy"))
3281                     continue;
3282                 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
3283                 if (tabctrl != ctrl)
3284                     tabctrl->SetSelectedFont(m_normal_font);
3285                 else
3286                     tabctrl->SetSelectedFont(m_selected_font);
3287                 tabctrl->Refresh();
3288             }
3289
3290             // We should set focus to the tab control if not already focused.
3291             if (ctrl->IsShownOnScreen() && FindFocus() != ctrl)
3292                 ctrl->SetFocus();
3293
3294             return old_curpage;
3295         }
3296     }
3297
3298     return m_curpage;
3299 }
3300
3301 void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
3302 {
3303     const int idx = m_tabs.GetIdxFromWindow(win);
3304     wxCHECK_RET( idx != wxNOT_FOUND, _T("invalid notebook page") );
3305
3306     SetSelection(idx);
3307 }
3308
3309 // GetPageCount() returns the total number of
3310 // pages managed by the multi-notebook
3311 size_t wxAuiNotebook::GetPageCount() const
3312 {
3313     return m_tabs.GetPageCount();
3314 }
3315
3316 // GetPage() returns the wxWindow pointer of the
3317 // specified page
3318 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
3319 {
3320     wxASSERT(page_idx < m_tabs.GetPageCount());
3321
3322     return m_tabs.GetWindowFromIdx(page_idx);
3323 }
3324
3325 // DoSizing() performs all sizing operations in each tab control
3326 void wxAuiNotebook::DoSizing()
3327 {
3328     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3329     size_t i, pane_count = all_panes.GetCount();
3330     for (i = 0; i < pane_count; ++i)
3331     {
3332         if (all_panes.Item(i).name == wxT("dummy"))
3333             continue;
3334
3335         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3336         tabframe->DoSizing();
3337     }
3338 }
3339
3340 // GetActiveTabCtrl() returns the active tab control.  It is
3341 // called to determine which control gets new windows being added
3342 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
3343 {
3344     if (m_curpage >= 0 && m_curpage < (int)m_tabs.GetPageCount())
3345     {
3346         wxAuiTabCtrl* ctrl;
3347         int idx;
3348
3349         // find the tab ctrl with the current page
3350         if (FindTab(m_tabs.GetPage(m_curpage).window,
3351                     &ctrl, &idx))
3352         {
3353             return ctrl;
3354         }
3355     }
3356
3357     // no current page, just find the first tab ctrl
3358     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3359     size_t i, pane_count = all_panes.GetCount();
3360     for (i = 0; i < pane_count; ++i)
3361     {
3362         if (all_panes.Item(i).name == wxT("dummy"))
3363             continue;
3364
3365         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3366         return tabframe->m_tabs;
3367     }
3368
3369     // If there is no tabframe at all, create one
3370     wxTabFrame* tabframe = new wxTabFrame;
3371     tabframe->SetTabCtrlHeight(m_tab_ctrl_height);
3372     tabframe->m_tabs = new wxAuiTabCtrl(this,
3373                                         m_tab_id_counter++,
3374                                         wxDefaultPosition,
3375                                         wxDefaultSize,
3376                                         wxNO_BORDER|wxWANTS_CHARS);
3377     tabframe->m_tabs->SetFlags(m_flags);
3378     tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3379     m_mgr.AddPane(tabframe,
3380                   wxAuiPaneInfo().Center().CaptionVisible(false));
3381
3382     m_mgr.Update();
3383
3384     return tabframe->m_tabs;
3385 }
3386
3387 // FindTab() finds the tab control that currently contains the window as well
3388 // as the index of the window in the tab control.  It returns true if the
3389 // window was found, otherwise false.
3390 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
3391 {
3392     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3393     size_t i, pane_count = all_panes.GetCount();
3394     for (i = 0; i < pane_count; ++i)
3395     {
3396         if (all_panes.Item(i).name == wxT("dummy"))
3397             continue;
3398
3399         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3400
3401         int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
3402         if (page_idx != -1)
3403         {
3404             *ctrl = tabframe->m_tabs;
3405             *idx = page_idx;
3406             return true;
3407         }
3408     }
3409
3410     return false;
3411 }
3412
3413 void wxAuiNotebook::Split(size_t page, int direction)
3414 {
3415     wxSize cli_size = GetClientSize();
3416
3417     // get the page's window pointer
3418     wxWindow* wnd = GetPage(page);
3419     if (!wnd)
3420         return;
3421
3422     // notebooks with 1 or less pages can't be split
3423     if (GetPageCount() < 2)
3424         return;
3425
3426     // find out which tab control the page currently belongs to
3427     wxAuiTabCtrl *src_tabs, *dest_tabs;
3428     int src_idx = -1;
3429     src_tabs = NULL;
3430     if (!FindTab(wnd, &src_tabs, &src_idx))
3431         return;
3432     if (!src_tabs || src_idx == -1)
3433         return;
3434
3435     // choose a split size
3436     wxSize split_size;
3437     if (GetPageCount() > 2)
3438     {
3439         split_size = CalculateNewSplitSize();
3440     }
3441     else
3442     {
3443         // because there are two panes, always split them
3444         // equally
3445         split_size = GetClientSize();
3446         split_size.x /= 2;
3447         split_size.y /= 2;
3448     }
3449
3450
3451     // create a new tab frame
3452     wxTabFrame* new_tabs = new wxTabFrame;
3453     new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
3454     new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3455     new_tabs->m_tabs = new wxAuiTabCtrl(this,
3456                                         m_tab_id_counter++,
3457                                         wxDefaultPosition,
3458                                         wxDefaultSize,
3459                                         wxNO_BORDER|wxWANTS_CHARS);
3460     new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3461     new_tabs->m_tabs->SetFlags(m_flags);
3462     dest_tabs = new_tabs->m_tabs;
3463
3464     // create a pane info structure with the information
3465     // about where the pane should be added
3466     wxAuiPaneInfo pane_info = wxAuiPaneInfo().Bottom().CaptionVisible(false);
3467     wxPoint mouse_pt;
3468
3469     if (direction == wxLEFT)
3470     {
3471         pane_info.Left();
3472         mouse_pt = wxPoint(0, cli_size.y/2);
3473     }
3474     else if (direction == wxRIGHT)
3475     {
3476         pane_info.Right();
3477         mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
3478     }
3479     else if (direction == wxTOP)
3480     {
3481         pane_info.Top();
3482         mouse_pt = wxPoint(cli_size.x/2, 0);
3483     }
3484     else if (direction == wxBOTTOM)
3485     {
3486         pane_info.Bottom();
3487         mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
3488     }
3489
3490     m_mgr.AddPane(new_tabs, pane_info, mouse_pt);
3491     m_mgr.Update();
3492
3493     // remove the page from the source tabs
3494     wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
3495     page_info.active = false;
3496     src_tabs->RemovePage(page_info.window);
3497     if (src_tabs->GetPageCount() > 0)
3498     {
3499         src_tabs->SetActivePage((size_t)0);
3500         src_tabs->DoShowHide();
3501         src_tabs->Refresh();
3502     }
3503
3504
3505     // add the page to the destination tabs
3506     dest_tabs->InsertPage(page_info.window, page_info, 0);
3507
3508     if (src_tabs->GetPageCount() == 0)
3509     {
3510         RemoveEmptyTabFrames();
3511     }
3512
3513     DoSizing();
3514     dest_tabs->DoShowHide();
3515     dest_tabs->Refresh();
3516
3517     // force the set selection function reset the selection
3518     m_curpage = -1;
3519
3520     // set the active page to the one we just split off
3521     SetSelectionToPage(page_info);
3522
3523     UpdateHintWindowSize();
3524 }
3525
3526
3527 void wxAuiNotebook::OnSize(wxSizeEvent& evt)
3528 {
3529     UpdateHintWindowSize();
3530
3531     evt.Skip();
3532 }
3533
3534 void wxAuiNotebook::OnTabClicked(wxCommandEvent& command_evt)
3535 {
3536     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3537
3538     wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
3539     wxASSERT(ctrl != NULL);
3540
3541     wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
3542     wxASSERT(wnd != NULL);
3543
3544     SetSelectionToWindow(wnd);
3545 }
3546
3547 void wxAuiNotebook::OnTabBeginDrag(wxCommandEvent&)
3548 {
3549     m_last_drag_x = 0;
3550 }
3551
3552 void wxAuiNotebook::OnTabDragMotion(wxCommandEvent& evt)
3553 {
3554     wxPoint screen_pt = ::wxGetMousePosition();
3555     wxPoint client_pt = ScreenToClient(screen_pt);
3556     wxPoint zero(0,0);
3557
3558     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3559     wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
3560
3561     if (dest_tabs == src_tabs)
3562     {
3563         if (src_tabs)
3564         {
3565             src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3566         }
3567
3568         // always hide the hint for inner-tabctrl drag
3569         m_mgr.HideHint();
3570
3571         // if tab moving is not allowed, leave
3572         if (!(m_flags & wxAUI_NB_TAB_MOVE))
3573         {
3574             return;
3575         }
3576
3577         wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
3578         wxWindow* dest_location_tab;
3579
3580         // this is an inner-tab drag/reposition
3581         if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
3582         {
3583             int src_idx = evt.GetSelection();
3584             int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
3585
3586             // prevent jumpy drag
3587             if ((src_idx == dest_idx) || dest_idx == -1 ||
3588                 (src_idx > dest_idx && m_last_drag_x <= pt.x) ||
3589                 (src_idx < dest_idx && m_last_drag_x >= pt.x))
3590             {
3591                 m_last_drag_x = pt.x;
3592                 return;
3593             }
3594
3595
3596             wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
3597             dest_tabs->MovePage(src_tab, dest_idx);
3598             dest_tabs->SetActivePage((size_t)dest_idx);
3599             dest_tabs->DoShowHide();
3600             dest_tabs->Refresh();
3601             m_last_drag_x = pt.x;
3602
3603         }
3604
3605         return;
3606     }
3607
3608
3609     // if external drag is allowed, check if the tab is being dragged
3610     // over a different wxAuiNotebook control
3611     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3612     {
3613         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
3614
3615         // if we aren't over any window, stop here
3616         if (!tab_ctrl)
3617             return;
3618
3619         // make sure we are not over the hint window
3620         if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
3621         {
3622             while (tab_ctrl)
3623             {
3624                 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3625                     break;
3626                 tab_ctrl = tab_ctrl->GetParent();
3627             }
3628
3629             if (tab_ctrl)
3630             {
3631                 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3632
3633                 if (nb != this)
3634                 {
3635                     wxRect hint_rect = tab_ctrl->GetClientRect();
3636                     tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
3637                     m_mgr.ShowHint(hint_rect);
3638                     return;
3639                 }
3640             }
3641         }
3642         else
3643         {
3644             if (!dest_tabs)
3645             {
3646                 // we are either over a hint window, or not over a tab
3647                 // window, and there is no where to drag to, so exit
3648                 return;
3649             }
3650         }
3651     }
3652
3653
3654     // if there are less than two panes, split can't happen, so leave
3655     if (m_tabs.GetPageCount() < 2)
3656         return;
3657
3658     // if tab moving is not allowed, leave
3659     if (!(m_flags & wxAUI_NB_TAB_SPLIT))
3660         return;
3661
3662
3663     if (src_tabs)
3664     {
3665         src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
3666     }
3667
3668
3669     if (dest_tabs)
3670     {
3671         wxRect hint_rect = dest_tabs->GetRect();
3672         ClientToScreen(&hint_rect.x, &hint_rect.y);
3673         m_mgr.ShowHint(hint_rect);
3674     }
3675     else
3676     {
3677         m_mgr.DrawHintRect(m_dummy_wnd, client_pt, zero);
3678     }
3679 }
3680
3681
3682
3683 void wxAuiNotebook::OnTabEndDrag(wxCommandEvent& command_evt)
3684 {
3685     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
3686
3687     m_mgr.HideHint();
3688
3689
3690     wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3691     wxCHECK_RET( src_tabs, _T("no source object?") );
3692
3693     src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3694
3695     // get the mouse position, which will be used to determine the drop point
3696     wxPoint mouse_screen_pt = ::wxGetMousePosition();
3697     wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
3698
3699
3700
3701     // check for an external move
3702     if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3703     {
3704         wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
3705
3706         while (tab_ctrl)
3707         {
3708             if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3709                 break;
3710             tab_ctrl = tab_ctrl->GetParent();
3711         }
3712
3713         if (tab_ctrl)
3714         {
3715             wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3716
3717             if (nb != this)
3718             {
3719                 // find out from the destination control
3720                 // if it's ok to drop this tab here
3721                 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
3722                 e.SetSelection(evt.GetSelection());
3723                 e.SetOldSelection(evt.GetSelection());
3724                 e.SetEventObject(this);
3725                 e.SetDragSource(this);
3726                 e.Veto(); // dropping must be explicitly approved by control owner
3727
3728                 nb->GetEventHandler()->ProcessEvent(e);
3729
3730                 if (!e.IsAllowed())
3731                 {
3732                     // no answer or negative answer
3733                     m_mgr.HideHint();
3734                     return;
3735                 }
3736
3737                 // drop was allowed
3738                 int src_idx = evt.GetSelection();
3739                 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
3740
3741                 // Check that it's not an impossible parent relationship
3742                 wxWindow* p = nb;
3743                 while (p && !p->IsTopLevel())
3744                 {
3745                     if (p == src_page)
3746                     {
3747                         return;
3748                     }
3749                     p = p->GetParent();
3750                 }
3751
3752                 // get main index of the page
3753                 int main_idx = m_tabs.GetIdxFromWindow(src_page);
3754                 wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no source page?") );
3755
3756
3757                 // make a copy of the page info
3758                 wxAuiNotebookPage page_info = m_tabs.GetPage(main_idx);
3759
3760                 // remove the page from the source notebook
3761                 RemovePage(main_idx);
3762
3763                 // reparent the page
3764                 src_page->Reparent(nb);
3765
3766
3767                 // found out the insert idx
3768                 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
3769                 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3770
3771                 wxWindow* target = NULL;
3772                 int insert_idx = -1;
3773                 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3774                 if (target)
3775                 {
3776                     insert_idx = dest_tabs->GetIdxFromWindow(target);
3777                 }
3778
3779
3780                 // add the page to the new notebook
3781                 if (insert_idx == -1)
3782                     insert_idx = dest_tabs->GetPageCount();
3783                 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3784                 nb->m_tabs.AddPage(page_info.window, page_info);
3785
3786                 nb->DoSizing();
3787                 dest_tabs->DoShowHide();
3788                 dest_tabs->Refresh();
3789
3790                 // set the selection in the destination tab control
3791                 nb->SetSelectionToPage(page_info);
3792
3793                 return;
3794             }
3795         }
3796     }
3797
3798
3799
3800
3801     // only perform a tab split if it's allowed
3802     wxAuiTabCtrl* dest_tabs = NULL;
3803
3804     if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
3805     {
3806         // If the pointer is in an existing tab frame, do a tab insert
3807         wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
3808         wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
3809         int insert_idx = -1;
3810         if (tab_frame)
3811         {
3812             dest_tabs = tab_frame->m_tabs;
3813
3814             if (dest_tabs == src_tabs)
3815                 return;
3816
3817
3818             wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3819             wxWindow* target = NULL;
3820             dest_tabs->TabHitTest(pt.x, pt.y, &target);
3821             if (target)
3822             {
3823                 insert_idx = dest_tabs->GetIdxFromWindow(target);
3824             }
3825         }
3826         else
3827         {
3828             wxPoint zero(0,0);
3829             wxRect rect = m_mgr.CalculateHintRect(m_dummy_wnd,
3830                                                   mouse_client_pt,
3831                                                   zero);
3832             if (rect.IsEmpty())
3833             {
3834                 // there is no suitable drop location here, exit out
3835                 return;
3836             }
3837
3838             // If there is no tabframe at all, create one
3839             wxTabFrame* new_tabs = new wxTabFrame;
3840             new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
3841             new_tabs->SetTabCtrlHeight(m_tab_ctrl_height);
3842             new_tabs->m_tabs = new wxAuiTabCtrl(this,
3843                                                 m_tab_id_counter++,
3844                                                 wxDefaultPosition,
3845                                                 wxDefaultSize,
3846                                                 wxNO_BORDER|wxWANTS_CHARS);
3847             new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3848             new_tabs->m_tabs->SetFlags(m_flags);
3849
3850             m_mgr.AddPane(new_tabs,
3851                           wxAuiPaneInfo().Bottom().CaptionVisible(false),
3852                           mouse_client_pt);
3853             m_mgr.Update();
3854             dest_tabs = new_tabs->m_tabs;
3855         }
3856
3857
3858
3859         // remove the page from the source tabs
3860         wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
3861         page_info.active = false;
3862         src_tabs->RemovePage(page_info.window);
3863         if (src_tabs->GetPageCount() > 0)
3864         {
3865             src_tabs->SetActivePage((size_t)0);
3866             src_tabs->DoShowHide();
3867             src_tabs->Refresh();
3868         }
3869
3870
3871
3872         // add the page to the destination tabs
3873         if (insert_idx == -1)
3874             insert_idx = dest_tabs->GetPageCount();
3875         dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3876
3877         if (src_tabs->GetPageCount() == 0)
3878         {
3879             RemoveEmptyTabFrames();
3880         }
3881
3882         DoSizing();
3883         dest_tabs->DoShowHide();
3884         dest_tabs->Refresh();
3885
3886         // force the set selection function reset the selection
3887         m_curpage = -1;
3888
3889         // set the active page to the one we just split off
3890         SetSelectionToPage(page_info);
3891
3892         UpdateHintWindowSize();
3893     }
3894 }
3895
3896
3897
3898 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
3899 {
3900     // if we've just removed the last tab from the source
3901     // tab set, the remove the tab control completely
3902     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3903     size_t i, pane_count = all_panes.GetCount();
3904     for (i = 0; i < pane_count; ++i)
3905     {
3906         if (all_panes.Item(i).name == wxT("dummy"))
3907             continue;
3908
3909         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3910         if (tabframe->m_tab_rect.Contains(pt))
3911             return tabframe->m_tabs;
3912     }
3913
3914     return NULL;
3915 }
3916
3917 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
3918 {
3919     // if we've just removed the last tab from the source
3920     // tab set, the remove the tab control completely
3921     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3922     size_t i, pane_count = all_panes.GetCount();
3923     for (i = 0; i < pane_count; ++i)
3924     {
3925         if (all_panes.Item(i).name == wxT("dummy"))
3926             continue;
3927
3928         wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3929         if (tabframe->m_tabs == tab_ctrl)
3930         {
3931             return tabframe;
3932         }
3933     }
3934
3935     return NULL;
3936 }
3937
3938 void wxAuiNotebook::RemoveEmptyTabFrames()
3939 {
3940     // if we've just removed the last tab from the source
3941     // tab set, the remove the tab control completely
3942     wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
3943     size_t i, pane_count = all_panes.GetCount();
3944     for (i = 0; i < pane_count; ++i)
3945     {
3946         if (all_panes.Item(i).name == wxT("dummy"))
3947             continue;
3948
3949         wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
3950         if (tab_frame->m_tabs->GetPageCount() == 0)
3951         {
3952             m_mgr.DetachPane(tab_frame);
3953
3954             // use pending delete because sometimes during
3955             // window closing, refreshs are pending
3956             if (!wxPendingDelete.Member(tab_frame->m_tabs))
3957                 wxPendingDelete.Append(tab_frame->m_tabs);
3958
3959             tab_frame->m_tabs = NULL;
3960
3961             delete tab_frame;
3962         }
3963     }
3964
3965
3966     // check to see if there is still a center pane;
3967     // if there isn't, make a frame the center pane
3968     wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
3969     pane_count = panes.GetCount();
3970     wxWindow* first_good = NULL;
3971     bool center_found = false;
3972     for (i = 0; i < pane_count; ++i)
3973     {
3974         if (panes.Item(i).name == wxT("dummy"))
3975             continue;
3976         if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
3977             center_found = true;
3978         if (!first_good)
3979             first_good = panes.Item(i).window;
3980     }
3981
3982     if (!center_found && first_good)
3983     {
3984         m_mgr.GetPane(first_good).Centre();
3985     }
3986
3987     m_mgr.Update();
3988 }
3989
3990 void wxAuiNotebook::OnChildFocus(wxChildFocusEvent& evt)
3991 {
3992     // if we're dragging a tab, don't change the current selection.
3993     // This code prevents a bug that used to happen when the hint window
3994     // was hidden.  In the bug, the focus would return to the notebook
3995     // child, which would then enter this handler and call
3996     // SetSelection, which is not desired turn tab dragging.
3997
3998     wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3999     size_t i, pane_count = all_panes.GetCount();
4000     for (i = 0; i < pane_count; ++i)
4001     {
4002         wxAuiPaneInfo& pane = all_panes.Item(i);
4003         if (pane.name == wxT("dummy"))
4004             continue;
4005         wxTabFrame* tabframe = (wxTabFrame*)pane.window;
4006         if (tabframe->m_tabs->IsDragging())
4007             return;
4008     }
4009
4010
4011     // change the tab selection to the child
4012     // which was focused
4013     int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
4014     if (idx != -1 && idx != m_curpage)
4015     {
4016         SetSelection(idx);
4017     }
4018 }
4019
4020 void wxAuiNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
4021 {
4022     if ( event.IsWindowChange() ) {
4023         // change pages
4024         // FIXME: the problem with this is that if we have a split notebook,
4025         // we selection may go all over the place.
4026         AdvanceSelection(event.GetDirection());
4027     }
4028     else {
4029         // we get this event in 3 cases
4030         //
4031         // a) one of our pages might have generated it because the user TABbed
4032         // out from it in which case we should propagate the event upwards and
4033         // our parent will take care of setting the focus to prev/next sibling
4034         //
4035         // or
4036         //
4037         // b) the parent panel wants to give the focus to us so that we
4038         // forward it to our selected page. We can't deal with this in
4039         // OnSetFocus() because we don't know which direction the focus came
4040         // from in this case and so can't choose between setting the focus to
4041         // first or last panel child
4042         //
4043         // or
4044         //
4045         // c) we ourselves (see MSWTranslateMessage) generated the event
4046         //
4047         wxWindow * const parent = GetParent();
4048
4049         // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
4050         const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
4051         const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
4052
4053         if ( isFromParent || isFromSelf )
4054         {
4055             // no, it doesn't come from child, case (b) or (c): forward to a
4056             // page but only if direction is backwards (TAB) or from ourselves,
4057             if ( GetSelection() != wxNOT_FOUND &&
4058                     (!event.GetDirection() || isFromSelf) )
4059             {
4060                 // so that the page knows that the event comes from it's parent
4061                 // and is being propagated downwards
4062                 event.SetEventObject(this);
4063
4064                 wxWindow *page = GetPage(GetSelection());
4065                 if ( !page->GetEventHandler()->ProcessEvent(event) )
4066                 {
4067                     page->SetFocus();
4068                 }
4069                 //else: page manages focus inside it itself
4070             }
4071             else // otherwise set the focus to the notebook itself
4072             {
4073                 SetFocus();
4074             }
4075         }
4076         else
4077         {
4078             // it comes from our child, case (a), pass to the parent, but only
4079             // if the direction is forwards. Otherwise set the focus to the
4080             // notebook itself. The notebook is always the 'first' control of a
4081             // page.
4082             if ( !event.GetDirection() )
4083             {
4084                 SetFocus();
4085             }
4086             else if ( parent )
4087             {
4088                 event.SetCurrentFocus(this);
4089                 parent->GetEventHandler()->ProcessEvent(event);
4090             }
4091         }
4092     }
4093 }
4094
4095 void wxAuiNotebook::OnTabButton(wxCommandEvent& command_evt)
4096 {
4097     wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
4098     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4099
4100     int button_id = evt.GetInt();
4101
4102     if (button_id == wxAUI_BUTTON_CLOSE)
4103     {
4104         int selection = evt.GetSelection();
4105
4106         if (selection == -1)
4107         {
4108             // if the close button is to the right, use the active
4109             // page selection to determine which page to close
4110             selection = GetSelection();
4111         }
4112
4113         if (selection != -1)
4114         {
4115             wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
4116
4117             // ask owner if it's ok to close the tab
4118             wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
4119             e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
4120             e.SetOldSelection(evt.GetSelection());
4121             e.SetEventObject(this);
4122             GetEventHandler()->ProcessEvent(e);
4123             if (!e.IsAllowed())
4124                 return;
4125
4126
4127             if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
4128             {
4129                 close_wnd->Close();
4130             }
4131             else
4132             {
4133                 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
4134                 wxCHECK_RET( main_idx != wxNOT_FOUND, _T("no page to delete?") );
4135
4136                 DeletePage(main_idx);
4137             }
4138         }
4139     }
4140 }
4141
4142
4143 void wxAuiNotebook::OnTabMiddleDown(wxCommandEvent& evt)
4144 {
4145     // patch event through to owner
4146     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4147     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4148
4149     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
4150     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4151     e.SetEventObject(this);
4152     GetEventHandler()->ProcessEvent(e);
4153 }
4154
4155 void wxAuiNotebook::OnTabMiddleUp(wxCommandEvent& evt)
4156 {
4157     // if the wxAUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
4158     // click should act like a tab close action.  However, first
4159     // give the owner an opportunity to handle the middle up event
4160     // for custom action
4161
4162     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4163     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4164
4165     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
4166     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4167     e.SetEventObject(this);
4168     if (GetEventHandler()->ProcessEvent(e))
4169         return;
4170     if (!e.IsAllowed())
4171         return;
4172
4173     // check if we are supposed to close on middle-up
4174     if ((m_flags & wxAUI_NB_MIDDLE_CLICK_CLOSE) == 0)
4175         return;
4176
4177     // simulate the user pressing the close button on the tab
4178     evt.SetInt(wxAUI_BUTTON_CLOSE);
4179     OnTabButton(evt);
4180 }
4181
4182 void wxAuiNotebook::OnTabRightDown(wxCommandEvent& evt)
4183 {
4184     // patch event through to owner
4185     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4186     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4187
4188     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
4189     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4190     e.SetEventObject(this);
4191     GetEventHandler()->ProcessEvent(e);
4192 }
4193
4194 void wxAuiNotebook::OnTabRightUp(wxCommandEvent& evt)
4195 {
4196     // patch event through to owner
4197     wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4198     wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4199
4200     wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
4201     e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4202     e.SetEventObject(this);
4203     GetEventHandler()->ProcessEvent(e);
4204 }
4205
4206 // Sets the normal font
4207 void wxAuiNotebook::SetNormalFont(const wxFont& font)
4208 {
4209     m_normal_font = font;
4210     GetArtProvider()->SetNormalFont(font);
4211 }
4212
4213 // Sets the selected tab font
4214 void wxAuiNotebook::SetSelectedFont(const wxFont& font)
4215 {
4216     m_selected_font = font;
4217     GetArtProvider()->SetSelectedFont(font);
4218 }
4219
4220 // Sets the measuring font
4221 void wxAuiNotebook::SetMeasuringFont(const wxFont& font)
4222 {
4223     GetArtProvider()->SetMeasuringFont(font);
4224 }
4225
4226 // Sets the tab font
4227 bool wxAuiNotebook::SetFont(const wxFont& font)
4228 {
4229     wxControl::SetFont(font);
4230
4231     wxFont normalFont(font);
4232     wxFont selectedFont(normalFont);
4233     selectedFont.SetWeight(wxBOLD);
4234
4235     SetNormalFont(normalFont);
4236     SetSelectedFont(selectedFont);
4237     SetMeasuringFont(selectedFont);
4238
4239     return true;
4240 }
4241
4242 // Gets the tab control height
4243 int wxAuiNotebook::GetTabCtrlHeight() const
4244 {
4245     return m_tab_ctrl_height;
4246 }
4247
4248 // Gets the height of the notebook for a given page height
4249 int wxAuiNotebook::GetHeightForPageHeight(int pageHeight)
4250 {
4251     UpdateTabCtrlHeight();
4252
4253     int tabCtrlHeight = GetTabCtrlHeight();
4254     int decorHeight = 2;
4255     return tabCtrlHeight + pageHeight + decorHeight;
4256 }
4257
4258 // Advances the selection, generation page selection events
4259 void wxAuiNotebook::AdvanceSelection(bool forward)
4260 {
4261     if (GetPageCount() <= 1)
4262         return;
4263
4264     int currentSelection = GetSelection();
4265
4266     if (forward)
4267     {
4268         if (currentSelection == (int) (GetPageCount() - 1))
4269             return;
4270         else if (currentSelection == -1)
4271             currentSelection = 0;
4272         else
4273             currentSelection ++;
4274     }
4275     else
4276     {
4277         if (currentSelection <= 0)
4278             return;
4279         else
4280             currentSelection --;
4281     }
4282
4283     SetSelection(currentSelection);
4284 }
4285
4286 // Shows the window menu
4287 bool wxAuiNotebook::ShowWindowMenu()
4288 {
4289     wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
4290
4291     int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
4292
4293     if (idx != -1)
4294     {
4295         wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
4296         e.SetSelection(idx);
4297         e.SetOldSelection(tabCtrl->GetActivePage());
4298         e.SetEventObject(tabCtrl);
4299         GetEventHandler()->ProcessEvent(e);
4300
4301         return true;
4302     }
4303     else
4304         return false;
4305 }
4306
4307 #endif // wxUSE_AUI