src/aui/auibook.cpp

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