src/aui/framemanager.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/aui/framemanager.cpp
   3 // Purpose:     wxaui: wx advanced user interface - docking window manager
   4 // Author:      Benjamin I. Williams
   5 // Modified by:
   6 // Created:     2005-05-17
   7 // RCS-ID:      $Id$
   8 // Copyright:   (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
   9 // Licence:     wxWindows Library Licence, Version 3.1
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_AUI
  27
  28 #include "wx/aui/framemanager.h"
  29 #include "wx/aui/dockart.h"
  30 #include "wx/aui/floatpane.h"
  31 #include "wx/aui/tabmdi.h"
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/panel.h"
  35     #include "wx/settings.h"
  36     #include "wx/app.h"
  37     #include "wx/dcclient.h"
  38     #include "wx/dcscreen.h"
  39     #include "wx/toolbar.h"
  40     #include "wx/mdi.h"
  41     #include "wx/image.h"
  42 #endif
  43
  44 WX_CHECK_BUILD_OPTIONS("wxAUI")
  45
  46 #include "wx/arrimpl.cpp"
  47 WX_DECLARE_OBJARRAY(wxRect, wxAuiRectArray);
  48 WX_DEFINE_OBJARRAY(wxAuiRectArray)
  49 WX_DEFINE_OBJARRAY(wxAuiDockUIPartArray)
  50 WX_DEFINE_OBJARRAY(wxAuiDockInfoArray)
  51 WX_DEFINE_OBJARRAY(wxAuiPaneButtonArray)
  52 WX_DEFINE_OBJARRAY(wxAuiPaneInfoArray)
  53
  54 wxAuiPaneInfo wxAuiNullPaneInfo;
  55 wxAuiDockInfo wxAuiNullDockInfo;
  56 DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_BUTTON)
  57 DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_CLOSE)
  58 DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_MAXIMIZE)
  59 DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_RESTORE)
  60 DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)
  61 DEFINE_EVENT_TYPE(wxEVT_AUI_FIND_MANAGER)
  62
  63 #ifdef __WXMAC__
  64     // a few defines to avoid nameclashes
  65     #define __MAC_OS_X_MEMORY_MANAGER_CLEAN__ 1
  66     #define __AIFF__
  67     #include "wx/mac/private.h"
  68 #endif
  69
  70 IMPLEMENT_DYNAMIC_CLASS(wxAuiManagerEvent, wxEvent)
  71 IMPLEMENT_CLASS(wxAuiManager, wxEvtHandler)
  72
  73
  74
  75 const int auiToolBarLayer = 10;
  76
  77
  78 class wxPseudoTransparentFrame : public wxFrame
  79 {
  80 public:
  81     wxPseudoTransparentFrame(wxWindow* parent = NULL,
  82                 wxWindowID id = wxID_ANY,
  83                 const wxString& title = wxEmptyString,
  84                 const wxPoint& pos = wxDefaultPosition,
  85                 const wxSize& size = wxDefaultSize,
  86                 long style = wxDEFAULT_FRAME_STYLE,
  87                 const wxString &name = wxT("frame"))
  88                     : wxFrame(parent, id, title, pos, size, style | wxFRAME_SHAPED, name)
  89     {
  90         SetBackgroundStyle(wxBG_STYLE_CUSTOM);
  91         m_Amount=0;
  92         m_MaxWidth=0;
  93         m_MaxHeight=0;
  94         m_lastWidth=0;
  95         m_lastHeight=0;
  96 #ifdef __WXGTK__
  97         m_CanSetShape = false; // have to wait for window create event on GTK
  98 #else
  99         m_CanSetShape = true;
 100 #endif
 101         m_Region = wxRegion(0, 0, 0, 0);
 102         SetTransparent(0);
 103     }
 104
 105     virtual bool SetTransparent(wxByte alpha)
 106     {
 107         if (m_CanSetShape)
 108         {
 109             int w=100; // some defaults
 110             int h=100;
 111             GetClientSize(&w, &h);
 112
 113             m_MaxWidth = w;
 114             m_MaxHeight = h;
 115             m_Amount = alpha;
 116             m_Region.Clear();
 117 //            m_Region.Union(0, 0, 1, m_MaxWidth);
 118             if (m_Amount)
 119             {
 120                 for (int y=0; y<m_MaxHeight; y++)
 121                 {
 122                     // Reverse the order of the bottom 4 bits
 123                     int j=((y&8)?1:0)|((y&4)?2:0)|((y&2)?4:0)|((y&1)?8:0);
 124                     if ((j*16+8)<m_Amount)
 125                         m_Region.Union(0, y, m_MaxWidth, 1);
 126                 }
 127             }
 128             SetShape(m_Region);
 129             Refresh();
 130         }
 131         return true;
 132     }
 133
 134     void OnPaint(wxPaintEvent& WXUNUSED(event))
 135     {
 136         wxPaintDC dc(this);
 137
 138         if (m_Region.IsEmpty())
 139             return;
 140
 141 #ifdef __WXMAC__
 142         dc.SetBrush(wxColour(128, 192, 255));
 143 #else
 144         dc.SetBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
 145 #endif
 146         dc.SetPen(*wxTRANSPARENT_PEN);
 147
 148         wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
 149
 150         while (upd)
 151         {
 152             wxRect rect(upd.GetRect());
 153             dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
 154
 155             ++upd;
 156         }
 157     }
 158
 159 #ifdef __WXGTK__
 160     void OnWindowCreate(wxWindowCreateEvent& WXUNUSED(event))
 161     {
 162         m_CanSetShape=true;
 163         SetTransparent(0);
 164     }
 165 #endif
 166
 167     void OnSize(wxSizeEvent& event)
 168     {
 169         // We sometimes get surplus size events
 170         if ((event.GetSize().GetWidth() == m_lastWidth) &&
 171             (event.GetSize().GetHeight() == m_lastHeight))
 172         {
 173             event.Skip();
 174             return;
 175         }
 176         m_lastWidth = event.GetSize().GetWidth();
 177         m_lastHeight = event.GetSize().GetHeight();
 178
 179         SetTransparent(m_Amount);
 180         m_Region.Intersect(0, 0, event.GetSize().GetWidth(),
 181                            event.GetSize().GetHeight());
 182         SetShape(m_Region);
 183         Refresh();
 184         event.Skip();
 185     }
 186
 187 private:
 188     wxByte m_Amount;
 189     int m_MaxWidth;
 190     int m_MaxHeight;
 191     bool m_CanSetShape;
 192     int m_lastWidth,m_lastHeight;
 193
 194     wxRegion m_Region;
 195
 196     DECLARE_DYNAMIC_CLASS(wxPseudoTransparentFrame)
 197     DECLARE_EVENT_TABLE()
 198 };
 199
 200
 201 IMPLEMENT_DYNAMIC_CLASS(wxPseudoTransparentFrame, wxFrame)
 202
 203 BEGIN_EVENT_TABLE(wxPseudoTransparentFrame, wxFrame)
 204     EVT_PAINT(wxPseudoTransparentFrame::OnPaint)
 205     EVT_SIZE(wxPseudoTransparentFrame::OnSize)
 206 #ifdef __WXGTK__
 207     EVT_WINDOW_CREATE(wxPseudoTransparentFrame::OnWindowCreate)
 208 #endif
 209 END_EVENT_TABLE()
 210
 211
 212 // -- static utility functions --
 213
 214 static wxBitmap wxPaneCreateStippleBitmap()
 215 {
 216     unsigned char data[] = { 0,0,0,192,192,192, 192,192,192,0,0,0 };
 217     wxImage img(2,2,data,true);
 218     return wxBitmap(img);
 219 }
 220
 221 static void DrawResizeHint(wxDC& dc, const wxRect& rect)
 222 {
 223     wxBitmap stipple = wxPaneCreateStippleBitmap();
 224     wxBrush brush(stipple);
 225     dc.SetBrush(brush);
 226     dc.SetPen(*wxTRANSPARENT_PEN);
 227
 228     dc.SetLogicalFunction(wxXOR);
 229     dc.DrawRectangle(rect);
 230 }
 231
 232
 233
 234 // CopyDocksAndPanes() - this utility function creates copies of
 235 // the dock and pane info.  wxAuiDockInfo's usually contain pointers
 236 // to wxAuiPaneInfo classes, thus this function is necessary to reliably
 237 // reconstruct that relationship in the new dock info and pane info arrays
 238
 239 static void CopyDocksAndPanes(wxAuiDockInfoArray& dest_docks,
 240                               wxAuiPaneInfoArray& dest_panes,
 241                               const wxAuiDockInfoArray& src_docks,
 242                               const wxAuiPaneInfoArray& src_panes)
 243 {
 244     dest_docks = src_docks;
 245     dest_panes = src_panes;
 246     int i, j, k, dock_count, pc1, pc2;
 247     for (i = 0, dock_count = dest_docks.GetCount(); i < dock_count; ++i)
 248     {
 249         wxAuiDockInfo& dock = dest_docks.Item(i);
 250         for (j = 0, pc1 = dock.panes.GetCount(); j < pc1; ++j)
 251             for (k = 0, pc2 = src_panes.GetCount(); k < pc2; ++k)
 252                 if (dock.panes.Item(j) == &src_panes.Item(k))
 253                     dock.panes.Item(j) = &dest_panes.Item(k);
 254     }
 255 }
 256
 257 // GetMaxLayer() is an internal function which returns
 258 // the highest layer inside the specified dock
 259 static int GetMaxLayer(const wxAuiDockInfoArray& docks,
 260                        int dock_direction)
 261 {
 262     int i, dock_count, max_layer = 0;
 263     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
 264     {
 265         wxAuiDockInfo& dock = docks.Item(i);
 266         if (dock.dock_direction == dock_direction &&
 267             dock.dock_layer > max_layer && !dock.fixed)
 268                 max_layer = dock.dock_layer;
 269     }
 270     return max_layer;
 271 }
 272
 273
 274 // GetMaxRow() is an internal function which returns
 275 // the highest layer inside the specified dock
 276 static int GetMaxRow(const wxAuiPaneInfoArray& panes, int direction, int layer)
 277 {
 278     int i, pane_count, max_row = 0;
 279     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
 280     {
 281         wxAuiPaneInfo& pane = panes.Item(i);
 282         if (pane.dock_direction == direction &&
 283             pane.dock_layer == layer &&
 284             pane.dock_row > max_row)
 285                 max_row = pane.dock_row;
 286     }
 287     return max_row;
 288 }
 289
 290
 291
 292 // DoInsertDockLayer() is an internal function that inserts a new dock
 293 // layer by incrementing all existing dock layer values by one
 294 static void DoInsertDockLayer(wxAuiPaneInfoArray& panes,
 295                               int dock_direction,
 296                               int dock_layer)
 297 {
 298     int i, pane_count;
 299     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
 300     {
 301         wxAuiPaneInfo& pane = panes.Item(i);
 302         if (!pane.IsFloating() &&
 303             pane.dock_direction == dock_direction &&
 304             pane.dock_layer >= dock_layer)
 305                 pane.dock_layer++;
 306     }
 307 }
 308
 309 // DoInsertDockLayer() is an internal function that inserts a new dock
 310 // row by incrementing all existing dock row values by one
 311 static void DoInsertDockRow(wxAuiPaneInfoArray& panes,
 312                             int dock_direction,
 313                             int dock_layer,
 314                             int dock_row)
 315 {
 316     int i, pane_count;
 317     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
 318     {
 319         wxAuiPaneInfo& pane = panes.Item(i);
 320         if (!pane.IsFloating() &&
 321             pane.dock_direction == dock_direction &&
 322             pane.dock_layer == dock_layer &&
 323             pane.dock_row >= dock_row)
 324                 pane.dock_row++;
 325     }
 326 }
 327
 328 // DoInsertDockLayer() is an internal function that inserts a space for
 329 // another dock pane by incrementing all existing dock row values by one
 330 static void DoInsertPane(wxAuiPaneInfoArray& panes,
 331                          int dock_direction,
 332                          int dock_layer,
 333                          int dock_row,
 334                          int dock_pos)
 335 {
 336     int i, pane_count;
 337     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
 338     {
 339         wxAuiPaneInfo& pane = panes.Item(i);
 340         if (!pane.IsFloating() &&
 341             pane.dock_direction == dock_direction &&
 342             pane.dock_layer == dock_layer &&
 343             pane.dock_row == dock_row &&
 344             pane.dock_pos >= dock_pos)
 345                 pane.dock_pos++;
 346     }
 347 }
 348
 349 // FindDocks() is an internal function that returns a list of docks which meet
 350 // the specified conditions in the parameters and returns a sorted array
 351 // (sorted by layer and then row)
 352 static void FindDocks(wxAuiDockInfoArray& docks,
 353                       int dock_direction,
 354                       int dock_layer,
 355                       int dock_row,
 356                       wxAuiDockInfoPtrArray& arr)
 357 {
 358     int begin_layer = dock_layer;
 359     int end_layer = dock_layer;
 360     int begin_row = dock_row;
 361     int end_row = dock_row;
 362     int dock_count = docks.GetCount();
 363     int layer, row, i, max_row = 0, max_layer = 0;
 364
 365     // discover the maximum dock layer and the max row
 366     for (i = 0; i < dock_count; ++i)
 367     {
 368         max_row = wxMax(max_row, docks.Item(i).dock_row);
 369         max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
 370     }
 371
 372     // if no dock layer was specified, search all dock layers
 373     if (dock_layer == -1)
 374     {
 375         begin_layer = 0;
 376         end_layer = max_layer;
 377     }
 378
 379     // if no dock row was specified, search all dock row
 380     if (dock_row == -1)
 381     {
 382         begin_row = 0;
 383         end_row = max_row;
 384     }
 385
 386     arr.Clear();
 387
 388     for (layer = begin_layer; layer <= end_layer; ++layer)
 389         for (row = begin_row; row <= end_row; ++row)
 390             for (i = 0; i < dock_count; ++i)
 391             {
 392                 wxAuiDockInfo& d = docks.Item(i);
 393                 if (dock_direction == -1 || dock_direction == d.dock_direction)
 394                 {
 395                     if (d.dock_layer == layer && d.dock_row == row)
 396                         arr.Add(&d);
 397                 }
 398             }
 399 }
 400
 401 // FindPaneInDock() looks up a specified window pointer inside a dock.
 402 // If found, the corresponding wxAuiPaneInfo pointer is returned, otherwise NULL.
 403 static wxAuiPaneInfo* FindPaneInDock(const wxAuiDockInfo& dock, wxWindow* window)
 404 {
 405     int i, count = dock.panes.GetCount();
 406     for (i = 0; i < count; ++i)
 407     {
 408         wxAuiPaneInfo* p = dock.panes.Item(i);
 409         if (p->window == window)
 410             return p;
 411     }
 412     return NULL;
 413 }
 414
 415 // RemovePaneFromDocks() removes a pane window from all docks
 416 // with a possible exception specified by parameter "ex_cept"
 417 static void RemovePaneFromDocks(wxAuiDockInfoArray& docks,
 418                                 wxAuiPaneInfo& pane,
 419                                 wxAuiDockInfo* ex_cept  = NULL  )
 420 {
 421     int i, dock_count;
 422     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
 423     {
 424         wxAuiDockInfo& d = docks.Item(i);
 425         if (&d == ex_cept)
 426             continue;
 427         wxAuiPaneInfo* pi = FindPaneInDock(d, pane.window);
 428         if (pi)
 429             d.panes.Remove(pi);
 430     }
 431 }
 432
 433 // RenumberDockRows() takes a dock and assigns sequential numbers
 434 // to existing rows.  Basically it takes out the gaps; so if a
 435 // dock has rows with numbers 0,2,5, they will become 0,1,2
 436 static void RenumberDockRows(wxAuiDockInfoPtrArray& docks)
 437 {
 438     int i, dock_count;
 439     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
 440     {
 441         wxAuiDockInfo& dock = *docks.Item(i);
 442         dock.dock_row = i;
 443
 444         // (BIW) I believe these lines are wrong because they are modifying
 445         // the original pane structures, which should be avoided as much
 446         // as possible.
 447
 448         //for (j = 0, pane_count = dock.panes.GetCount(); j < pane_count; ++j)
 449         //    dock.panes.Item(j)->dock_row = i;
 450     }
 451 }
 452
 453
 454 // SetActivePane() sets the active pane, as well as cycles through
 455 // every other pane and makes sure that all others' active flags
 456 // are turned off
 457 static void SetActivePane(wxAuiPaneInfoArray& panes, wxWindow* active_pane)
 458 {
 459     int i, pane_count;
 460     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
 461     {
 462         wxAuiPaneInfo& pane = panes.Item(i);
 463         pane.state &= ~wxAuiPaneInfo::optionActive;
 464         if (pane.window == active_pane)
 465             pane.state |= wxAuiPaneInfo::optionActive;
 466     }
 467 }
 468
 469
 470 // this function is used to sort panes by dock position
 471 static int PaneSortFunc(wxAuiPaneInfo** p1, wxAuiPaneInfo** p2)
 472 {
 473     return ((*p1)->dock_pos < (*p2)->dock_pos) ? -1 : 1;
 474 }
 475
 476
 477 // -- wxAuiManager class implementation --
 478
 479
 480 BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler)
 481     EVT_AUI_PANE_BUTTON(wxAuiManager::OnPaneButton)
 482     EVT_AUI_RENDER(wxAuiManager::OnRender)
 483     EVT_PAINT(wxAuiManager::OnPaint)
 484     EVT_ERASE_BACKGROUND(wxAuiManager::OnEraseBackground)
 485     EVT_SIZE(wxAuiManager::OnSize)
 486     EVT_SET_CURSOR(wxAuiManager::OnSetCursor)
 487     EVT_LEFT_DOWN(wxAuiManager::OnLeftDown)
 488     EVT_LEFT_UP(wxAuiManager::OnLeftUp)
 489     EVT_MOTION(wxAuiManager::OnMotion)
 490     EVT_LEAVE_WINDOW(wxAuiManager::OnLeaveWindow)
 491     EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus)
 492     EVT_AUI_FIND_MANAGER(wxAuiManager::OnFindManager)
 493     EVT_TIMER(101, wxAuiManager::OnHintFadeTimer)
 494 END_EVENT_TABLE()
 495
 496
 497 wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags)
 498 {
 499     m_action = actionNone;
 500     m_last_mouse_move = wxPoint();
 501     m_hover_button = NULL;
 502     m_art = new wxAuiDefaultDockArt;
 503     m_hint_wnd = NULL;
 504     m_flags = flags;
 505     m_skipping = false;
 506     m_has_maximized = false;
 507     m_frame = NULL;
 508     m_dock_constraint_x = 0.3;
 509     m_dock_constraint_y = 0.3;
 510     m_reserved = NULL;
 511
 512     if (managed_wnd)
 513     {
 514         SetManagedWindow(managed_wnd);
 515     }
 516 }
 517
 518 wxAuiManager::~wxAuiManager()
 519 {
 520     for ( size_t i = 0; i < m_panes.size(); i++ )
 521     {
 522         wxAuiPaneInfo& pinfo = m_panes[i];
 523         if (pinfo.window && !pinfo.window->GetParent())
 524             delete pinfo.window;
 525     }
 526
 527     delete m_art;
 528 }
 529
 530 // creates a floating frame for the windows
 531 wxAuiFloatingFrame* wxAuiManager::CreateFloatingFrame(wxWindow* parent,
 532                                                       const wxAuiPaneInfo& pane_info)
 533 {
 534     return new wxAuiFloatingFrame(parent, this, pane_info);
 535 }
 536
 537 bool wxAuiManager::CanDockPanel(const wxAuiPaneInfo & WXUNUSED(p))
 538 {
 539     // if a key modifier is pressed while dragging the frame,
 540     // don't dock the window
 541     return !(wxGetKeyState(WXK_CONTROL) || wxGetKeyState(WXK_ALT));
 542 }
 543
 544 // GetPane() looks up a wxAuiPaneInfo structure based
 545 // on the supplied window pointer.  Upon failure, GetPane()
 546 // returns an empty wxAuiPaneInfo, a condition which can be checked
 547 // by calling wxAuiPaneInfo::IsOk().
 548 //
 549 // The pane info's structure may then be modified.  Once a pane's
 550 // info is modified, wxAuiManager::Update() must be called to
 551 // realize the changes in the UI.
 552
 553 wxAuiPaneInfo& wxAuiManager::GetPane(wxWindow* window)
 554 {
 555     int i, pane_count;
 556     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
 557     {
 558         wxAuiPaneInfo& p = m_panes.Item(i);
 559         if (p.window == window)
 560             return p;
 561     }
 562     return wxAuiNullPaneInfo;
 563 }
 564
 565 // this version of GetPane() looks up a pane based on a
 566 // 'pane name', see above comment for more info
 567 wxAuiPaneInfo& wxAuiManager::GetPane(const wxString& name)
 568 {
 569     int i, pane_count;
 570     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
 571     {
 572         wxAuiPaneInfo& p = m_panes.Item(i);
 573         if (p.name == name)
 574             return p;
 575     }
 576     return wxAuiNullPaneInfo;
 577 }
 578
 579 // GetAllPanes() returns a reference to all the pane info structures
 580 wxAuiPaneInfoArray& wxAuiManager::GetAllPanes()
 581 {
 582     return m_panes;
 583 }
 584
 585 // HitTest() is an internal function which determines
 586 // which UI item the specified coordinates are over
 587 // (x,y) specify a position in client coordinates
 588 wxAuiDockUIPart* wxAuiManager::HitTest(int x, int y)
 589 {
 590     wxAuiDockUIPart* result = NULL;
 591
 592     int i, part_count;
 593     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
 594     {
 595         wxAuiDockUIPart* item = &m_uiparts.Item(i);
 596
 597         // we are not interested in typeDock, because this space
 598         // isn't used to draw anything, just for measurements;
 599         // besides, the entire dock area is covered with other
 600         // rectangles, which we are interested in.
 601         if (item->type == wxAuiDockUIPart::typeDock)
 602             continue;
 603
 604         // if we already have a hit on a more specific item, we are not
 605         // interested in a pane hit.  If, however, we don't already have
 606         // a hit, returning a pane hit is necessary for some operations
 607         if ((item->type == wxAuiDockUIPart::typePane ||
 608             item->type == wxAuiDockUIPart::typePaneBorder) && result)
 609             continue;
 610
 611         // if the point is inside the rectangle, we have a hit
 612         if (item->rect.Contains(x,y))
 613             result = item;
 614     }
 615
 616     return result;
 617 }
 618
 619
 620 // SetFlags() and GetFlags() allow the owner to set various
 621 // options which are global to wxAuiManager
 622 void wxAuiManager::SetFlags(unsigned int flags)
 623 {
 624     // find out if we have to call UpdateHintWindowConfig()
 625     bool update_hint_wnd = false;
 626     unsigned int hint_mask = wxAUI_MGR_TRANSPARENT_HINT |
 627                              wxAUI_MGR_VENETIAN_BLINDS_HINT |
 628                              wxAUI_MGR_RECTANGLE_HINT;
 629     if ((flags & hint_mask) != (m_flags & hint_mask))
 630         update_hint_wnd = true;
 631
 632
 633     // set the new flags
 634     m_flags = flags;
 635
 636     if (update_hint_wnd)
 637     {
 638         UpdateHintWindowConfig();
 639     }
 640 }
 641
 642 unsigned int wxAuiManager::GetFlags() const
 643 {
 644     return m_flags;
 645 }
 646
 647
 648 // don't use these anymore as they are deprecated
 649 // use Set/GetManagedFrame() instead
 650 void wxAuiManager::SetFrame(wxFrame* frame)
 651 {
 652     SetManagedWindow((wxWindow*)frame);
 653 }
 654
 655 wxFrame* wxAuiManager::GetFrame() const
 656 {
 657     return (wxFrame*)m_frame;
 658 }
 659
 660
 661 // this function will return the aui manager for a given
 662 // window.  The |window| parameter should be any child window
 663 // or grand-child window (and so on) of the frame/window
 664 // managed by wxAuiManager.  The |window| parameter does not
 665 // need to be managed by the manager itself.
 666 wxAuiManager* wxAuiManager::GetManager(wxWindow* window)
 667 {
 668     wxAuiManagerEvent evt(wxEVT_AUI_FIND_MANAGER);
 669     evt.SetManager(NULL);
 670     evt.ResumePropagation(wxEVENT_PROPAGATE_MAX);
 671     if (!window->ProcessEvent(evt))
 672         return NULL;
 673
 674     return evt.GetManager();
 675 }
 676
 677
 678 void wxAuiManager::UpdateHintWindowConfig()
 679 {
 680     // find out if the the system can do transparent frames
 681     bool can_do_transparent = false;
 682
 683     wxWindow* w = m_frame;
 684     while (w)
 685     {
 686         if (w->IsKindOf(CLASSINFO(wxFrame)))
 687         {
 688             wxFrame* f = static_cast<wxFrame*>(w);
 689             can_do_transparent = f->CanSetTransparent();
 690             break;
 691         }
 692
 693         w = w->GetParent();
 694     }
 695
 696     // if there is an existing hint window, delete it
 697     if (m_hint_wnd)
 698     {
 699         m_hint_wnd->Destroy();
 700         m_hint_wnd = NULL;
 701     }
 702
 703     m_hint_fademax = 50;
 704     m_hint_wnd = NULL;
 705
 706     if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) && can_do_transparent)
 707     {
 708         // Make a window to use for a transparent hint
 709         #if defined(__WXMSW__) || defined(__WXGTK__)
 710             m_hint_wnd = new wxFrame(m_frame, wxID_ANY, wxEmptyString,
 711                                      wxDefaultPosition, wxSize(1,1),
 712                                          wxFRAME_TOOL_WINDOW |
 713                                          wxFRAME_FLOAT_ON_PARENT |
 714                                          wxFRAME_NO_TASKBAR |
 715                                          wxNO_BORDER);
 716
 717             m_hint_wnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
 718         #elif defined(__WXMAC__)
 719             // Using a miniframe with float and tool styles keeps the parent
 720             // frame activated and highlighted as such...
 721             m_hint_wnd = new wxMiniFrame(m_frame, wxID_ANY, wxEmptyString,
 722                                          wxDefaultPosition, wxSize(1,1),
 723                                          wxFRAME_FLOAT_ON_PARENT
 724                                          | wxFRAME_TOOL_WINDOW );
 725
 726             // Can't set the bg colour of a Frame in wxMac
 727             wxPanel* p = new wxPanel(m_hint_wnd);
 728
 729             // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver
 730             // color that is really hard to see, especially transparent.
 731             // Until a better system color is decided upon we'll just use
 732             // blue.
 733             p->SetBackgroundColour(*wxBLUE);
 734         #endif
 735
 736     }
 737     else
 738     {
 739         if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 ||
 740             (m_flags & wxAUI_MGR_VENETIAN_BLINDS_HINT) != 0)
 741         {
 742             // system can't support transparent fade, or the venetian
 743             // blinds effect was explicitly requested
 744             m_hint_wnd = new wxPseudoTransparentFrame(m_frame,
 745                                                       wxID_ANY,
 746                                                       wxEmptyString,
 747                                                       wxDefaultPosition,
 748                                                       wxSize(1,1),
 749                                                             wxFRAME_TOOL_WINDOW |
 750                                                             wxFRAME_FLOAT_ON_PARENT |
 751                                                             wxFRAME_NO_TASKBAR |
 752                                                             wxNO_BORDER);
 753             m_hint_fademax = 128;
 754         }
 755     }
 756 }
 757
 758
 759 // SetManagedWindow() is usually called once when the frame
 760 // manager class is being initialized.  "frame" specifies
 761 // the frame which should be managed by the frame mananger
 762 void wxAuiManager::SetManagedWindow(wxWindow* wnd)
 763 {
 764     wxASSERT_MSG(wnd, wxT("specified window must be non-NULL"));
 765
 766     m_frame = wnd;
 767     m_frame->PushEventHandler(this);
 768
 769 #if wxUSE_MDI
 770     // if the owner is going to manage an MDI parent frame,
 771     // we need to add the MDI client window as the default
 772     // center pane
 773
 774     if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
 775     {
 776         wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)m_frame;
 777         wxWindow* client_window = mdi_frame->GetClientWindow();
 778
 779         wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
 780
 781         AddPane(client_window,
 782                 wxAuiPaneInfo().Name(wxT("mdiclient")).
 783                 CenterPane().PaneBorder(false));
 784     }
 785     else if (m_frame->IsKindOf(CLASSINFO(wxAuiMDIParentFrame)))
 786     {
 787         wxAuiMDIParentFrame* mdi_frame = (wxAuiMDIParentFrame*)m_frame;
 788         wxAuiMDIClientWindow* client_window = mdi_frame->GetClientWindow();
 789         wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
 790
 791         AddPane(client_window,
 792                 wxAuiPaneInfo().Name(wxT("mdiclient")).
 793                 CenterPane().PaneBorder(false));
 794     }
 795
 796 #endif
 797
 798     UpdateHintWindowConfig();
 799 }
 800
 801
 802 // UnInit() must be called, usually in the destructor
 803 // of the frame class.   If it is not called, usually this
 804 // will result in a crash upon program exit
 805 void wxAuiManager::UnInit()
 806 {
 807     if (m_frame)
 808     {
 809         m_frame->RemoveEventHandler(this);
 810     }
 811 }
 812
 813 // GetManagedWindow() returns the window pointer being managed
 814 wxWindow* wxAuiManager::GetManagedWindow() const
 815 {
 816     return m_frame;
 817 }
 818
 819 wxAuiDockArt* wxAuiManager::GetArtProvider() const
 820 {
 821     return m_art;
 822 }
 823
 824 void wxAuiManager::ProcessMgrEvent(wxAuiManagerEvent& event)
 825 {
 826     // first, give the owner frame a chance to override
 827     if (m_frame)
 828     {
 829         if (m_frame->ProcessEvent(event))
 830             return;
 831     }
 832
 833     ProcessEvent(event);
 834 }
 835
 836 // SetArtProvider() instructs wxAuiManager to use the
 837 // specified art provider for all drawing calls.  This allows
 838 // plugable look-and-feel features.  The pointer that is
 839 // passed to this method subsequently belongs to wxAuiManager,
 840 // and is deleted in the frame manager destructor
 841 void wxAuiManager::SetArtProvider(wxAuiDockArt* art_provider)
 842 {
 843     // delete the last art provider, if any
 844     delete m_art;
 845
 846     // assign the new art provider
 847     m_art = art_provider;
 848 }
 849
 850
 851 bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
 852 {
 853     // check if the pane has a valid window
 854     if (!window)
 855         return false;
 856
 857     // check if the window is already managed by us
 858     if (GetPane(pane_info.window).IsOk())
 859         return false;
 860
 861     // check if the pane name already exists, this could reveal a
 862     // bug in the library user's application
 863     bool already_exists = false;
 864     if (!pane_info.name.empty() && GetPane(pane_info.name).IsOk())
 865     {
 866         wxFAIL_MSG(wxT("A pane with that name already exists in the manager!"));
 867         already_exists = true;
 868     }
 869
 870     // if the new pane is docked then we should undo maximize
 871     if (pane_info.IsDocked())
 872         RestoreMaximizedPane();
 873
 874     m_panes.Add(pane_info);
 875
 876     wxAuiPaneInfo& pinfo = m_panes.Last();
 877
 878     // set the pane window
 879     pinfo.window = window;
 880
 881
 882     // if the pane's name identifier is blank, create a random string
 883     if (pinfo.name.empty() || already_exists)
 884     {
 885         pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"),
 886              ((unsigned long)pinfo.window) & 0xffffffff,
 887              (unsigned int)time(NULL),
 888 #ifdef __WXWINCE__
 889              (unsigned int)GetTickCount(),
 890 #else
 891              (unsigned int)clock(),
 892 #endif
 893              (unsigned long)m_panes.GetCount());
 894     }
 895
 896     // set initial proportion (if not already set)
 897     if (pinfo.dock_proportion == 0)
 898         pinfo.dock_proportion = 100000;
 899
 900     if (pinfo.HasMaximizeButton())
 901     {
 902         wxAuiPaneButton button;
 903         button.button_id = wxAUI_BUTTON_MAXIMIZE_RESTORE;
 904         pinfo.buttons.Add(button);
 905     }
 906
 907     if (pinfo.HasPinButton())
 908     {
 909         wxAuiPaneButton button;
 910         button.button_id = wxAUI_BUTTON_PIN;
 911         pinfo.buttons.Add(button);
 912     }
 913
 914     if (pinfo.HasCloseButton())
 915     {
 916         wxAuiPaneButton button;
 917         button.button_id = wxAUI_BUTTON_CLOSE;
 918         pinfo.buttons.Add(button);
 919     }
 920
 921     if (pinfo.best_size == wxDefaultSize &&
 922         pinfo.window)
 923     {
 924         pinfo.best_size = pinfo.window->GetClientSize();
 925
 926         if (pinfo.window->IsKindOf(CLASSINFO(wxToolBar)))
 927         {
 928             // GetClientSize() doesn't get the best size for
 929             // a toolbar under some newer versions of wxWidgets,
 930             // so use GetBestSize()
 931             pinfo.best_size = pinfo.window->GetBestSize();
 932
 933             // for some reason, wxToolBar::GetBestSize() is returning
 934             // a size that is a pixel shy of the correct amount.
 935             // I believe this to be the correct action, until
 936             // wxToolBar::GetBestSize() is fixed.  Is this assumption
 937             // correct?
 938             // commented out by JACS 2007-9-08 after having added a pixel in wxMSW's wxToolBar::DoGetBestSize()
 939             // pinfo.best_size.y++;
 940         }
 941
 942         if (pinfo.min_size != wxDefaultSize)
 943         {
 944             if (pinfo.best_size.x < pinfo.min_size.x)
 945                 pinfo.best_size.x = pinfo.min_size.x;
 946             if (pinfo.best_size.y < pinfo.min_size.y)
 947                 pinfo.best_size.y = pinfo.min_size.y;
 948         }
 949     }
 950
 951     return true;
 952 }
 953
 954 bool wxAuiManager::AddPane(wxWindow* window,
 955                            int direction,
 956                            const wxString& caption)
 957 {
 958     wxAuiPaneInfo pinfo;
 959     pinfo.Caption(caption);
 960     switch (direction)
 961     {
 962         case wxTOP:    pinfo.Top(); break;
 963         case wxBOTTOM: pinfo.Bottom(); break;
 964         case wxLEFT:   pinfo.Left(); break;
 965         case wxRIGHT:  pinfo.Right(); break;
 966         case wxCENTER: pinfo.CenterPane(); break;
 967     }
 968     return AddPane(window, pinfo);
 969 }
 970
 971 bool wxAuiManager::AddPane(wxWindow* window,
 972                            const wxAuiPaneInfo& pane_info,
 973                            const wxPoint& drop_pos)
 974 {
 975     if (!AddPane(window, pane_info))
 976         return false;
 977
 978     wxAuiPaneInfo& pane = GetPane(window);
 979
 980     DoDrop(m_docks, m_panes, pane, drop_pos, wxPoint(0,0));
 981
 982     return true;
 983 }
 984
 985 bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info,
 986                                 int insert_level)
 987 {
 988     // shift the panes around, depending on the insert level
 989     switch (insert_level)
 990     {
 991         case wxAUI_INSERT_PANE:
 992             DoInsertPane(m_panes,
 993                  pane_info.dock_direction,
 994                  pane_info.dock_layer,
 995                  pane_info.dock_row,
 996                  pane_info.dock_pos);
 997             break;
 998         case wxAUI_INSERT_ROW:
 999             DoInsertDockRow(m_panes,
1000                  pane_info.dock_direction,
1001                  pane_info.dock_layer,
1002                  pane_info.dock_row);
1003             break;
1004         case wxAUI_INSERT_DOCK:
1005             DoInsertDockLayer(m_panes,
1006                  pane_info.dock_direction,
1007                  pane_info.dock_layer);
1008             break;
1009     }
1010
1011     // if the window already exists, we are basically just moving/inserting the
1012     // existing window.  If it doesn't exist, we need to add it and insert it
1013     wxAuiPaneInfo& existing_pane = GetPane(window);
1014     if (!existing_pane.IsOk())
1015     {
1016         return AddPane(window, pane_info);
1017     }
1018     else
1019     {
1020         if (pane_info.IsFloating())
1021         {
1022             existing_pane.Float();
1023             if (pane_info.floating_pos != wxDefaultPosition)
1024                 existing_pane.FloatingPosition(pane_info.floating_pos);
1025             if (pane_info.floating_size != wxDefaultSize)
1026                 existing_pane.FloatingSize(pane_info.floating_size);
1027         }
1028         else
1029         {
1030             // if the new pane is docked then we should undo maximize
1031             RestoreMaximizedPane();
1032
1033             existing_pane.Direction(pane_info.dock_direction);
1034             existing_pane.Layer(pane_info.dock_layer);
1035             existing_pane.Row(pane_info.dock_row);
1036             existing_pane.Position(pane_info.dock_pos);
1037         }
1038     }
1039
1040     return true;
1041 }
1042
1043
1044 // DetachPane() removes a pane from the frame manager.  This
1045 // method will not destroy the window that is removed.
1046 bool wxAuiManager::DetachPane(wxWindow* window)
1047 {
1048     int i, count;
1049     for (i = 0, count = m_panes.GetCount(); i < count; ++i)
1050     {
1051         wxAuiPaneInfo& p = m_panes.Item(i);
1052         if (p.window == window)
1053         {
1054             if (p.frame)
1055             {
1056                 // we have a floating frame which is being detached. We need to
1057                 // reparent it to m_frame and destroy the floating frame
1058
1059                 // reduce flicker
1060                 p.window->SetSize(1,1);
1061
1062                 if (p.frame->IsShown())
1063                     p.frame->Show(false);
1064
1065                 // reparent to m_frame and destroy the pane
1066                 if (m_action_window == p.frame)
1067                 {
1068                     m_action_window = NULL;
1069                 }
1070
1071                 p.window->Reparent(m_frame);
1072                 p.frame->SetSizer(NULL);
1073                 p.frame->Destroy();
1074                 p.frame = NULL;
1075             }
1076
1077             // make sure there are no references to this pane in our uiparts,
1078             // just in case the caller doesn't call Update() immediately after
1079             // the DetachPane() call.  This prevets obscure crashes which would
1080             // happen at window repaint if the caller forgets to call Update()
1081             int pi, part_count;
1082             for (pi = 0, part_count = (int)m_uiparts.GetCount(); pi < part_count; ++pi)
1083             {
1084                 wxAuiDockUIPart& part = m_uiparts.Item(pi);
1085                 if (part.pane == &p)
1086                 {
1087                     m_uiparts.RemoveAt(pi);
1088                     part_count--;
1089                     pi--;
1090                     continue;
1091                 }
1092             }
1093
1094             m_panes.RemoveAt(i);
1095             return true;
1096         }
1097     }
1098     return false;
1099 }
1100
1101 // ClosePane() destroys or hides the pane depending on its flags
1102 void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info)
1103 {
1104     // if we were maximized, restore
1105     if (pane_info.IsMaximized())
1106     {
1107         RestorePane(pane_info);
1108     }
1109
1110     // first, hide the window
1111     if (pane_info.window && pane_info.window->IsShown())
1112     {
1113         pane_info.window->Show(false);
1114     }
1115
1116     // make sure that we are the parent of this window
1117     if (pane_info.window && pane_info.window->GetParent() != m_frame)
1118     {
1119         pane_info.window->Reparent(m_frame);
1120     }
1121
1122     // if we have a frame, destroy it
1123     if (pane_info.frame)
1124     {
1125         pane_info.frame->Destroy();
1126         pane_info.frame = NULL;
1127     }
1128
1129     // now we need to either destroy or hide the pane
1130     if (pane_info.IsDestroyOnClose())
1131     {
1132         wxWindow * window = pane_info.window;
1133         DetachPane(window);
1134         if (window)
1135         {
1136             window->Destroy();
1137         }
1138     }
1139     else
1140     {
1141         pane_info.Hide();
1142     }
1143 }
1144
1145 void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info)
1146 {
1147     int i, pane_count;
1148
1149     // un-maximize and hide all other panes
1150     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
1151     {
1152         wxAuiPaneInfo& p = m_panes.Item(i);
1153         if (!p.IsToolbar())
1154         {
1155             p.Restore();
1156
1157             // save hidden state
1158             p.SetFlag(wxAuiPaneInfo::savedHiddenState,
1159                       p.HasFlag(wxAuiPaneInfo::optionHidden));
1160
1161             // hide the pane, because only the newly
1162             // maximized pane should show
1163             p.Hide();
1164         }
1165     }
1166
1167     // mark ourselves maximized
1168     pane_info.Maximize();
1169     pane_info.Show();
1170     m_has_maximized = true;
1171
1172     // last, show the window
1173     if (pane_info.window && !pane_info.window->IsShown())
1174     {
1175         pane_info.window->Show(true);
1176     }
1177 }
1178
1179 void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info)
1180 {
1181     int i, pane_count;
1182
1183     // restore all the panes
1184     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
1185     {
1186         wxAuiPaneInfo& p = m_panes.Item(i);
1187         if (!p.IsToolbar())
1188         {
1189             p.SetFlag(wxAuiPaneInfo::optionHidden,
1190                       p.HasFlag(wxAuiPaneInfo::savedHiddenState));
1191         }
1192     }
1193
1194     // mark ourselves non-maximized
1195     pane_info.Restore();
1196     m_has_maximized = false;
1197
1198     // last, show the window
1199     if (pane_info.window && !pane_info.window->IsShown())
1200     {
1201         pane_info.window->Show(true);
1202     }
1203 }
1204
1205 void wxAuiManager::RestoreMaximizedPane()
1206 {
1207     int i, pane_count;
1208
1209     // restore all the panes
1210     for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
1211     {
1212         wxAuiPaneInfo& p = m_panes.Item(i);
1213         if (p.IsMaximized())
1214         {
1215             RestorePane(p);
1216             break;
1217         }
1218     }
1219 }
1220
1221 // EscapeDelimiters() changes ";" into "\;" and "|" into "\|"
1222 // in the input string.  This is an internal functions which is
1223 // used for saving perspectives
1224 static wxString EscapeDelimiters(const wxString& s)
1225 {
1226     wxString result;
1227     result.Alloc(s.length());
1228     const wxChar* ch = s.c_str();
1229     while (*ch)
1230     {
1231         if (*ch == wxT(';') || *ch == wxT('|'))
1232             result += wxT('\\');
1233         result += *ch;
1234         ++ch;
1235     }
1236     return result;
1237 }
1238
1239 wxString wxAuiManager::SavePaneInfo(wxAuiPaneInfo& pane)
1240 {
1241     wxString result = wxT("name=");
1242     result += EscapeDelimiters(pane.name);
1243     result += wxT(";");
1244
1245     result += wxT("caption=");
1246     result += EscapeDelimiters(pane.caption);
1247     result += wxT(";");
1248
1249     result += wxString::Format(wxT("state=%u;"), pane.state);
1250     result += wxString::Format(wxT("dir=%d;"), pane.dock_direction);
1251     result += wxString::Format(wxT("layer=%d;"), pane.dock_layer);
1252     result += wxString::Format(wxT("row=%d;"), pane.dock_row);
1253     result += wxString::Format(wxT("pos=%d;"), pane.dock_pos);
1254     result += wxString::Format(wxT("prop=%d;"), pane.dock_proportion);
1255     result += wxString::Format(wxT("bestw=%d;"), pane.best_size.x);
1256     result += wxString::Format(wxT("besth=%d;"), pane.best_size.y);
1257     result += wxString::Format(wxT("minw=%d;"), pane.min_size.x);
1258     result += wxString::Format(wxT("minh=%d;"), pane.min_size.y);
1259     result += wxString::Format(wxT("maxw=%d;"), pane.max_size.x);
1260     result += wxString::Format(wxT("maxh=%d;"), pane.max_size.y);
1261     result += wxString::Format(wxT("floatx=%d;"), pane.floating_pos.x);
1262     result += wxString::Format(wxT("floaty=%d;"), pane.floating_pos.y);
1263     result += wxString::Format(wxT("floatw=%d;"), pane.floating_size.x);
1264     result += wxString::Format(wxT("floath=%d"), pane.floating_size.y);
1265
1266     return result;
1267 }
1268
1269 // Load a "pane" with the pane infor settings in pane_part
1270 void wxAuiManager::LoadPaneInfo(wxString pane_part, wxAuiPaneInfo &pane)
1271 {
1272     // replace escaped characters so we can
1273     // split up the string easily
1274     pane_part.Replace(wxT("\\|"), wxT("\a"));
1275     pane_part.Replace(wxT("\\;"), wxT("\b"));
1276
1277     while(1)
1278     {
1279         wxString val_part = pane_part.BeforeFirst(wxT(';'));
1280         pane_part = pane_part.AfterFirst(wxT(';'));
1281         wxString val_name = val_part.BeforeFirst(wxT('='));
1282         wxString value = val_part.AfterFirst(wxT('='));
1283         val_name.MakeLower();
1284         val_name.Trim(true);
1285         val_name.Trim(false);
1286         value.Trim(true);
1287         value.Trim(false);
1288
1289         if (val_name.empty())
1290             break;
1291
1292         if (val_name == wxT("name"))
1293             pane.name = value;
1294         else if (val_name == wxT("caption"))
1295             pane.caption = value;
1296         else if (val_name == wxT("state"))
1297             pane.state = (unsigned int)wxAtoi(value.c_str());
1298         else if (val_name == wxT("dir"))
1299             pane.dock_direction = wxAtoi(value.c_str());
1300         else if (val_name == wxT("layer"))
1301             pane.dock_layer = wxAtoi(value.c_str());
1302         else if (val_name == wxT("row"))
1303             pane.dock_row = wxAtoi(value.c_str());
1304         else if (val_name == wxT("pos"))
1305             pane.dock_pos = wxAtoi(value.c_str());
1306         else if (val_name == wxT("prop"))
1307             pane.dock_proportion = wxAtoi(value.c_str());
1308         else if (val_name == wxT("bestw"))
1309             pane.best_size.x = wxAtoi(value.c_str());
1310         else if (val_name == wxT("besth"))
1311             pane.best_size.y = wxAtoi(value.c_str());
1312         else if (val_name == wxT("minw"))
1313             pane.min_size.x = wxAtoi(value.c_str());
1314         else if (val_name == wxT("minh"))
1315             pane.min_size.y = wxAtoi(value.c_str());
1316         else if (val_name == wxT("maxw"))
1317             pane.max_size.x = wxAtoi(value.c_str());
1318         else if (val_name == wxT("maxh"))
1319             pane.max_size.y = wxAtoi(value.c_str());
1320         else if (val_name == wxT("floatx"))
1321             pane.floating_pos.x = wxAtoi(value.c_str());
1322         else if (val_name == wxT("floaty"))
1323             pane.floating_pos.y = wxAtoi(value.c_str());
1324         else if (val_name == wxT("floatw"))
1325             pane.floating_size.x = wxAtoi(value.c_str());
1326         else if (val_name == wxT("floath"))
1327             pane.floating_size.y = wxAtoi(value.c_str());
1328         else {
1329             wxFAIL_MSG(wxT("Bad Perspective String"));
1330         }
1331     }
1332
1333     // replace escaped characters so we can
1334     // split up the string easily
1335     pane.name.Replace(wxT("\a"), wxT("|"));
1336     pane.name.Replace(wxT("\b"), wxT(";"));
1337     pane.caption.Replace(wxT("\a"), wxT("|"));
1338     pane.caption.Replace(wxT("\b"), wxT(";"));
1339     pane_part.Replace(wxT("\a"), wxT("|"));
1340     pane_part.Replace(wxT("\b"), wxT(";"));
1341
1342     return;
1343 }
1344
1345
1346 // SavePerspective() saves all pane information as a single string.
1347 // This string may later be fed into LoadPerspective() to restore
1348 // all pane settings.  This save and load mechanism allows an
1349 // exact pane configuration to be saved and restored at a later time
1350
1351 wxString wxAuiManager::SavePerspective()
1352 {
1353     wxString result;
1354     result.Alloc(500);
1355     result = wxT("layout2|");
1356
1357     int pane_i, pane_count = m_panes.GetCount();
1358     for (pane_i = 0; pane_i < pane_count; ++pane_i)
1359     {
1360         wxAuiPaneInfo& pane = m_panes.Item(pane_i);
1361         result += SavePaneInfo(pane)+wxT("|");
1362     }
1363
1364     int dock_i, dock_count = m_docks.GetCount();
1365     for (dock_i = 0; dock_i < dock_count; ++dock_i)
1366     {
1367         wxAuiDockInfo& dock = m_docks.Item(dock_i);
1368
1369         result += wxString::Format(wxT("dock_size(%d,%d,%d)=%d|"),
1370                                    dock.dock_direction, dock.dock_layer,
1371                                    dock.dock_row, dock.size);
1372     }
1373
1374     return result;
1375 }
1376
1377 // LoadPerspective() loads a layout which was saved with SavePerspective()
1378 // If the "update" flag parameter is true, the GUI will immediately be updated
1379
1380 bool wxAuiManager::LoadPerspective(const wxString& layout, bool update)
1381 {
1382     wxString input = layout;
1383     wxString part;
1384
1385     // check layout string version
1386     //    'layout1' = wxAUI 0.9.0 - wxAUI 0.9.2
1387     //    'layout2' = wxAUI 0.9.2 (wxWidgets 2.8)
1388     part = input.BeforeFirst(wxT('|'));
1389     input = input.AfterFirst(wxT('|'));
1390     part.Trim(true);
1391     part.Trim(false);
1392     if (part != wxT("layout2"))
1393         return false;
1394
1395     // mark all panes currently managed as docked and hidden
1396     int pane_i, pane_count = m_panes.GetCount();
1397     for (pane_i = 0; pane_i < pane_count; ++pane_i)
1398         m_panes.Item(pane_i).Dock().Hide();
1399
1400     // clear out the dock array; this will be reconstructed
1401     m_docks.Clear();
1402
1403     // replace escaped characters so we can
1404     // split up the string easily
1405     input.Replace(wxT("\\|"), wxT("\a"));
1406     input.Replace(wxT("\\;"), wxT("\b"));
1407
1408     while (1)
1409     {
1410         wxAuiPaneInfo pane;
1411
1412         wxString pane_part = input.BeforeFirst(wxT('|'));
1413         input = input.AfterFirst(wxT('|'));
1414         pane_part.Trim(true);
1415
1416         // if the string is empty, we're done parsing
1417         if (pane_part.empty())
1418             break;
1419
1420         if (pane_part.Left(9) == wxT("dock_size"))
1421         {
1422             wxString val_name = pane_part.BeforeFirst(wxT('='));
1423             wxString value = pane_part.AfterFirst(wxT('='));
1424
1425             long dir, layer, row, size;
1426             wxString piece = val_name.AfterFirst(wxT('('));
1427             piece = piece.BeforeLast(wxT(')'));
1428             piece.BeforeFirst(wxT(',')).ToLong(&dir);
1429             piece = piece.AfterFirst(wxT(','));
1430             piece.BeforeFirst(wxT(',')).ToLong(&layer);
1431             piece.AfterFirst(wxT(',')).ToLong(&row);
1432             value.ToLong(&size);
1433
1434             wxAuiDockInfo dock;
1435             dock.dock_direction = dir;
1436             dock.dock_layer = layer;
1437             dock.dock_row = row;
1438             dock.size = size;
1439             m_docks.Add(dock);
1440             continue;
1441         }
1442
1443         // Undo our escaping as LoadPaneInfo needs to take an unescaped
1444         // name so it can be called by external callers
1445         pane_part.Replace(wxT("\a"), wxT("|"));
1446         pane_part.Replace(wxT("\b"), wxT(";"));
1447
1448         LoadPaneInfo(pane_part, pane);
1449
1450         wxAuiPaneInfo& p = GetPane(pane.name);
1451         if (!p.IsOk())
1452         {
1453             // the pane window couldn't be found
1454             // in the existing layout -- skip it
1455             continue;
1456         }
1457
1458         p.SafeSet(pane);
1459     }
1460
1461     if (update)
1462         Update();
1463
1464     return true;
1465 }
1466
1467 void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
1468                                             wxArrayInt& positions,
1469                                             wxArrayInt& sizes)
1470 {
1471     int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
1472     int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
1473     int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
1474
1475     positions.Empty();
1476     sizes.Empty();
1477
1478     int offset, action_pane = -1;
1479     int pane_i, pane_count = dock.panes.GetCount();
1480
1481     // find the pane marked as our action pane
1482     for (pane_i = 0; pane_i < pane_count; ++pane_i)
1483     {
1484         wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
1485
1486         if (pane.state & wxAuiPaneInfo::actionPane)
1487         {
1488             wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes"));
1489             action_pane = pane_i;
1490         }
1491     }
1492
1493     // set up each panes default position, and
1494     // determine the size (width or height, depending
1495     // on the dock's orientation) of each pane
1496     for (pane_i = 0; pane_i < pane_count; ++pane_i)
1497     {
1498         wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
1499         positions.Add(pane.dock_pos);
1500         int size = 0;
1501
1502         if (pane.HasBorder())
1503             size += (pane_border_size*2);
1504
1505         if (dock.IsHorizontal())
1506         {
1507             if (pane.HasGripper() && !pane.HasGripperTop())
1508                 size += gripper_size;
1509             size += pane.best_size.x;
1510         }
1511         else
1512         {
1513             if (pane.HasGripper() && pane.HasGripperTop())
1514                 size += gripper_size;
1515
1516             if (pane.HasCaption())
1517                 size += caption_size;
1518             size += pane.best_size.y;
1519         }
1520
1521         sizes.Add(size);
1522     }
1523
1524     // if there is no action pane, just return the default
1525     // positions (as specified in pane.pane_pos)
1526     if (action_pane == -1)
1527         return;
1528
1529     offset = 0;
1530     for (pane_i = action_pane-1; pane_i >= 0; --pane_i)
1531     {
1532         int amount = positions[pane_i+1] - (positions[pane_i] + sizes[pane_i]);
1533
1534         if (amount >= 0)
1535             offset += amount;
1536         else
1537             positions[pane_i] -= -amount;
1538
1539         offset += sizes[pane_i];
1540     }
1541
1542     // if the dock mode is fixed, make sure none of the panes
1543     // overlap; we will bump panes that overlap
1544     offset = 0;
1545     for (pane_i = action_pane; pane_i < pane_count; ++pane_i)
1546     {
1547         int amount = positions[pane_i] - offset;
1548         if (amount >= 0)
1549             offset += amount;
1550         else
1551             positions[pane_i] += -amount;
1552
1553         offset += sizes[pane_i];
1554     }
1555 }
1556
1557
1558 void wxAuiManager::LayoutAddPane(wxSizer* cont,
1559                                  wxAuiDockInfo& dock,
1560                                  wxAuiPaneInfo& pane,
1561                                  wxAuiDockUIPartArray& uiparts,
1562                                  bool spacer_only)
1563 {
1564     wxAuiDockUIPart part;
1565     wxSizerItem* sizer_item;
1566
1567     int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
1568     int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
1569     int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
1570     int pane_button_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BUTTON_SIZE);
1571
1572     // find out the orientation of the item (orientation for panes
1573     // is the same as the dock's orientation)
1574     int orientation;
1575     if (dock.IsHorizontal())
1576         orientation = wxHORIZONTAL;
1577     else
1578         orientation = wxVERTICAL;
1579
1580     // this variable will store the proportion
1581     // value that the pane will receive
1582     int pane_proportion = pane.dock_proportion;
1583
1584     wxBoxSizer* horz_pane_sizer = new wxBoxSizer(wxHORIZONTAL);
1585     wxBoxSizer* vert_pane_sizer = new wxBoxSizer(wxVERTICAL);
1586
1587     if (pane.HasGripper())
1588     {
1589         if (pane.HasGripperTop())
1590             sizer_item = vert_pane_sizer ->Add(1, gripper_size, 0, wxEXPAND);
1591         else
1592             sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND);
1593
1594         part.type = wxAuiDockUIPart::typeGripper;
1595         part.dock = &dock;
1596         part.pane = &pane;
1597         part.button = NULL;
1598         part.orientation = orientation;
1599         part.cont_sizer = horz_pane_sizer;
1600         part.sizer_item = sizer_item;
1601         uiparts.Add(part);
1602     }
1603
1604     if (pane.HasCaption())
1605     {
1606         // create the caption sizer
1607         wxBoxSizer* caption_sizer = new wxBoxSizer(wxHORIZONTAL);
1608
1609         sizer_item = caption_sizer->Add(1, caption_size, 1, wxEXPAND);
1610
1611         part.type = wxAuiDockUIPart::typeCaption;
1612         part.dock = &dock;
1613         part.pane = &pane;
1614         part.button = NULL;
1615         part.orientation = orientation;
1616         part.cont_sizer = vert_pane_sizer;
1617         part.sizer_item = sizer_item;
1618         int caption_part_idx = uiparts.GetCount();
1619         uiparts.Add(part);
1620
1621         // add pane buttons to the caption
1622         int i, button_count;
1623         for (i = 0, button_count = pane.buttons.GetCount();
1624              i < button_count; ++i)
1625         {
1626             wxAuiPaneButton& button = pane.buttons.Item(i);
1627
1628             sizer_item = caption_sizer->Add(pane_button_size,
1629                                             caption_size,
1630                                             0, wxEXPAND);
1631
1632             part.type = wxAuiDockUIPart::typePaneButton;
1633             part.dock = &dock;
1634             part.pane = &pane;
1635             part.button = &button;
1636             part.orientation = orientation;
1637             part.cont_sizer = caption_sizer;
1638             part.sizer_item = sizer_item;
1639             uiparts.Add(part);
1640         }
1641
1642         // if we have buttons, add a little space to the right
1643         // of them to ease visual crowding
1644         if (button_count >= 1)
1645         {
1646             caption_sizer->Add(3,1);
1647         }
1648
1649         // add the caption sizer
1650         sizer_item = vert_pane_sizer->Add(caption_sizer, 0, wxEXPAND);
1651
1652         uiparts.Item(caption_part_idx).sizer_item = sizer_item;
1653     }
1654
1655     // add the pane window itself
1656     if (spacer_only)
1657     {
1658         sizer_item = vert_pane_sizer->Add(1, 1, 1, wxEXPAND);
1659     }
1660     else
1661     {
1662         sizer_item = vert_pane_sizer->Add(pane.window, 1, wxEXPAND);
1663         // Don't do this because it breaks the pane size in floating windows
1664         // BIW: Right now commenting this out is causing problems with
1665         // an mdi client window as the center pane.
1666         vert_pane_sizer->SetItemMinSize(pane.window, 1, 1);
1667     }
1668
1669     part.type = wxAuiDockUIPart::typePane;
1670     part.dock = &dock;
1671     part.pane = &pane;
1672     part.button = NULL;
1673     part.orientation = orientation;
1674     part.cont_sizer = vert_pane_sizer;
1675     part.sizer_item = sizer_item;
1676     uiparts.Add(part);
1677
1678
1679     // determine if the pane should have a minimum size; if the pane is
1680     // non-resizable (fixed) then we must set a minimum size. Alternatively,
1681     // if the pane.min_size is set, we must use that value as well
1682
1683     wxSize min_size = pane.min_size;
1684     if (pane.IsFixed())
1685     {
1686         if (min_size == wxDefaultSize)
1687         {
1688             min_size = pane.best_size;
1689             pane_proportion = 0;
1690         }
1691     }
1692
1693     if (min_size != wxDefaultSize)
1694     {
1695         vert_pane_sizer->SetItemMinSize(
1696                         vert_pane_sizer->GetChildren().GetCount()-1,
1697                         min_size.x, min_size.y);
1698     }
1699
1700
1701     // add the verticle sizer (caption, pane window) to the
1702     // horizontal sizer (gripper, verticle sizer)
1703     horz_pane_sizer->Add(vert_pane_sizer, 1, wxEXPAND);
1704
1705     // finally, add the pane sizer to the dock sizer
1706
1707     if (pane.HasBorder())
1708     {
1709         // allowing space for the pane's border
1710         sizer_item = cont->Add(horz_pane_sizer, pane_proportion,
1711                                wxEXPAND | wxALL, pane_border_size);
1712
1713         part.type = wxAuiDockUIPart::typePaneBorder;
1714         part.dock = &dock;
1715         part.pane = &pane;
1716         part.button = NULL;
1717         part.orientation = orientation;
1718         part.cont_sizer = cont;
1719         part.sizer_item = sizer_item;
1720         uiparts.Add(part);
1721     }
1722     else
1723     {
1724         sizer_item = cont->Add(horz_pane_sizer, pane_proportion, wxEXPAND);
1725     }
1726 }
1727
1728 void wxAuiManager::LayoutAddDock(wxSizer* cont,
1729                                  wxAuiDockInfo& dock,
1730                                  wxAuiDockUIPartArray& uiparts,
1731                                  bool spacer_only)
1732 {
1733     wxSizerItem* sizer_item;
1734     wxAuiDockUIPart part;
1735
1736     int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE);
1737     int orientation = dock.IsHorizontal() ? wxHORIZONTAL : wxVERTICAL;
1738
1739     // resizable bottom and right docks have a sash before them
1740     if (!m_has_maximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM ||
1741                         dock.dock_direction == wxAUI_DOCK_RIGHT))
1742     {
1743         sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
1744
1745         part.type = wxAuiDockUIPart::typeDockSizer;
1746         part.orientation = orientation;
1747         part.dock = &dock;
1748         part.pane = NULL;
1749         part.button = NULL;
1750         part.cont_sizer = cont;
1751         part.sizer_item = sizer_item;
1752         uiparts.Add(part);
1753     }
1754
1755     // create the sizer for the dock
1756     wxSizer* dock_sizer = new wxBoxSizer(orientation);
1757
1758     // add each pane to the dock
1759     bool has_maximized_pane = false;
1760     int pane_i, pane_count = dock.panes.GetCount();
1761
1762     if (dock.fixed)
1763     {
1764         wxArrayInt pane_positions, pane_sizes;
1765
1766         // figure out the real pane positions we will
1767         // use, without modifying the each pane's pane_pos member
1768         GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
1769
1770         int offset = 0;
1771         for (pane_i = 0; pane_i < pane_count; ++pane_i)
1772         {
1773             wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
1774             int pane_pos = pane_positions.Item(pane_i);
1775
1776             if (pane.IsMaximized())
1777                 has_maximized_pane = true;
1778
1779
1780             int amount = pane_pos - offset;
1781             if (amount > 0)
1782             {
1783                 if (dock.IsVertical())
1784                     sizer_item = dock_sizer->Add(1, amount, 0, wxEXPAND);
1785                 else
1786                     sizer_item = dock_sizer->Add(amount, 1, 0, wxEXPAND);
1787
1788                 part.type = wxAuiDockUIPart::typeBackground;
1789                 part.dock = &dock;
1790                 part.pane = NULL;
1791                 part.button = NULL;
1792                 part.orientation = (orientation==wxHORIZONTAL) ? wxVERTICAL:wxHORIZONTAL;
1793                 part.cont_sizer = dock_sizer;
1794                 part.sizer_item = sizer_item;
1795                 uiparts.Add(part);
1796
1797                 offset += amount;
1798             }
1799
1800             LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only);
1801
1802             offset += pane_sizes.Item(pane_i);
1803         }
1804
1805         // at the end add a very small stretchable background area
1806         sizer_item = dock_sizer->Add(0,0, 1, wxEXPAND);
1807
1808         part.type = wxAuiDockUIPart::typeBackground;
1809         part.dock = &dock;
1810         part.pane = NULL;
1811         part.button = NULL;
1812         part.orientation = orientation;
1813         part.cont_sizer = dock_sizer;
1814         part.sizer_item = sizer_item;
1815         uiparts.Add(part);
1816     }
1817     else
1818     {
1819         for (pane_i = 0; pane_i < pane_count; ++pane_i)
1820         {
1821             wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
1822
1823             if (pane.IsMaximized())
1824                 has_maximized_pane = true;
1825
1826             // if this is not the first pane being added,
1827             // we need to add a pane sizer
1828             if (!m_has_maximized && pane_i > 0)
1829             {
1830                 sizer_item = dock_sizer->Add(sash_size, sash_size, 0, wxEXPAND);
1831
1832                 part.type = wxAuiDockUIPart::typePaneSizer;
1833                 part.dock = &dock;
1834                 part.pane = dock.panes.Item(pane_i-1);
1835                 part.button = NULL;
1836                 part.orientation = (orientation==wxHORIZONTAL) ? wxVERTICAL:wxHORIZONTAL;
1837                 part.cont_sizer = dock_sizer;
1838                 part.sizer_item = sizer_item;
1839                 uiparts.Add(part);
1840             }
1841
1842             LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only);
1843         }
1844     }
1845
1846     if (dock.dock_direction == wxAUI_DOCK_CENTER || has_maximized_pane)
1847         sizer_item = cont->Add(dock_sizer, 1, wxEXPAND);
1848     else
1849         sizer_item = cont->Add(dock_sizer, 0, wxEXPAND);
1850
1851     part.type = wxAuiDockUIPart::typeDock;
1852     part.dock = &dock;
1853     part.pane = NULL;
1854     part.button = NULL;
1855     part.orientation = orientation;
1856     part.cont_sizer = cont;
1857     part.sizer_item = sizer_item;
1858     uiparts.Add(part);
1859
1860     if (dock.IsHorizontal())
1861         cont->SetItemMinSize(dock_sizer, 0, dock.size);
1862     else
1863         cont->SetItemMinSize(dock_sizer, dock.size, 0);
1864
1865     //  top and left docks have a sash after them
1866     if (!m_has_maximized &&
1867         !dock.fixed &&
1868           (dock.dock_direction == wxAUI_DOCK_TOP ||
1869            dock.dock_direction == wxAUI_DOCK_LEFT))
1870     {
1871         sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
1872
1873         part.type = wxAuiDockUIPart::typeDockSizer;
1874         part.dock = &dock;
1875         part.pane = NULL;
1876         part.button = NULL;
1877         part.orientation = orientation;
1878         part.cont_sizer = cont;
1879         part.sizer_item = sizer_item;
1880         uiparts.Add(part);
1881     }
1882 }
1883
1884 wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
1885                                  wxAuiDockInfoArray& docks,
1886                                  wxAuiDockUIPartArray& uiparts,
1887                                  bool spacer_only)
1888 {
1889     wxBoxSizer* container = new wxBoxSizer(wxVERTICAL);
1890
1891     int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
1892     int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
1893     wxSize cli_size = m_frame->GetClientSize();
1894     int i, dock_count, pane_count;
1895
1896
1897     // empty all docks out
1898     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
1899     {
1900         wxAuiDockInfo& dock = docks.Item(i);
1901
1902         // empty out all panes, as they will be readded below
1903         dock.panes.Empty();
1904
1905         if (dock.fixed)
1906         {
1907             // always reset fixed docks' sizes, because
1908             // the contained windows may have been resized
1909             dock.size = 0;
1910         }
1911     }
1912
1913
1914     // iterate through all known panes, filing each
1915     // of them into the appropriate dock. If the
1916     // pane does not exist in the dock, add it
1917     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
1918     {
1919         wxAuiPaneInfo& p = panes.Item(i);
1920
1921         // find any docks with the same dock direction, dock layer, and
1922         // dock row as the pane we are working on
1923         wxAuiDockInfo* dock;
1924         wxAuiDockInfoPtrArray arr;
1925         FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row, arr);
1926
1927         if (arr.GetCount() > 0)
1928         {
1929             // found the right dock
1930             dock = arr.Item(0);
1931         }
1932         else
1933         {
1934             // dock was not found, so we need to create a new one
1935             wxAuiDockInfo d;
1936             d.dock_direction = p.dock_direction;
1937             d.dock_layer = p.dock_layer;
1938             d.dock_row = p.dock_row;
1939             docks.Add(d);
1940             dock = &docks.Last();
1941         }
1942
1943
1944         if (p.IsDocked() && p.IsShown())
1945         {
1946             // remove the pane from any existing docks except this one
1947             RemovePaneFromDocks(docks, p, dock);
1948
1949             // pane needs to be added to the dock,
1950             // if it doesn't already exist
1951             if (!FindPaneInDock(*dock, p.window))
1952                 dock->panes.Add(&p);
1953         }
1954         else
1955         {
1956             // remove the pane from any existing docks
1957             RemovePaneFromDocks(docks, p);
1958         }
1959
1960     }
1961
1962     // remove any empty docks
1963     for (i = docks.GetCount()-1; i >= 0; --i)
1964     {
1965         if (docks.Item(i).panes.GetCount() == 0)
1966             docks.RemoveAt(i);
1967     }
1968
1969     // configure the docks further
1970     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
1971     {
1972         wxAuiDockInfo& dock = docks.Item(i);
1973         int j, dock_pane_count = dock.panes.GetCount();
1974
1975         // sort the dock pane array by the pane's
1976         // dock position (dock_pos), in ascending order
1977         dock.panes.Sort(PaneSortFunc);
1978
1979         // for newly created docks, set up their initial size
1980         if (dock.size == 0)
1981         {
1982             int size = 0;
1983
1984             for (j = 0; j < dock_pane_count; ++j)
1985             {
1986                 wxAuiPaneInfo& pane = *dock.panes.Item(j);
1987                 wxSize pane_size = pane.best_size;
1988                 if (pane_size == wxDefaultSize)
1989                     pane_size = pane.min_size;
1990                 if (pane_size == wxDefaultSize)
1991                     pane_size = pane.window->GetSize();
1992
1993                 if (dock.IsHorizontal())
1994                     size = wxMax(pane_size.y, size);
1995                 else
1996                     size = wxMax(pane_size.x, size);
1997             }
1998
1999             // add space for the border (two times), but only
2000             // if at least one pane inside the dock has a pane border
2001             for (j = 0; j < dock_pane_count; ++j)
2002             {
2003                 if (dock.panes.Item(j)->HasBorder())
2004                 {
2005                     size += (pane_border_size*2);
2006                     break;
2007                 }
2008             }
2009
2010             // if pane is on the top or bottom, add the caption height,
2011             // but only if at least one pane inside the dock has a caption
2012             if (dock.IsHorizontal())
2013             {
2014                 for (j = 0; j < dock_pane_count; ++j)
2015                 {
2016                     if (dock.panes.Item(j)->HasCaption())
2017                     {
2018                         size += caption_size;
2019                         break;
2020                     }
2021                 }
2022             }
2023
2024
2025             // new dock's size may not be more than the dock constraint
2026             // parameter specifies.  See SetDockSizeConstraint()
2027
2028             int max_dock_x_size = (int)(m_dock_constraint_x * ((double)cli_size.x));
2029             int max_dock_y_size = (int)(m_dock_constraint_y * ((double)cli_size.y));
2030
2031             if (dock.IsHorizontal())
2032                 size = wxMin(size, max_dock_y_size);
2033             else
2034                 size = wxMin(size, max_dock_x_size);
2035
2036             // absolute minimum size for a dock is 10 pixels
2037             if (size < 10)
2038                 size = 10;
2039
2040             dock.size = size;
2041         }
2042
2043
2044         // determine the dock's minimum size
2045         bool plus_border = false;
2046         bool plus_caption = false;
2047         int dock_min_size = 0;
2048         for (j = 0; j < dock_pane_count; ++j)
2049         {
2050             wxAuiPaneInfo& pane = *dock.panes.Item(j);
2051             if (pane.min_size != wxDefaultSize)
2052             {
2053                 if (pane.HasBorder())
2054                     plus_border = true;
2055                 if (pane.HasCaption())
2056                     plus_caption = true;
2057                 if (dock.IsHorizontal())
2058                 {
2059                     if (pane.min_size.y > dock_min_size)
2060                         dock_min_size = pane.min_size.y;
2061                 }
2062                 else
2063                 {
2064                     if (pane.min_size.x > dock_min_size)
2065                         dock_min_size = pane.min_size.x;
2066                 }
2067             }
2068         }
2069
2070         if (plus_border)
2071             dock_min_size += (pane_border_size*2);
2072         if (plus_caption && dock.IsHorizontal())
2073             dock_min_size += (caption_size);
2074
2075         dock.min_size = dock_min_size;
2076
2077
2078         // if the pane's current size is less than it's
2079         // minimum, increase the dock's size to it's minimum
2080         if (dock.size < dock.min_size)
2081             dock.size = dock.min_size;
2082
2083
2084         // determine the dock's mode (fixed or proportional);
2085         // determine whether the dock has only toolbars
2086         bool action_pane_marked = false;
2087         dock.fixed = true;
2088         dock.toolbar = true;
2089         for (j = 0; j < dock_pane_count; ++j)
2090         {
2091             wxAuiPaneInfo& pane = *dock.panes.Item(j);
2092             if (!pane.IsFixed())
2093                 dock.fixed = false;
2094             if (!pane.IsToolbar())
2095                 dock.toolbar = false;
2096             if (pane.HasFlag(wxAuiPaneInfo::optionDockFixed))
2097                 dock.fixed = true;
2098             if (pane.state & wxAuiPaneInfo::actionPane)
2099                 action_pane_marked = true;
2100         }
2101
2102
2103         // if the dock mode is proportional and not fixed-pixel,
2104         // reassign the dock_pos to the sequential 0, 1, 2, 3;
2105         // e.g. remove gaps like 1, 2, 30, 500
2106         if (!dock.fixed)
2107         {
2108             for (j = 0; j < dock_pane_count; ++j)
2109             {
2110                 wxAuiPaneInfo& pane = *dock.panes.Item(j);
2111                 pane.dock_pos = j;
2112             }
2113         }
2114
2115         // if the dock mode is fixed, and none of the panes
2116         // are being moved right now, make sure the panes
2117         // do not overlap each other.  If they do, we will
2118         // adjust the positions of the panes
2119         if (dock.fixed && !action_pane_marked)
2120         {
2121             wxArrayInt pane_positions, pane_sizes;
2122             GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
2123
2124             int offset = 0;
2125             for (j = 0; j < dock_pane_count; ++j)
2126             {
2127                 wxAuiPaneInfo& pane = *(dock.panes.Item(j));
2128                 pane.dock_pos = pane_positions[j];
2129
2130                 int amount = pane.dock_pos - offset;
2131                 if (amount >= 0)
2132                     offset += amount;
2133                 else
2134                     pane.dock_pos += -amount;
2135
2136                 offset += pane_sizes[j];
2137             }
2138         }
2139     }
2140
2141     // discover the maximum dock layer
2142     int max_layer = 0;
2143     for (i = 0; i < dock_count; ++i)
2144         max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
2145
2146
2147     // clear out uiparts
2148     uiparts.Empty();
2149
2150     // create a bunch of box sizers,
2151     // from the innermost level outwards.
2152     wxSizer* cont = NULL;
2153     wxSizer* middle = NULL;
2154     int layer = 0;
2155     int row, row_count;
2156
2157     for (layer = 0; layer <= max_layer; ++layer)
2158     {
2159         wxAuiDockInfoPtrArray arr;
2160
2161         // find any docks in this layer
2162         FindDocks(docks, -1, layer, -1, arr);
2163
2164         // if there aren't any, skip to the next layer
2165         if (arr.IsEmpty())
2166             continue;
2167
2168         wxSizer* old_cont = cont;
2169
2170         // create a container which will hold this layer's
2171         // docks (top, bottom, left, right)
2172         cont = new wxBoxSizer(wxVERTICAL);
2173
2174
2175         // find any top docks in this layer
2176         FindDocks(docks, wxAUI_DOCK_TOP, layer, -1, arr);
2177         RenumberDockRows(arr);
2178         if (!arr.IsEmpty())
2179         {
2180             for (row = 0, row_count = arr.GetCount(); row < row_count; ++row)
2181                 LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only);
2182         }
2183
2184
2185         // fill out the middle layer (which consists
2186         // of left docks, content area and right docks)
2187
2188         middle = new wxBoxSizer(wxHORIZONTAL);
2189
2190         // find any left docks in this layer
2191         FindDocks(docks, wxAUI_DOCK_LEFT, layer, -1, arr);
2192         RenumberDockRows(arr);
2193         if (!arr.IsEmpty())
2194         {
2195             for (row = 0, row_count = arr.GetCount(); row < row_count; ++row)
2196                 LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
2197         }
2198
2199         // add content dock (or previous layer's sizer
2200         // to the middle
2201         if (!old_cont)
2202         {
2203             // find any center docks
2204             FindDocks(docks, wxAUI_DOCK_CENTER, -1, -1, arr);
2205             if (!arr.IsEmpty())
2206             {
2207                 for (row = 0,row_count = arr.GetCount(); row<row_count; ++row)
2208                    LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
2209             }
2210             else if (!m_has_maximized)
2211             {
2212                 // there are no center docks, add a background area
2213                 wxSizerItem* sizer_item = middle->Add(1,1, 1, wxEXPAND);
2214                 wxAuiDockUIPart part;
2215                 part.type = wxAuiDockUIPart::typeBackground;
2216                 part.pane = NULL;
2217                 part.dock = NULL;
2218                 part.button = NULL;
2219                 part.cont_sizer = middle;
2220                 part.sizer_item = sizer_item;
2221                 uiparts.Add(part);
2222             }
2223         }
2224         else
2225         {
2226             middle->Add(old_cont, 1, wxEXPAND);
2227         }
2228
2229         // find any right docks in this layer
2230         FindDocks(docks, wxAUI_DOCK_RIGHT, layer, -1, arr);
2231         RenumberDockRows(arr);
2232         if (!arr.IsEmpty())
2233         {
2234             for (row = arr.GetCount()-1; row >= 0; --row)
2235                 LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
2236         }
2237
2238         cont->Add(middle, 1, wxEXPAND);
2239
2240
2241
2242         // find any bottom docks in this layer
2243         FindDocks(docks, wxAUI_DOCK_BOTTOM, layer, -1, arr);
2244         RenumberDockRows(arr);
2245         if (!arr.IsEmpty())
2246         {
2247             for (row = arr.GetCount()-1; row >= 0; --row)
2248                 LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only);
2249         }
2250
2251     }
2252
2253     if (!cont)
2254     {
2255         // no sizer available, because there are no docks,
2256         // therefore we will create a simple background area
2257         cont = new wxBoxSizer(wxVERTICAL);
2258         wxSizerItem* sizer_item = cont->Add(1,1, 1, wxEXPAND);
2259         wxAuiDockUIPart part;
2260         part.type = wxAuiDockUIPart::typeBackground;
2261         part.pane = NULL;
2262         part.dock = NULL;
2263         part.button = NULL;
2264         part.cont_sizer = middle;
2265         part.sizer_item = sizer_item;
2266         uiparts.Add(part);
2267     }
2268
2269     container->Add(cont, 1, wxEXPAND);
2270     return container;
2271 }
2272
2273
2274 // SetDockSizeConstraint() allows the dock constraints to be set.  For example,
2275 // specifying values of 0.5, 0.5 will mean that upon dock creation, a dock may
2276 // not be larger than half of the window's size
2277
2278 void wxAuiManager::SetDockSizeConstraint(double width_pct, double height_pct)
2279 {
2280     m_dock_constraint_x = wxMax(0.0, wxMin(1.0, width_pct));
2281     m_dock_constraint_y = wxMax(0.0, wxMin(1.0, height_pct));
2282 }
2283
2284 void wxAuiManager::GetDockSizeConstraint(double* width_pct, double* height_pct) const
2285 {
2286     if (width_pct)
2287         *width_pct = m_dock_constraint_x;
2288
2289     if (height_pct)
2290         *height_pct = m_dock_constraint_y;
2291 }
2292
2293
2294
2295 // Update() updates the layout.  Whenever changes are made to
2296 // one or more panes, this function should be called.  It is the
2297 // external entry point for running the layout engine.
2298
2299 void wxAuiManager::Update()
2300 {
2301     m_hover_button = NULL;
2302
2303     wxSizer* sizer;
2304     int i, pane_count = m_panes.GetCount();
2305
2306
2307     // destroy floating panes which have been
2308     // redocked or are becoming non-floating
2309     for (i = 0; i < pane_count; ++i)
2310     {
2311         wxAuiPaneInfo& p = m_panes.Item(i);
2312
2313         if (!p.IsFloating() && p.frame)
2314         {
2315             // because the pane is no longer in a floating, we need to
2316             // reparent it to m_frame and destroy the floating frame
2317
2318             // reduce flicker
2319             p.window->SetSize(1,1);
2320
2321
2322             // the following block is a workaround for bug #1531361
2323             // (see wxWidgets sourceforge page).  On wxGTK (only), when
2324             // a frame is shown/hidden, a move event unfortunately
2325             // also gets fired.  Because we may be dragging around
2326             // a pane, we need to cancel that action here to prevent
2327             // a spurious crash.
2328             if (m_action_window == p.frame)
2329             {
2330                 if (wxWindow::GetCapture() == m_frame)
2331                     m_frame->ReleaseMouse();
2332                 m_action = actionNone;
2333                 m_action_window = NULL;
2334             }
2335
2336             // hide the frame
2337             if (p.frame->IsShown())
2338                 p.frame->Show(false);
2339
2340             // reparent to m_frame and destroy the pane
2341             if (m_action_window == p.frame)
2342             {
2343                 m_action_window = NULL;
2344             }
2345
2346             p.window->Reparent(m_frame);
2347             p.frame->SetSizer(NULL);
2348             p.frame->Destroy();
2349             p.frame = NULL;
2350         }
2351     }
2352
2353
2354     // delete old sizer first
2355     m_frame->SetSizer(NULL);
2356
2357     // create a layout for all of the panes
2358     sizer = LayoutAll(m_panes, m_docks, m_uiparts, false);
2359
2360     // hide or show panes as necessary,
2361     // and float panes as necessary
2362     for (i = 0; i < pane_count; ++i)
2363     {
2364         wxAuiPaneInfo& p = m_panes.Item(i);
2365
2366         if (p.IsFloating())
2367         {
2368             if (p.frame == NULL)
2369             {
2370                 // we need to create a frame for this
2371                 // pane, which has recently been floated
2372                 wxAuiFloatingFrame* frame = CreateFloatingFrame(m_frame, p);
2373
2374                 // on MSW and Mac, if the owner desires transparent dragging, and
2375                 // the dragging is happening right now, then the floating
2376                 // window should have this style by default
2377                 if (m_action == actionDragFloatingPane &&
2378                     (m_flags & wxAUI_MGR_TRANSPARENT_DRAG))
2379                         frame->SetTransparent(150);
2380
2381                 frame->SetPaneWindow(p);
2382                 p.frame = frame;
2383
2384                 if (p.IsShown() && !frame->IsShown())
2385                     frame->Show();
2386             }
2387             else
2388             {
2389                 // frame already exists, make sure it's position
2390                 // and size reflect the information in wxAuiPaneInfo
2391                 if ((p.frame->GetPosition() != p.floating_pos) || (p.frame->GetSize() != p.floating_size))
2392                 {
2393                     p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
2394                                      p.floating_size.x, p.floating_size.y,
2395                                      wxSIZE_USE_EXISTING);
2396                 /*
2397                     p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
2398                                      wxDefaultCoord, wxDefaultCoord,
2399                                      wxSIZE_USE_EXISTING);
2400                     //p.frame->Move(p.floating_pos.x, p.floating_pos.y);
2401                 */
2402                 }
2403
2404                 if (p.frame->IsShown() != p.IsShown())
2405                     p.frame->Show(p.IsShown());
2406             }
2407         }
2408         else
2409         {
2410             if (p.window->IsShown() != p.IsShown())
2411                 p.window->Show(p.IsShown());
2412         }
2413
2414         // if "active panes" are no longer allowed, clear
2415         // any optionActive values from the pane states
2416         if ((m_flags & wxAUI_MGR_ALLOW_ACTIVE_PANE) == 0)
2417         {
2418             p.state &= ~wxAuiPaneInfo::optionActive;
2419         }
2420     }
2421
2422
2423     // keep track of the old window rectangles so we can
2424     // refresh those windows whose rect has changed
2425     wxAuiRectArray old_pane_rects;
2426     for (i = 0; i < pane_count; ++i)
2427     {
2428         wxRect r;
2429         wxAuiPaneInfo& p = m_panes.Item(i);
2430
2431         if (p.window && p.IsShown() && p.IsDocked())
2432             r = p.rect;
2433
2434         old_pane_rects.Add(r);
2435     }
2436
2437
2438
2439
2440     // apply the new sizer
2441     m_frame->SetSizer(sizer);
2442     m_frame->SetAutoLayout(false);
2443     DoFrameLayout();
2444
2445
2446
2447     // now that the frame layout is done, we need to check
2448     // the new pane rectangles against the old rectangles that
2449     // we saved a few lines above here.  If the rectangles have
2450     // changed, the corresponding panes must also be updated
2451     for (i = 0; i < pane_count; ++i)
2452     {
2453         wxAuiPaneInfo& p = m_panes.Item(i);
2454         if (p.window && p.window->IsShown() && p.IsDocked())
2455         {
2456             if (p.rect != old_pane_rects[i])
2457             {
2458                 p.window->Refresh();
2459                 p.window->Update();
2460             }
2461         }
2462     }
2463
2464
2465     Repaint();
2466
2467     // set frame's minimum size
2468
2469 /*
2470     // N.B. More work needs to be done on frame minimum sizes;
2471     // this is some intresting code that imposes the minimum size,
2472     // but we may want to include a more flexible mechanism or
2473     // options for multiple minimum-size modes, e.g. strict or lax
2474     wxSize min_size = sizer->GetMinSize();
2475     wxSize frame_size = m_frame->GetSize();
2476     wxSize client_size = m_frame->GetClientSize();
2477
2478     wxSize minframe_size(min_size.x+frame_size.x-client_size.x,
2479                          min_size.y+frame_size.y-client_size.y );
2480
2481     m_frame->SetMinSize(minframe_size);
2482
2483     if (frame_size.x < minframe_size.x ||
2484         frame_size.y < minframe_size.y)
2485             sizer->Fit(m_frame);
2486 */
2487 }
2488
2489
2490 // DoFrameLayout() is an internal function which invokes wxSizer::Layout
2491 // on the frame's main sizer, then measures all the various UI items
2492 // and updates their internal rectangles.  This should always be called
2493 // instead of calling m_frame->Layout() directly
2494
2495 void wxAuiManager::DoFrameLayout()
2496 {
2497     m_frame->Layout();
2498
2499     int i, part_count;
2500     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
2501     {
2502         wxAuiDockUIPart& part = m_uiparts.Item(i);
2503
2504         // get the rectangle of the UI part
2505         // originally, this code looked like this:
2506         //    part.rect = wxRect(part.sizer_item->GetPosition(),
2507         //                       part.sizer_item->GetSize());
2508         // this worked quite well, with one exception: the mdi
2509         // client window had a "deferred" size variable
2510         // that returned the wrong size.  It looks like
2511         // a bug in wx, because the former size of the window
2512         // was being returned.  So, we will retrieve the part's
2513         // rectangle via other means
2514
2515
2516         part.rect = part.sizer_item->GetRect();
2517         int flag = part.sizer_item->GetFlag();
2518         int border = part.sizer_item->GetBorder();
2519         if (flag & wxTOP)
2520         {
2521             part.rect.y -= border;
2522             part.rect.height += border;
2523         }
2524         if (flag & wxLEFT)
2525         {
2526             part.rect.x -= border;
2527             part.rect.width += border;
2528         }
2529         if (flag & wxBOTTOM)
2530             part.rect.height += border;
2531         if (flag & wxRIGHT)
2532             part.rect.width += border;
2533
2534
2535         if (part.type == wxAuiDockUIPart::typeDock)
2536             part.dock->rect = part.rect;
2537         if (part.type == wxAuiDockUIPart::typePane)
2538             part.pane->rect = part.rect;
2539     }
2540 }
2541
2542 // GetPanePart() looks up the pane the pane border UI part (or the regular
2543 // pane part if there is no border). This allows the caller to get the exact
2544 // rectangle of the pane in question, including decorations like
2545 // caption and border (if any).
2546
2547 wxAuiDockUIPart* wxAuiManager::GetPanePart(wxWindow* wnd)
2548 {
2549     int i, part_count;
2550     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
2551     {
2552         wxAuiDockUIPart& part = m_uiparts.Item(i);
2553         if (part.type == wxAuiDockUIPart::typePaneBorder &&
2554             part.pane && part.pane->window == wnd)
2555                 return &part;
2556     }
2557     for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
2558     {
2559         wxAuiDockUIPart& part = m_uiparts.Item(i);
2560         if (part.type == wxAuiDockUIPart::typePane &&
2561             part.pane && part.pane->window == wnd)
2562                 return &part;
2563     }
2564     return NULL;
2565 }
2566
2567
2568
2569 // GetDockPixelOffset() is an internal function which returns
2570 // a dock's offset in pixels from the left side of the window
2571 // (for horizontal docks) or from the top of the window (for
2572 // vertical docks).  This value is necessary for calculating
2573 // fixel-pane/toolbar offsets when they are dragged.
2574
2575 int wxAuiManager::GetDockPixelOffset(wxAuiPaneInfo& test)
2576 {
2577     // the only way to accurately calculate the dock's
2578     // offset is to actually run a theoretical layout
2579
2580     int i, part_count, dock_count;
2581     wxAuiDockInfoArray docks;
2582     wxAuiPaneInfoArray panes;
2583     wxAuiDockUIPartArray uiparts;
2584     CopyDocksAndPanes(docks, panes, m_docks, m_panes);
2585     panes.Add(test);
2586
2587     wxSizer* sizer = LayoutAll(panes, docks, uiparts, true);
2588     wxSize client_size = m_frame->GetClientSize();
2589     sizer->SetDimension(0, 0, client_size.x, client_size.y);
2590     sizer->Layout();
2591
2592     for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i)
2593     {
2594         wxAuiDockUIPart& part = uiparts.Item(i);
2595         part.rect = wxRect(part.sizer_item->GetPosition(),
2596                            part.sizer_item->GetSize());
2597         if (part.type == wxAuiDockUIPart::typeDock)
2598             part.dock->rect = part.rect;
2599     }
2600
2601     delete sizer;
2602
2603     for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
2604     {
2605         wxAuiDockInfo& dock = docks.Item(i);
2606         if (test.dock_direction == dock.dock_direction &&
2607             test.dock_layer==dock.dock_layer && test.dock_row==dock.dock_row)
2608         {
2609             if (dock.IsVertical())
2610                 return dock.rect.y;
2611             else
2612                 return dock.rect.x;
2613         }
2614     }
2615
2616     return 0;
2617 }
2618
2619
2620
2621 // ProcessDockResult() is a utility function used by DoDrop() - it checks
2622 // if a dock operation is allowed, the new dock position is copied into
2623 // the target info.  If the operation was allowed, the function returns true.
2624
2625 bool wxAuiManager::ProcessDockResult(wxAuiPaneInfo& target,
2626                                      const wxAuiPaneInfo& new_pos)
2627 {
2628     bool allowed = false;
2629     switch (new_pos.dock_direction)
2630     {
2631         case wxAUI_DOCK_TOP:    allowed = target.IsTopDockable();    break;
2632         case wxAUI_DOCK_BOTTOM: allowed = target.IsBottomDockable(); break;
2633         case wxAUI_DOCK_LEFT:   allowed = target.IsLeftDockable();   break;
2634         case wxAUI_DOCK_RIGHT:  allowed = target.IsRightDockable();  break;
2635     }
2636
2637     if (allowed)
2638         target = new_pos;
2639
2640     return allowed;
2641 }
2642
2643
2644 // DoDrop() is an important function.  It basically takes a mouse position,
2645 // and determines where the pane's new position would be.  If the pane is to be
2646 // dropped, it performs the drop operation using the specified dock and pane
2647 // arrays.  By specifying copied dock and pane arrays when calling, a "what-if"
2648 // scenario can be performed, giving precise coordinates for drop hints.
2649 // If, however, wxAuiManager:m_docks and wxAuiManager::m_panes are specified
2650 // as parameters, the changes will be made to the main state arrays
2651
2652 const int auiInsertRowPixels = 10;
2653 const int auiNewRowPixels = 40;
2654 const int auiLayerInsertPixels = 40;
2655 const int auiLayerInsertOffset = 5;
2656
2657 bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
2658                           wxAuiPaneInfoArray& panes,
2659                           wxAuiPaneInfo& target,
2660                           const wxPoint& pt,
2661                           const wxPoint& offset)
2662 {
2663     wxSize cli_size = m_frame->GetClientSize();
2664
2665     wxAuiPaneInfo drop = target;
2666
2667
2668     // The result should always be shown
2669     drop.Show();
2670
2671
2672     // Check to see if the pane has been dragged outside of the window
2673     // (or near to the outside of the window), if so, dock it along the edge
2674
2675
2676     int layer_insert_offset = auiLayerInsertOffset;
2677     if (drop.IsToolbar())
2678         layer_insert_offset = 0;
2679
2680
2681     if (pt.x < layer_insert_offset &&
2682         pt.x > layer_insert_offset-auiLayerInsertPixels)
2683     {
2684         int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT),
2685                                 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)),
2686                                 GetMaxLayer(docks, wxAUI_DOCK_TOP)) + 1;
2687
2688         if (drop.IsToolbar())
2689             new_layer = auiToolBarLayer;
2690
2691         drop.Dock().Left().
2692              Layer(new_layer).
2693              Row(0).
2694              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
2695         return ProcessDockResult(target, drop);
2696     }
2697     else if (pt.y < layer_insert_offset &&
2698              pt.y > layer_insert_offset-auiLayerInsertPixels)
2699     {
2700         int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
2701                                 GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
2702                                 GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1;
2703
2704         if (drop.IsToolbar())
2705             new_layer = auiToolBarLayer;
2706
2707         drop.Dock().Top().
2708              Layer(new_layer).
2709              Row(0).
2710              Position(pt.x - GetDockPixelOffset(drop) - offset.x);
2711         return ProcessDockResult(target, drop);
2712     }
2713     else if (pt.x >= cli_size.x - layer_insert_offset &&
2714              pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels)
2715     {
2716         int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
2717                                 GetMaxLayer(docks, wxAUI_DOCK_TOP)),
2718                                 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1;
2719
2720         if (drop.IsToolbar())
2721             new_layer = auiToolBarLayer;
2722
2723         drop.Dock().Right().
2724              Layer(new_layer).
2725              Row(0).
2726              Position(pt.y - GetDockPixelOffset(drop) - offset.y);
2727         return ProcessDockResult(target, drop);
2728     }
2729     else if (pt.y >= cli_size.y - layer_insert_offset &&
2730              pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels)
2731     {
2732         int new_layer = wxMax( wxMax( GetMaxLayer(docks, wxAUI_DOCK_BOTTOM),
2733                                       GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
2734                                       GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1;
2735
2736         if (drop.IsToolbar())
2737             new_layer = auiToolBarLayer;
2738
2739         drop.Dock().Bottom().
2740              Layer(new_layer).
2741              Row(0).
2742              Position(pt.x - GetDockPixelOffset(drop) - offset.x);
2743         return ProcessDockResult(target, drop);
2744     }
2745
2746
2747     wxAuiDockUIPart* part = HitTest(pt.x, pt.y);
2748
2749
2750     if (drop.IsToolbar())
2751     {
2752         if (!part || !part->dock)
2753             return false;
2754
2755         // calculate the offset from where the dock begins
2756         // to the point where the user dropped the pane
2757         int dock_drop_offset = 0;
2758         if (part->dock->IsHorizontal())
2759             dock_drop_offset = pt.x - part->dock->rect.x - offset.x;
2760         else
2761             dock_drop_offset = pt.y - part->dock->rect.y - offset.y;
2762
2763
2764         // toolbars may only be moved in and to fixed-pane docks,
2765         // otherwise we will try to float the pane.  Also, the pane
2766         // should float if being dragged over center pane windows
2767         if (!part->dock->fixed || part->dock->dock_direction == wxAUI_DOCK_CENTER)
2768         {
2769             if (m_last_rect.IsEmpty() || m_last_rect.Contains(pt.x, pt.y ))
2770             {
2771                 m_skipping = true;
2772             }
2773             else
2774             {
2775                 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
2776                    (drop.IsFloatable() ||
2777                     (part->dock->dock_direction != wxAUI_DOCK_CENTER &&
2778                      part->dock->dock_direction != wxAUI_DOCK_NONE)))
2779                 {
2780                     drop.Float();
2781                 }
2782
2783                 m_skipping = false;
2784
2785                 return ProcessDockResult(target, drop);
2786             }
2787
2788             drop.Position(pt.x - GetDockPixelOffset(drop) - offset.x);
2789
2790             return ProcessDockResult(target, drop);
2791         }
2792
2793         m_skipping = false;
2794
2795         m_last_rect = part->dock->rect;
2796         m_last_rect.Inflate( 15, 15 );
2797
2798         drop.Dock().
2799              Direction(part->dock->dock_direction).
2800              Layer(part->dock->dock_layer).
2801              Row(part->dock->dock_row).
2802              Position(dock_drop_offset);
2803
2804         if ((
2805             ((pt.y < part->dock->rect.y + 1) && part->dock->IsHorizontal()) ||
2806             ((pt.x < part->dock->rect.x + 1) && part->dock->IsVertical())
2807             ) && part->dock->panes.GetCount() > 1)
2808         {
2809             if ((part->dock->dock_direction == wxAUI_DOCK_TOP) ||
2810                 (part->dock->dock_direction == wxAUI_DOCK_LEFT))
2811             {
2812                 int row = drop.dock_row;
2813                 DoInsertDockRow(panes, part->dock->dock_direction,
2814                                 part->dock->dock_layer,
2815                                 part->dock->dock_row);
2816                 drop.dock_row = row;
2817             }
2818             else
2819             {
2820                 DoInsertDockRow(panes, part->dock->dock_direction,
2821                                 part->dock->dock_layer,
2822                                 part->dock->dock_row+1);
2823                 drop.dock_row = part->dock->dock_row+1;
2824             }
2825         }
2826
2827         if ((
2828             ((pt.y > part->dock->rect.y + part->dock->rect.height - 2 ) && part->dock->IsHorizontal()) ||
2829             ((pt.x > part->dock->rect.x + part->dock->rect.width - 2 ) && part->dock->IsVertical())
2830             ) && part->dock->panes.GetCount() > 1)
2831         {
2832             if ((part->dock->dock_direction == wxAUI_DOCK_TOP) ||
2833                 (part->dock->dock_direction == wxAUI_DOCK_LEFT))
2834             {
2835                 DoInsertDockRow(panes, part->dock->dock_direction,
2836                                 part->dock->dock_layer,
2837                                 part->dock->dock_row+1);
2838                 drop.dock_row = part->dock->dock_row+1;
2839             }
2840             else
2841             {
2842                 int row = drop.dock_row;
2843                 DoInsertDockRow(panes, part->dock->dock_direction,
2844                                 part->dock->dock_layer,
2845                                 part->dock->dock_row);
2846                 drop.dock_row = row;
2847             }
2848         }
2849
2850         return ProcessDockResult(target, drop);
2851     }
2852
2853
2854
2855
2856     if (!part)
2857         return false;
2858
2859     if (part->type == wxAuiDockUIPart::typePaneBorder ||
2860         part->type == wxAuiDockUIPart::typeCaption ||
2861         part->type == wxAuiDockUIPart::typeGripper ||
2862         part->type == wxAuiDockUIPart::typePaneButton ||
2863         part->type == wxAuiDockUIPart::typePane ||
2864         part->type == wxAuiDockUIPart::typePaneSizer ||
2865         part->type == wxAuiDockUIPart::typeDockSizer ||
2866         part->type == wxAuiDockUIPart::typeBackground)
2867     {
2868         if (part->type == wxAuiDockUIPart::typeDockSizer)
2869         {
2870             if (part->dock->panes.GetCount() != 1)
2871                 return false;
2872             part = GetPanePart(part->dock->panes.Item(0)->window);
2873             if (!part)
2874                 return false;
2875         }
2876
2877
2878
2879         // If a normal frame is being dragged over a toolbar, insert it
2880         // along the edge under the toolbar, but over all other panes.
2881         // (this could be done much better, but somehow factoring this
2882         // calculation with the one at the beginning of this function)
2883         if (part->dock && part->dock->toolbar)
2884         {
2885             int layer = 0;
2886
2887             switch (part->dock->dock_direction)
2888             {
2889                 case wxAUI_DOCK_LEFT:
2890                     layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT),
2891                                       GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)),
2892                                       GetMaxLayer(docks, wxAUI_DOCK_TOP));
2893                     break;
2894                 case wxAUI_DOCK_TOP:
2895                     layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
2896                                       GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
2897                                       GetMaxLayer(docks, wxAUI_DOCK_RIGHT));
2898                     break;
2899                 case wxAUI_DOCK_RIGHT:
2900                     layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
2901                                       GetMaxLayer(docks, wxAUI_DOCK_TOP)),
2902                                       GetMaxLayer(docks, wxAUI_DOCK_BOTTOM));
2903                     break;
2904                 case wxAUI_DOCK_BOTTOM:
2905                     layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM),
2906                                       GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
2907                                       GetMaxLayer(docks, wxAUI_DOCK_RIGHT));
2908                     break;
2909             }
2910
2911             DoInsertDockRow(panes, part->dock->dock_direction,
2912                             layer, 0);
2913             drop.Dock().
2914                  Direction(part->dock->dock_direction).
2915                  Layer(layer).Row(0).Position(0);
2916             return ProcessDockResult(target, drop);
2917         }
2918
2919
2920         if (!part->pane)
2921             return false;
2922
2923         part = GetPanePart(part->pane->window);
2924         if (!part)
2925             return false;
2926
2927         bool insert_dock_row = false;
2928         int insert_row = part->pane->dock_row;
2929         int insert_dir = part->pane->dock_direction;
2930         int insert_layer = part->pane->dock_layer;
2931
2932         switch (part->pane->dock_direction)
2933         {
2934             case wxAUI_DOCK_TOP:
2935                 if (pt.y >= part->rect.y &&
2936                     pt.y < part->rect.y+auiInsertRowPixels)
2937                         insert_dock_row = true;
2938                 break;
2939             case wxAUI_DOCK_BOTTOM:
2940                 if (pt.y > part->rect.y+part->rect.height-auiInsertRowPixels &&
2941                     pt.y <= part->rect.y + part->rect.height)
2942                         insert_dock_row = true;
2943                 break;
2944             case wxAUI_DOCK_LEFT:
2945                 if (pt.x >= part->rect.x &&
2946                     pt.x < part->rect.x+auiInsertRowPixels)
2947                         insert_dock_row = true;
2948                 break;
2949             case wxAUI_DOCK_RIGHT:
2950                 if (pt.x > part->rect.x+part->rect.width-auiInsertRowPixels &&
2951                     pt.x <= part->rect.x+part->rect.width)
2952                         insert_dock_row = true;
2953                 break;
2954             case wxAUI_DOCK_CENTER:
2955             {
2956                 // "new row pixels" will be set to the default, but
2957                 // must never exceed 20% of the window size
2958                 int new_row_pixels_x = auiNewRowPixels;
2959                 int new_row_pixels_y = auiNewRowPixels;
2960
2961                 if (new_row_pixels_x > (part->rect.width*20)/100)
2962                     new_row_pixels_x = (part->rect.width*20)/100;
2963
2964                 if (new_row_pixels_y > (part->rect.height*20)/100)
2965                     new_row_pixels_y = (part->rect.height*20)/100;
2966
2967
2968                 // determine if the mouse pointer is in a location that
2969                 // will cause a new row to be inserted.  The hot spot positions
2970                 // are along the borders of the center pane
2971
2972                 insert_layer = 0;
2973                 insert_dock_row = true;
2974                 const wxRect& pr = part->rect;
2975                 if (pt.x >= pr.x && pt.x < pr.x + new_row_pixels_x)
2976                     insert_dir = wxAUI_DOCK_LEFT;
2977                 else if (pt.y >= pr.y && pt.y < pr.y + new_row_pixels_y)
2978                     insert_dir = wxAUI_DOCK_TOP;
2979                 else if (pt.x >= pr.x + pr.width - new_row_pixels_x &&
2980                          pt.x < pr.x + pr.width)
2981                     insert_dir = wxAUI_DOCK_RIGHT;
2982                 else if (pt.y >= pr.y+ pr.height - new_row_pixels_y &&
2983                          pt.y < pr.y + pr.height)
2984                     insert_dir = wxAUI_DOCK_BOTTOM;
2985                 else
2986                     return false;
2987
2988                 insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1;
2989             }
2990         }
2991
2992         if (insert_dock_row)
2993         {
2994             DoInsertDockRow(panes, insert_dir, insert_layer, insert_row);
2995             drop.Dock().Direction(insert_dir).
2996                         Layer(insert_layer).
2997                         Row(insert_row).
2998                         Position(0);
2999             return ProcessDockResult(target, drop);
3000         }
3001
3002         // determine the mouse offset and the pane size, both in the
3003         // direction of the dock itself, and perpendicular to the dock
3004
3005         int offset, size;
3006
3007         if (part->orientation == wxVERTICAL)
3008         {
3009             offset = pt.y - part->rect.y;
3010             size = part->rect.GetHeight();
3011         }
3012         else
3013         {
3014             offset = pt.x - part->rect.x;
3015             size = part->rect.GetWidth();
3016         }
3017
3018         int drop_position = part->pane->dock_pos;
3019
3020         // if we are in the top/left part of the pane,
3021         // insert the pane before the pane being hovered over
3022         if (offset <= size/2)
3023         {
3024             drop_position = part->pane->dock_pos;
3025             DoInsertPane(panes,
3026                          part->pane->dock_direction,
3027                          part->pane->dock_layer,
3028                          part->pane->dock_row,
3029                          part->pane->dock_pos);
3030         }
3031
3032         // if we are in the bottom/right part of the pane,
3033         // insert the pane before the pane being hovered over
3034         if (offset > size/2)
3035         {
3036             drop_position = part->pane->dock_pos+1;
3037             DoInsertPane(panes,
3038                          part->pane->dock_direction,
3039                          part->pane->dock_layer,
3040                          part->pane->dock_row,
3041                          part->pane->dock_pos+1);
3042         }
3043
3044         drop.Dock().
3045              Direction(part->dock->dock_direction).
3046              Layer(part->dock->dock_layer).
3047              Row(part->dock->dock_row).
3048              Position(drop_position);
3049         return ProcessDockResult(target, drop);
3050     }
3051
3052     return false;
3053 }
3054
3055
3056 void wxAuiManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
3057 {
3058     if (!m_hint_wnd || m_hint_fadeamt >= m_hint_fademax)
3059     {
3060         m_hint_fadetimer.Stop();
3061         return;
3062     }
3063
3064     m_hint_fadeamt += 4;
3065     m_hint_wnd->SetTransparent(m_hint_fadeamt);
3066 }
3067
3068 void wxAuiManager::ShowHint(const wxRect& rect)
3069 {
3070     if (m_hint_wnd)
3071     {
3072         // if the hint rect is the same as last time, don't do anything
3073         if (m_last_hint == rect)
3074             return;
3075         m_last_hint = rect;
3076
3077         m_hint_fadeamt = m_hint_fademax;
3078
3079         if ((m_flags & wxAUI_MGR_HINT_FADE)
3080             && !((m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) &&
3081                  (m_flags & wxAUI_MGR_NO_VENETIAN_BLINDS_FADE))
3082             )
3083             m_hint_fadeamt = 0;
3084
3085         m_hint_wnd->SetSize(rect);
3086         m_hint_wnd->SetTransparent(m_hint_fadeamt);
3087
3088         if (!m_hint_wnd->IsShown())
3089             m_hint_wnd->Show();
3090
3091         // if we are dragging a floating pane, set the focus
3092         // back to that floating pane (otherwise it becomes unfocused)
3093         if (m_action == actionDragFloatingPane && m_action_window)
3094             m_action_window->SetFocus();
3095
3096         m_hint_wnd->Raise();
3097
3098
3099         if (m_hint_fadeamt != m_hint_fademax) //  Only fade if we need to
3100         {
3101             // start fade in timer
3102             m_hint_fadetimer.SetOwner(this, 101);
3103             m_hint_fadetimer.Start(5);
3104         }
3105     }
3106     else  // Not using a transparent hint window...
3107     {
3108         if (!(m_flags & wxAUI_MGR_RECTANGLE_HINT))
3109             return;
3110
3111         if (m_last_hint != rect)
3112         {
3113             // remove the last hint rectangle
3114             m_last_hint = rect;
3115             m_frame->Refresh();
3116             m_frame->Update();
3117         }
3118
3119         wxScreenDC screendc;
3120         wxRegion clip(1, 1, 10000, 10000);
3121
3122         // clip all floating windows, so we don't draw over them
3123         int i, pane_count;
3124         for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
3125         {
3126             wxAuiPaneInfo& pane = m_panes.Item(i);
3127
3128             if (pane.IsFloating() &&
3129                 pane.frame->IsShown())
3130             {
3131                 wxRect rect = pane.frame->GetRect();
3132 #ifdef __WXGTK__
3133                 // wxGTK returns the client size, not the whole frame size
3134                 rect.width += 15;
3135                 rect.height += 35;
3136                 rect.Inflate(5);
3137 #endif
3138
3139                 clip.Subtract(rect);
3140             }
3141         }
3142
3143         // As we can only hide the hint by redrawing the managed window, we
3144         // need to clip the region to the managed window too or we get
3145         // nasty redrawn problems.
3146         clip.Intersect(m_frame->GetRect());
3147
3148         screendc.SetClippingRegion(clip);
3149
3150         wxBitmap stipple = wxPaneCreateStippleBitmap();
3151         wxBrush brush(stipple);
3152         screendc.SetBrush(brush);
3153         screendc.SetPen(*wxTRANSPARENT_PEN);
3154
3155         screendc.DrawRectangle(rect.x, rect.y, 5, rect.height);
3156         screendc.DrawRectangle(rect.x+5, rect.y, rect.width-10, 5);
3157         screendc.DrawRectangle(rect.x+rect.width-5, rect.y, 5, rect.height);
3158         screendc.DrawRectangle(rect.x+5, rect.y+rect.height-5, rect.width-10, 5);
3159     }
3160 }
3161
3162 void wxAuiManager::HideHint()
3163 {
3164     // hides a transparent window hint, if there is one
3165     if (m_hint_wnd)
3166     {
3167         if (m_hint_wnd->IsShown())
3168             m_hint_wnd->Show(false);
3169         m_hint_wnd->SetTransparent(0);
3170         m_hint_fadetimer.Stop();
3171         m_last_hint = wxRect();
3172         return;
3173     }
3174
3175     // hides a painted hint by redrawing the frame window
3176     if (!m_last_hint.IsEmpty())
3177     {
3178         m_frame->Refresh();
3179         m_frame->Update();
3180         m_last_hint = wxRect();
3181     }
3182 }
3183
3184
3185
3186 void wxAuiManager::StartPaneDrag(wxWindow* pane_window,
3187                                  const wxPoint& offset)
3188 {
3189     wxAuiPaneInfo& pane = GetPane(pane_window);
3190     if (!pane.IsOk())
3191         return;
3192
3193     if (pane.IsToolbar())
3194     {
3195         m_action = actionDragToolbarPane;
3196     }
3197     else
3198     {
3199         m_action = actionDragFloatingPane;
3200     }
3201
3202     m_action_window = pane_window;
3203     m_action_offset = offset;
3204     m_frame->CaptureMouse();
3205 }
3206
3207
3208 // CalculateHintRect() calculates the drop hint rectangle.  The method
3209 // first calls DoDrop() to determine the exact position the pane would
3210 // be at were if dropped.  If the pane would indeed become docked at the
3211 // specified drop point, the the rectangle hint will be returned in
3212 // screen coordinates.  Otherwise, an empty rectangle is returned.
3213 // |pane_window| is the window pointer of the pane being dragged, |pt| is
3214 // the mouse position, in client coordinates.  |offset| describes the offset
3215 // that the mouse is from the upper-left corner of the item being dragged
3216
3217 wxRect wxAuiManager::CalculateHintRect(wxWindow* pane_window,
3218                                        const wxPoint& pt,
3219                                        const wxPoint& offset)
3220 {
3221     wxRect rect;
3222
3223     // we need to paint a hint rectangle; to find out the exact hint rectangle,
3224     // we will create a new temporary layout and then measure the resulting
3225     // rectangle; we will create a copy of the docking structures (m_dock)
3226     // so that we don't modify the real thing on screen
3227
3228     int i, pane_count, part_count;
3229     wxAuiDockInfoArray docks;
3230     wxAuiPaneInfoArray panes;
3231     wxAuiDockUIPartArray uiparts;
3232     wxAuiPaneInfo hint = GetPane(pane_window);
3233     hint.name = wxT("__HINT__");
3234     hint.PaneBorder(true);
3235     hint.Show();
3236
3237     if (!hint.IsOk())
3238         return rect;
3239
3240     CopyDocksAndPanes(docks, panes, m_docks, m_panes);
3241
3242     // remove any pane already there which bears the same window;
3243     // this happens when you are moving a pane around in a dock
3244     for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
3245     {
3246         if (panes.Item(i).window == pane_window)
3247         {
3248             RemovePaneFromDocks(docks, panes.Item(i));
3249             panes.RemoveAt(i);
3250             break;
3251         }
3252     }
3253
3254     // find out where the new pane would be
3255     if (!DoDrop(docks, panes, hint, pt, offset))
3256     {
3257         return rect;
3258     }
3259
3260     panes.Add(hint);
3261
3262     wxSizer* sizer = LayoutAll(panes, docks, uiparts, true);
3263     wxSize client_size = m_frame->GetClientSize();
3264     sizer->SetDimension(0, 0, client_size.x, client_size.y);
3265     sizer->Layout();
3266
3267     for (i = 0, part_count = uiparts.GetCount();
3268          i < part_count; ++i)
3269     {
3270         wxAuiDockUIPart& part = uiparts.Item(i);
3271
3272         if (part.type == wxAuiDockUIPart::typePaneBorder &&
3273             part.pane && part.pane->name == wxT("__HINT__"))
3274         {
3275             rect = wxRect(part.sizer_item->GetPosition(),
3276                           part.sizer_item->GetSize());
3277             break;
3278         }
3279     }
3280
3281     delete sizer;
3282
3283     if (rect.IsEmpty())
3284     {
3285         return rect;
3286     }
3287
3288     // actually show the hint rectangle on the screen
3289     m_frame->ClientToScreen(&rect.x, &rect.y);
3290
3291     if ( m_frame->GetLayoutDirection() == wxLayout_RightToLeft )
3292     {
3293         // Mirror rectangle in RTL mode
3294         rect.x -= rect.GetWidth();
3295     }
3296
3297     return rect;
3298 }
3299
3300 // DrawHintRect() calculates the hint rectangle by calling
3301 // CalculateHintRect().  If there is a rectangle, it shows it
3302 // by calling ShowHint(), otherwise it hides any hint
3303 // rectangle currently shown
3304 void wxAuiManager::DrawHintRect(wxWindow* pane_window,
3305                                 const wxPoint& pt,
3306                                 const wxPoint& offset)
3307 {
3308     wxRect rect = CalculateHintRect(pane_window, pt, offset);
3309
3310     if (rect.IsEmpty())
3311     {
3312         HideHint();
3313     }
3314     else
3315     {
3316         ShowHint(rect);
3317     }
3318 }
3319
3320 void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd)
3321 {
3322     // try to find the pane
3323     wxAuiPaneInfo& pane = GetPane(wnd);
3324     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3325
3326     if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
3327         pane.frame->SetTransparent(150);
3328 }
3329
3330 void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
3331 {
3332     // try to find the pane
3333     wxAuiPaneInfo& pane = GetPane(wnd);
3334     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3335
3336     wxPoint pt = ::wxGetMousePosition();
3337
3338 #if 0
3339     // Adapt pt to direction
3340     if (dir == wxNORTH)
3341     {
3342         // move to pane's upper border
3343         wxPoint pos( 0,0 );
3344         pos = wnd->ClientToScreen( pos );
3345         pt.y = pos.y;
3346         // and some more pixels for the title bar
3347         pt.y -= 5;
3348     }
3349     else if (dir == wxWEST)
3350     {
3351         // move to pane's left border
3352         wxPoint pos( 0,0 );
3353         pos = wnd->ClientToScreen( pos );
3354         pt.x = pos.x;
3355     }
3356     else if (dir == wxEAST)
3357     {
3358         // move to pane's right border
3359         wxPoint pos( wnd->GetSize().x, 0 );
3360         pos = wnd->ClientToScreen( pos );
3361         pt.x = pos.x;
3362     }
3363     else if (dir == wxSOUTH)
3364     {
3365         // move to pane's bottom border
3366         wxPoint pos( 0, wnd->GetSize().y );
3367         pos = wnd->ClientToScreen( pos );
3368         pt.y = pos.y;
3369     }
3370 #else
3371     wxUnusedVar(dir);
3372 #endif
3373
3374     wxPoint client_pt = m_frame->ScreenToClient(pt);
3375
3376     // calculate the offset from the upper left-hand corner
3377     // of the frame to the mouse pointer
3378     wxPoint frame_pos = pane.frame->GetPosition();
3379     wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y);
3380
3381     // no hint for toolbar floating windows
3382     if (pane.IsToolbar() && m_action == actionDragFloatingPane)
3383     {
3384         wxAuiDockInfoArray docks;
3385         wxAuiPaneInfoArray panes;
3386         wxAuiDockUIPartArray uiparts;
3387         wxAuiPaneInfo hint = pane;
3388
3389         CopyDocksAndPanes(docks, panes, m_docks, m_panes);
3390
3391         // find out where the new pane would be
3392         if (!DoDrop(docks, panes, hint, client_pt))
3393             return;
3394         if (hint.IsFloating())
3395             return;
3396
3397         pane = hint;
3398         m_action = actionDragToolbarPane;
3399         m_action_window = pane.window;
3400
3401         Update();
3402
3403         return;
3404     }
3405
3406
3407     // if a key modifier is pressed while dragging the frame,
3408     // don't dock the window
3409     if (!CanDockPanel(pane))
3410     {
3411         HideHint();
3412         return;
3413     }
3414
3415
3416     DrawHintRect(wnd, client_pt, action_offset);
3417
3418 #ifdef __WXGTK__
3419     // this cleans up some screen artifacts that are caused on GTK because
3420     // we aren't getting the exact size of the window (see comment
3421     // in DrawHintRect)
3422     //Refresh();
3423 #endif
3424
3425
3426     // reduces flicker
3427     m_frame->Update();
3428 }
3429
3430 void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
3431 {
3432     // try to find the pane
3433     wxAuiPaneInfo& pane = GetPane(wnd);
3434     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3435
3436     wxPoint pt = ::wxGetMousePosition();
3437
3438 #if 0
3439     // Adapt pt to direction
3440     if (dir == wxNORTH)
3441     {
3442         // move to pane's upper border
3443         wxPoint pos( 0,0 );
3444         pos = wnd->ClientToScreen( pos );
3445         pt.y = pos.y;
3446         // and some more pixels for the title bar
3447         pt.y -= 10;
3448     }
3449     else if (dir == wxWEST)
3450     {
3451         // move to pane's left border
3452         wxPoint pos( 0,0 );
3453         pos = wnd->ClientToScreen( pos );
3454         pt.x = pos.x;
3455     }
3456     else if (dir == wxEAST)
3457     {
3458         // move to pane's right border
3459         wxPoint pos( wnd->GetSize().x, 0 );
3460         pos = wnd->ClientToScreen( pos );
3461         pt.x = pos.x;
3462     }
3463     else if (dir == wxSOUTH)
3464     {
3465         // move to pane's bottom border
3466         wxPoint pos( 0, wnd->GetSize().y );
3467         pos = wnd->ClientToScreen( pos );
3468         pt.y = pos.y;
3469     }
3470 #else
3471     wxUnusedVar(dir);
3472 #endif
3473
3474     wxPoint client_pt = m_frame->ScreenToClient(pt);
3475
3476     // calculate the offset from the upper left-hand corner
3477     // of the frame to the mouse pointer
3478     wxPoint frame_pos = pane.frame->GetPosition();
3479     wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y);
3480
3481
3482     // if a key modifier is pressed while dragging the frame,
3483     // don't dock the window
3484     if (CanDockPanel(pane))
3485     {
3486         // do the drop calculation
3487         DoDrop(m_docks, m_panes, pane, client_pt, action_offset);
3488     }
3489
3490     // if the pane is still floating, update it's floating
3491     // position (that we store)
3492     if (pane.IsFloating())
3493     {
3494         pane.floating_pos = pane.frame->GetPosition();
3495
3496         if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
3497             pane.frame->SetTransparent(255);
3498     }
3499     else if (m_has_maximized)
3500     {
3501         RestoreMaximizedPane();
3502     }
3503
3504     Update();
3505
3506     HideHint();
3507 }
3508
3509 void wxAuiManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size)
3510 {
3511     // try to find the pane
3512     wxAuiPaneInfo& pane = GetPane(wnd);
3513     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3514
3515     pane.floating_size = size;
3516 }
3517
3518
3519 void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
3520 {
3521     // try to find the pane
3522     wxAuiPaneInfo& pane = GetPane(wnd);
3523     wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3524
3525
3526     // fire pane close event
3527     wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE);
3528     e.SetPane(&pane);
3529     e.SetCanVeto(evt.CanVeto());
3530     ProcessMgrEvent(e);
3531
3532     if (e.GetVeto())
3533     {
3534         evt.Veto();
3535         return;
3536     }
3537     else
3538     {
3539         // close the pane, but check that it
3540         // still exists in our pane array first
3541         // (the event handler above might have removed it)
3542
3543         wxAuiPaneInfo& check = GetPane(wnd);
3544         if (check.IsOk())
3545         {
3546             ClosePane(pane);
3547         }
3548     }
3549 }
3550
3551
3552
3553 void wxAuiManager::OnFloatingPaneActivated(wxWindow* wnd)
3554 {
3555     if ((GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) && GetPane(wnd).IsOk())
3556     {
3557         SetActivePane(m_panes, wnd);
3558         Repaint();
3559     }
3560 }
3561
3562 // OnRender() draws all of the pane captions, sashes,
3563 // backgrounds, captions, grippers, pane borders and buttons.
3564 // It renders the entire user interface.
3565
3566 void wxAuiManager::OnRender(wxAuiManagerEvent& evt)
3567 {
3568     // if the frame is about to be deleted, don't bother
3569     if (!m_frame || wxPendingDelete.Member(m_frame))
3570         return;
3571
3572     wxDC* dc = evt.GetDC();
3573
3574 #ifdef __WXMAC__
3575     dc->Clear() ;
3576 #endif
3577     int i, part_count;
3578     for (i = 0, part_count = m_uiparts.GetCount();
3579          i < part_count; ++i)
3580     {
3581         wxAuiDockUIPart& part = m_uiparts.Item(i);
3582
3583         // don't draw hidden pane items or items that aren't windows
3584         if (part.sizer_item && ((!part.sizer_item->IsWindow() && !part.sizer_item->IsSpacer() && !part.sizer_item->IsSizer()) || !part.sizer_item->IsShown()))
3585             continue;
3586
3587         switch (part.type)
3588         {
3589             case wxAuiDockUIPart::typeDockSizer:
3590             case wxAuiDockUIPart::typePaneSizer:
3591                 m_art->DrawSash(*dc, m_frame, part.orientation, part.rect);
3592                 break;
3593             case wxAuiDockUIPart::typeBackground:
3594                 m_art->DrawBackground(*dc, m_frame, part.orientation, part.rect);
3595                 break;
3596             case wxAuiDockUIPart::typeCaption:
3597                 m_art->DrawCaption(*dc, m_frame, part.pane->caption, part.rect, *part.pane);
3598                 break;
3599             case wxAuiDockUIPart::typeGripper:
3600                 m_art->DrawGripper(*dc, m_frame, part.rect, *part.pane);
3601                 break;
3602             case wxAuiDockUIPart::typePaneBorder:
3603                 m_art->DrawBorder(*dc, m_frame, part.rect, *part.pane);
3604                 break;
3605             case wxAuiDockUIPart::typePaneButton:
3606                 m_art->DrawPaneButton(*dc, m_frame, part.button->button_id,
3607                         wxAUI_BUTTON_STATE_NORMAL, part.rect, *part.pane);
3608                 break;
3609         }
3610     }
3611 }
3612
3613
3614 // Render() fire a render event, which is normally handled by
3615 // wxAuiManager::OnRender().  This allows the render function to
3616 // be overridden via the render event.  This can be useful for paintin
3617 // custom graphics in the main window. Default behavior can be
3618 // invoked in the overridden function by calling OnRender()
3619
3620 void wxAuiManager::Render(wxDC* dc)
3621 {
3622     wxAuiManagerEvent e(wxEVT_AUI_RENDER);
3623     e.SetManager(this);
3624     e.SetDC(dc);
3625     ProcessMgrEvent(e);
3626 }
3627
3628 void wxAuiManager::Repaint(wxDC* dc)
3629 {
3630 #ifdef __WXMAC__
3631     if ( dc == NULL )
3632     {
3633         m_frame->Refresh() ;
3634         m_frame->Update() ;
3635         return ;
3636     }
3637 #endif
3638     int w, h;
3639     m_frame->GetClientSize(&w, &h);
3640
3641     // figure out which dc to use; if one
3642     // has been specified, use it, otherwise
3643     // make a client dc
3644     wxClientDC* client_dc = NULL;
3645     if (!dc)
3646     {
3647         client_dc = new wxClientDC(m_frame);
3648         dc = client_dc;
3649     }
3650
3651     // if the frame has a toolbar, the client area
3652     // origin will not be (0,0).
3653     wxPoint pt = m_frame->GetClientAreaOrigin();
3654     if (pt.x != 0 || pt.y != 0)
3655         dc->SetDeviceOrigin(pt.x, pt.y);
3656
3657     // render all the items
3658     Render(dc);
3659
3660     // if we created a client_dc, delete it
3661     if (client_dc)
3662         delete client_dc;
3663 }
3664
3665 void wxAuiManager::OnPaint(wxPaintEvent& WXUNUSED(event))
3666 {
3667     wxPaintDC dc(m_frame);
3668     Repaint(&dc);
3669 }
3670
3671 void wxAuiManager::OnEraseBackground(wxEraseEvent& event)
3672 {
3673 #ifdef __WXMAC__
3674     event.Skip() ;
3675 #else
3676     wxUnusedVar(event);
3677 #endif
3678 }
3679
3680 void wxAuiManager::OnSize(wxSizeEvent& event)
3681 {
3682     if (m_frame)
3683     {
3684         DoFrameLayout();
3685         Repaint();
3686
3687 #if wxUSE_MDI
3688         if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
3689         {
3690             // for MDI parent frames, this event must not
3691             // be "skipped".  In other words, the parent frame
3692             // must not be allowed to resize the client window
3693             // after we are finished processing sizing changes
3694             return;
3695         }
3696 #endif
3697     }
3698     event.Skip();
3699 }
3700
3701 void wxAuiManager::OnFindManager(wxAuiManagerEvent& evt)
3702 {
3703     // get the window we are managing, if none, return NULL
3704     wxWindow* window = GetManagedWindow();
3705     if (!window)
3706     {
3707         evt.SetManager(NULL);
3708         return;
3709     }
3710
3711     // if we are managing a child frame, get the 'real' manager
3712     if (window->IsKindOf(CLASSINFO(wxAuiFloatingFrame)))
3713     {
3714         wxAuiFloatingFrame* float_frame = static_cast<wxAuiFloatingFrame*>(window);
3715         evt.SetManager(float_frame->GetOwnerManager());
3716         return;
3717     }
3718
3719     // return pointer to ourself
3720     evt.SetManager(this);
3721 }
3722
3723 void wxAuiManager::OnSetCursor(wxSetCursorEvent& event)
3724 {
3725     // determine cursor
3726     wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());
3727     wxCursor cursor = wxNullCursor;
3728
3729     if (part)
3730     {
3731         if (part->type == wxAuiDockUIPart::typeDockSizer ||
3732             part->type == wxAuiDockUIPart::typePaneSizer)
3733         {
3734             // a dock may not be resized if it has a single
3735             // pane which is not resizable
3736             if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock &&
3737                 part->dock->panes.GetCount() == 1 &&
3738                 part->dock->panes.Item(0)->IsFixed())
3739                     return;
3740
3741             // panes that may not be resized do not get a sizing cursor
3742             if (part->pane && part->pane->IsFixed())
3743                 return;
3744
3745             if (part->orientation == wxVERTICAL)
3746                 cursor = wxCursor(wxCURSOR_SIZEWE);
3747             else
3748                 cursor = wxCursor(wxCURSOR_SIZENS);
3749         }
3750         else if (part->type == wxAuiDockUIPart::typeGripper)
3751         {
3752             cursor = wxCursor(wxCURSOR_SIZING);
3753         }
3754     }
3755
3756     event.SetCursor(cursor);
3757 }
3758
3759
3760
3761 void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part,
3762                                         const wxMouseEvent& event)
3763 {
3764     wxAuiDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());
3765     if (!hit_test || !button_ui_part)
3766         return;
3767
3768     int state = wxAUI_BUTTON_STATE_NORMAL;
3769
3770     if (hit_test == button_ui_part)
3771     {
3772         if (event.LeftDown())
3773             state = wxAUI_BUTTON_STATE_PRESSED;
3774         else
3775             state = wxAUI_BUTTON_STATE_HOVER;
3776     }
3777     else
3778     {
3779         if (event.LeftDown())
3780             state = wxAUI_BUTTON_STATE_HOVER;
3781     }
3782
3783     // now repaint the button with hover state
3784     wxClientDC cdc(m_frame);
3785
3786     // if the frame has a toolbar, the client area
3787     // origin will not be (0,0).
3788     wxPoint pt = m_frame->GetClientAreaOrigin();
3789     if (pt.x != 0 || pt.y != 0)
3790         cdc.SetDeviceOrigin(pt.x, pt.y);
3791
3792     if (hit_test->pane)
3793     {
3794         m_art->DrawPaneButton(cdc, m_frame,
3795                   button_ui_part->button->button_id,
3796                   state,
3797                   button_ui_part->rect,
3798                   *hit_test->pane);
3799     }
3800 }
3801
3802 void wxAuiManager::OnLeftDown(wxMouseEvent& event)
3803 {
3804     wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());
3805     if (part)
3806     {
3807         if (part->type == wxAuiDockUIPart::typeDockSizer ||
3808             part->type == wxAuiDockUIPart::typePaneSizer)
3809         {
3810             // Removing this restriction so that a centre pane can be resized
3811             //if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
3812             //    return;
3813
3814             // a dock may not be resized if it has a single
3815             // pane which is not resizable
3816             if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock &&
3817                 part->dock->panes.GetCount() == 1 &&
3818                 part->dock->panes.Item(0)->IsFixed())
3819                     return;
3820
3821             // panes that may not be resized should be ignored here
3822             if (part->pane && part->pane->IsFixed())
3823                 return;
3824
3825             m_action = actionResize;
3826             m_action_part = part;
3827             m_action_hintrect = wxRect();
3828             m_action_start = wxPoint(event.m_x, event.m_y);
3829             m_action_offset = wxPoint(event.m_x - part->rect.x,
3830                                       event.m_y - part->rect.y);
3831             m_frame->CaptureMouse();
3832         }
3833         else if (part->type == wxAuiDockUIPart::typePaneButton)
3834         {
3835             m_action = actionClickButton;
3836             m_action_part = part;
3837             m_action_start = wxPoint(event.m_x, event.m_y);
3838             m_frame->CaptureMouse();
3839
3840             UpdateButtonOnScreen(part, event);
3841         }
3842         else if (part->type == wxAuiDockUIPart::typeCaption ||
3843                   part->type == wxAuiDockUIPart::typeGripper)
3844         {
3845             // if we are managing a wxAuiFloatingFrame window, then
3846             // we are an embedded wxAuiManager inside the wxAuiFloatingFrame.
3847             // We want to initiate a toolbar drag in our owner manager
3848             wxWindow* managed_wnd = GetManagedWindow();
3849
3850             if (part->pane &&
3851                 part->pane->window &&
3852                 managed_wnd &&
3853                 managed_wnd->IsKindOf(CLASSINFO(wxAuiFloatingFrame)))
3854             {
3855                 wxAuiFloatingFrame* floating_frame = (wxAuiFloatingFrame*)managed_wnd;
3856                 wxAuiManager* owner_mgr = floating_frame->GetOwnerManager();
3857                 owner_mgr->StartPaneDrag(part->pane->window,
3858                                              wxPoint(event.m_x - part->rect.x,
3859                                                      event.m_y - part->rect.y));
3860                 return;
3861             }
3862
3863
3864
3865             if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
3866             {
3867                 // set the caption as active
3868                 SetActivePane(m_panes, part->pane->window);
3869                 Repaint();
3870             }
3871
3872             if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
3873                 return;
3874
3875             m_action = actionClickCaption;
3876             m_action_part = part;
3877             m_action_start = wxPoint(event.m_x, event.m_y);
3878             m_action_offset = wxPoint(event.m_x - part->rect.x,
3879                                       event.m_y - part->rect.y);
3880             m_frame->CaptureMouse();
3881         }
3882 #ifdef __WXMAC__
3883         else
3884         {
3885             event.Skip();
3886         }
3887 #endif
3888     }
3889 #ifdef __WXMAC__
3890     else
3891     {
3892         event.Skip();
3893     }
3894 #else
3895     event.Skip();
3896 #endif
3897 }
3898
3899
3900 void wxAuiManager::OnLeftUp(wxMouseEvent& event)
3901 {
3902     if (m_action == actionResize)
3903     {
3904         m_frame->ReleaseMouse();
3905
3906         // get rid of the hint rectangle
3907         wxScreenDC dc;
3908         DrawResizeHint(dc, m_action_hintrect);
3909
3910         // resize the dock or the pane
3911         if (m_action_part && m_action_part->type==wxAuiDockUIPart::typeDockSizer)
3912         {
3913             wxRect& rect = m_action_part->dock->rect;
3914
3915             wxPoint new_pos(event.m_x - m_action_offset.x,
3916                             event.m_y - m_action_offset.y);
3917
3918             switch (m_action_part->dock->dock_direction)
3919             {
3920                 case wxAUI_DOCK_LEFT:
3921                     m_action_part->dock->size = new_pos.x - rect.x;
3922                     break;
3923                 case wxAUI_DOCK_TOP:
3924                     m_action_part->dock->size = new_pos.y - rect.y;
3925                     break;
3926                 case wxAUI_DOCK_RIGHT:
3927                     m_action_part->dock->size = rect.x + rect.width -
3928                                   new_pos.x - m_action_part->rect.GetWidth();
3929                     break;
3930                 case wxAUI_DOCK_BOTTOM:
3931                     m_action_part->dock->size = rect.y + rect.height -
3932                                   new_pos.y - m_action_part->rect.GetHeight();
3933                     break;
3934             }
3935
3936             Update();
3937             Repaint(NULL);
3938         }
3939         else if (m_action_part &&
3940                  m_action_part->type == wxAuiDockUIPart::typePaneSizer)
3941         {
3942             wxAuiDockInfo& dock = *m_action_part->dock;
3943             wxAuiPaneInfo& pane = *m_action_part->pane;
3944
3945             int total_proportion = 0;
3946             int dock_pixels = 0;
3947             int new_pixsize = 0;
3948
3949             int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
3950             int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
3951             int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE);
3952
3953             wxPoint new_pos(event.m_x - m_action_offset.x,
3954                             event.m_y - m_action_offset.y);
3955
3956             // determine the pane rectangle by getting the pane part
3957             wxAuiDockUIPart* pane_part = GetPanePart(pane.window);
3958             wxASSERT_MSG(pane_part,
3959                        wxT("Pane border part not found -- shouldn't happen"));
3960
3961             // determine the new pixel size that the user wants;
3962             // this will help us recalculate the pane's proportion
3963             if (dock.IsHorizontal())
3964                 new_pixsize = new_pos.x - pane_part->rect.x;
3965             else
3966                 new_pixsize = new_pos.y - pane_part->rect.y;
3967
3968             // determine the size of the dock, based on orientation
3969             if (dock.IsHorizontal())
3970                 dock_pixels = dock.rect.GetWidth();
3971             else
3972                 dock_pixels = dock.rect.GetHeight();
3973
3974             // determine the total proportion of all resizable panes,
3975             // and the total size of the dock minus the size of all
3976             // the fixed panes
3977             int i, dock_pane_count = dock.panes.GetCount();
3978             int pane_position = -1;
3979             for (i = 0; i < dock_pane_count; ++i)
3980             {
3981                 wxAuiPaneInfo& p = *dock.panes.Item(i);
3982                 if (p.window == pane.window)
3983                     pane_position = i;
3984
3985                 // while we're at it, subtract the pane sash
3986                 // width from the dock width, because this would
3987                 // skew our proportion calculations
3988                 if (i > 0)
3989                     dock_pixels -= sash_size;
3990
3991                 // also, the whole size (including decorations) of
3992                 // all fixed panes must also be subtracted, because they
3993                 // are not part of the proportion calculation
3994                 if (p.IsFixed())
3995                 {
3996                     if (dock.IsHorizontal())
3997                         dock_pixels -= p.best_size.x;
3998                     else
3999                         dock_pixels -= p.best_size.y;
4000                 }
4001                 else
4002                 {
4003                     total_proportion += p.dock_proportion;
4004                 }
4005             }
4006
4007             // find a pane in our dock to 'steal' space from or to 'give'
4008             // space to -- this is essentially what is done when a pane is
4009             // resized; the pane should usually be the first non-fixed pane
4010             // to the right of the action pane
4011             int borrow_pane = -1;
4012             for (i = pane_position+1; i < dock_pane_count; ++i)
4013             {
4014                 wxAuiPaneInfo& p = *dock.panes.Item(i);
4015                 if (!p.IsFixed())
4016                 {
4017                     borrow_pane = i;
4018                     break;
4019                 }
4020             }
4021
4022
4023             // demand that the pane being resized is found in this dock
4024             // (this assert really never should be raised)
4025             wxASSERT_MSG(pane_position != -1, wxT("Pane not found in dock"));
4026
4027             // prevent division by zero
4028             if (dock_pixels == 0 || total_proportion == 0 || borrow_pane == -1)
4029             {
4030                 m_action = actionNone;
4031                 return;
4032             }
4033
4034             // calculate the new proportion of the pane
4035             int new_proportion = (new_pixsize*total_proportion)/dock_pixels;
4036
4037             // default minimum size
4038             int min_size = 0;
4039
4040             // check against the pane's minimum size, if specified. please note
4041             // that this is not enough to ensure that the minimum size will
4042             // not be violated, because the whole frame might later be shrunk,
4043             // causing the size of the pane to violate it's minimum size
4044             if (pane.min_size.IsFullySpecified())
4045             {
4046                 min_size = 0;
4047
4048                 if (pane.HasBorder())
4049                     min_size += (pane_border_size*2);
4050
4051                 // calculate minimum size with decorations (border,caption)
4052                 if (pane_part->orientation == wxVERTICAL)
4053                 {
4054                     min_size += pane.min_size.y;
4055                     if (pane.HasCaption())
4056                         min_size += caption_size;
4057                 }
4058                 else
4059                 {
4060                     min_size += pane.min_size.x;
4061                 }
4062             }
4063
4064
4065             // for some reason, an arithmatic error somewhere is causing
4066             // the proportion calculations to always be off by 1 pixel;
4067             // for now we will add the 1 pixel on, but we really should
4068             // determine what's causing this.
4069             min_size++;
4070
4071             int min_proportion = (min_size*total_proportion)/dock_pixels;
4072
4073             if (new_proportion < min_proportion)
4074                 new_proportion = min_proportion;
4075
4076
4077
4078             int prop_diff = new_proportion - pane.dock_proportion;
4079
4080             // borrow the space from our neighbor pane to the
4081             // right or bottom (depending on orientation)
4082             dock.panes.Item(borrow_pane)->dock_proportion -= prop_diff;
4083             pane.dock_proportion = new_proportion;
4084
4085             // repaint
4086             Update();
4087             Repaint(NULL);
4088         }
4089     }
4090     else if (m_action == actionClickButton)
4091     {
4092         m_hover_button = NULL;
4093         m_frame->ReleaseMouse();
4094         UpdateButtonOnScreen(m_action_part, event);
4095
4096         // make sure we're still over the item that was originally clicked
4097         if (m_action_part == HitTest(event.GetX(), event.GetY()))
4098         {
4099             // fire button-click event
4100             wxAuiManagerEvent e(wxEVT_AUI_PANE_BUTTON);
4101             e.SetManager(this);
4102             e.SetPane(m_action_part->pane);
4103             e.SetButton(m_action_part->button->button_id);
4104             ProcessMgrEvent(e);
4105         }
4106     }
4107     else if (m_action == actionClickCaption)
4108     {
4109         m_frame->ReleaseMouse();
4110     }
4111     else if (m_action == actionDragFloatingPane)
4112     {
4113         m_frame->ReleaseMouse();
4114     }
4115     else if (m_action == actionDragToolbarPane)
4116     {
4117         m_frame->ReleaseMouse();
4118
4119         wxAuiPaneInfo& pane = GetPane(m_action_window);
4120         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
4121
4122         // save the new positions
4123         wxAuiDockInfoPtrArray docks;
4124         FindDocks(m_docks, pane.dock_direction,
4125                   pane.dock_layer, pane.dock_row, docks);
4126         if (docks.GetCount() == 1)
4127         {
4128             wxAuiDockInfo& dock = *docks.Item(0);
4129
4130             wxArrayInt pane_positions, pane_sizes;
4131             GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
4132
4133             int i, dock_pane_count = dock.panes.GetCount();
4134             for (i = 0; i < dock_pane_count; ++i)
4135                 dock.panes.Item(i)->dock_pos = pane_positions[i];
4136         }
4137
4138         pane.state &= ~wxAuiPaneInfo::actionPane;
4139         Update();
4140     }
4141     else
4142     {
4143         event.Skip();
4144     }
4145
4146     m_action = actionNone;
4147     m_last_mouse_move = wxPoint(); // see comment in OnMotion()
4148 }
4149
4150
4151 void wxAuiManager::OnMotion(wxMouseEvent& event)
4152 {
4153     // sometimes when Update() is called from inside this method,
4154     // a spurious mouse move event is generated; this check will make
4155     // sure that only real mouse moves will get anywhere in this method;
4156     // this appears to be a bug somewhere, and I don't know where the
4157     // mouse move event is being generated.  only verified on MSW
4158
4159     wxPoint mouse_pos = event.GetPosition();
4160     if (m_last_mouse_move == mouse_pos)
4161         return;
4162     m_last_mouse_move = mouse_pos;
4163
4164
4165     if (m_action == actionResize)
4166     {
4167         wxPoint pos = m_action_part->rect.GetPosition();
4168         if (m_action_part->orientation == wxHORIZONTAL)
4169             pos.y = wxMax(0, event.m_y - m_action_offset.y);
4170         else
4171             pos.x = wxMax(0, event.m_x - m_action_offset.x);
4172
4173         wxRect rect(m_frame->ClientToScreen(pos),
4174                     m_action_part->rect.GetSize());
4175
4176         wxScreenDC dc;
4177         if (!m_action_hintrect.IsEmpty())
4178             DrawResizeHint(dc, m_action_hintrect);
4179         DrawResizeHint(dc, rect);
4180         m_action_hintrect = rect;
4181     }
4182     else if (m_action == actionClickCaption)
4183     {
4184         int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
4185         int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
4186
4187         // caption has been clicked.  we need to check if the mouse
4188         // is now being dragged. if it is, we need to change the
4189         // mouse action to 'drag'
4190         if (abs(event.m_x - m_action_start.x) > drag_x_threshold ||
4191             abs(event.m_y - m_action_start.y) > drag_y_threshold)
4192         {
4193             wxAuiPaneInfo* pane_info = m_action_part->pane;
4194
4195             if (!pane_info->IsToolbar())
4196             {
4197                 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
4198                     pane_info->IsFloatable())
4199                 {
4200                     m_action = actionDragFloatingPane;
4201
4202                     // set initial float position
4203                     wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
4204                     pane_info->floating_pos = wxPoint(pt.x - m_action_offset.x,
4205                                                       pt.y - m_action_offset.y);
4206
4207                     // float the window
4208                     if (pane_info->IsMaximized())
4209                         RestorePane(*pane_info);
4210                     pane_info->Float();
4211                     Update();
4212
4213                     m_action_window = pane_info->frame;
4214
4215                     // action offset is used here to make it feel "natural" to the user
4216                     // to drag a docked pane and suddenly have it become a floating frame.
4217                     // Sometimes, however, the offset where the user clicked on the docked
4218                     // caption is bigger than the width of the floating frame itself, so
4219                     // in that case we need to set the action offset to a sensible value
4220                     wxSize frame_size = m_action_window->GetSize();
4221                     if (frame_size.x <= m_action_offset.x)
4222                         m_action_offset.x = 30;
4223                 }
4224             }
4225             else
4226             {
4227                 m_action = actionDragToolbarPane;
4228                 m_action_window = pane_info->window;
4229             }
4230         }
4231     }
4232     else if (m_action == actionDragFloatingPane)
4233     {
4234         if (m_action_window)
4235         {
4236             wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
4237             m_action_window->Move(pt.x - m_action_offset.x,
4238                                 pt.y - m_action_offset.y);
4239         }
4240     }
4241     else if (m_action == actionDragToolbarPane)
4242     {
4243         wxAuiPaneInfo& pane = GetPane(m_action_window);
4244         wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
4245
4246         pane.state |= wxAuiPaneInfo::actionPane;
4247
4248         wxPoint pt = event.GetPosition();
4249         DoDrop(m_docks, m_panes, pane, pt, m_action_offset);
4250
4251         // if DoDrop() decided to float the pane, set up
4252         // the floating pane's initial position
4253         if (pane.IsFloating())
4254         {
4255             wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
4256             pane.floating_pos = wxPoint(pt.x - m_action_offset.x,
4257                                         pt.y - m_action_offset.y);
4258         }
4259
4260         // this will do the actiual move operation;
4261         // in the case that the pane has been floated,
4262         // this call will create the floating pane
4263         // and do the reparenting
4264         Update();
4265
4266         // if the pane has been floated, change the mouse
4267         // action actionDragFloatingPane so that subsequent
4268         // EVT_MOTION() events will move the floating pane
4269         if (pane.IsFloating())
4270         {
4271             pane.state &= ~wxAuiPaneInfo::actionPane;
4272             m_action = actionDragFloatingPane;
4273             m_action_window = pane.frame;
4274         }
4275     }
4276     else
4277     {
4278         wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());
4279         if (part && part->type == wxAuiDockUIPart::typePaneButton)
4280         {
4281             if (part != m_hover_button)
4282             {
4283                 // make the old button normal
4284                 if (m_hover_button)
4285                 {
4286                     UpdateButtonOnScreen(m_hover_button, event);
4287                     Repaint();
4288                 }
4289
4290                 // mouse is over a button, so repaint the
4291                 // button in hover mode
4292                 UpdateButtonOnScreen(part, event);
4293                 m_hover_button = part;
4294
4295             }
4296         }
4297         else
4298         {
4299             if (m_hover_button)
4300             {
4301                 m_hover_button = NULL;
4302                 Repaint();
4303             }
4304             else
4305             {
4306                 event.Skip();
4307             }
4308         }
4309     }
4310 }
4311
4312 void wxAuiManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
4313 {
4314     if (m_hover_button)
4315     {
4316         m_hover_button = NULL;
4317         Repaint();
4318     }
4319 }
4320
4321 void wxAuiManager::OnChildFocus(wxChildFocusEvent& event)
4322 {
4323     // when a child pane has it's focus set, we should change the
4324     // pane's active state to reflect this. (this is only true if
4325     // active panes are allowed by the owner)
4326     if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
4327     {
4328         wxAuiPaneInfo& pane = GetPane(event.GetWindow());
4329         if (pane.IsOk() && (pane.state & wxAuiPaneInfo::optionActive) == 0)
4330         {
4331             SetActivePane(m_panes, event.GetWindow());
4332             m_frame->Refresh();
4333         }
4334     }
4335
4336     event.Skip();
4337 }
4338
4339
4340 // OnPaneButton() is an event handler that is called
4341 // when a pane button has been pressed.
4342 void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)
4343 {
4344     wxASSERT_MSG(evt.pane, wxT("Pane Info passed to wxAuiManager::OnPaneButton must be non-null"));
4345
4346     wxAuiPaneInfo& pane = *(evt.pane);
4347
4348     if (evt.button == wxAUI_BUTTON_CLOSE)
4349     {
4350         // fire pane close event
4351         wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE);
4352         e.SetManager(this);
4353         e.SetPane(evt.pane);
4354         ProcessMgrEvent(e);
4355
4356         if (!e.GetVeto())
4357         {
4358             // close the pane, but check that it
4359             // still exists in our pane array first
4360             // (the event handler above might have removed it)
4361
4362             wxAuiPaneInfo& check = GetPane(pane.window);
4363             if (check.IsOk())
4364             {
4365                 ClosePane(pane);
4366             }
4367
4368             Update();
4369         }
4370     }
4371     else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && !pane.IsMaximized())
4372     {
4373         // fire pane close event
4374         wxAuiManagerEvent e(wxEVT_AUI_PANE_MAXIMIZE);
4375         e.SetManager(this);
4376         e.SetPane(evt.pane);
4377         ProcessMgrEvent(e);
4378
4379         if (!e.GetVeto())
4380         {
4381             MaximizePane(pane);
4382             Update();
4383         }
4384     }
4385     else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && pane.IsMaximized())
4386     {
4387         // fire pane close event
4388         wxAuiManagerEvent e(wxEVT_AUI_PANE_RESTORE);
4389         e.SetManager(this);
4390         e.SetPane(evt.pane);
4391         ProcessMgrEvent(e);
4392
4393         if (!e.GetVeto())
4394         {
4395             RestorePane(pane);
4396             Update();
4397         }
4398     }
4399     else if (evt.button == wxAUI_BUTTON_PIN)
4400     {
4401         if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
4402             pane.IsFloatable())
4403                 pane.Float();
4404         Update();
4405     }
4406 }
4407
4408 #endif // wxUSE_AUI