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