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