Ticket #10185: wxAuiMinimize.patch

File wxAuiMinimize.patch, 21.5 KB (added by ninjanl, 12 years ago)
  • include/wx/aui/dockart.h

     
    144144    wxBitmap m_inactive_close_bitmap;
    145145    wxBitmap m_inactive_pin_bitmap;
    146146    wxBitmap m_inactive_maximize_bitmap;
     147    wxBitmap m_inactive_minimize_bitmap;
    147148    wxBitmap m_inactive_restore_bitmap;
    148149    wxBitmap m_active_close_bitmap;
    149150    wxBitmap m_active_pin_bitmap;
    150151    wxBitmap m_active_maximize_bitmap;
     152    wxBitmap m_active_minimize_bitmap;
    151153    wxBitmap m_active_restore_bitmap;
    152154    wxPen m_gripper_pen1;
    153155    wxPen m_gripper_pen2;
  • include/wx/aui/framemanager.h

     
    240240    bool IsMovable() const { return HasFlag(optionMovable); }
    241241    bool IsDestroyOnClose() const { return HasFlag(optionDestroyOnClose); }
    242242    bool IsMaximized() const { return HasFlag(optionMaximized); }
     243    bool IsMinimized() const { return HasFlag(optionMinimized); }
    243244    bool HasCaption() const { return HasFlag(optionCaption); }
    244245    bool HasGripper() const { return HasFlag(optionGripper); }
    245246    bool HasBorder() const { return HasFlag(optionPaneBorder); }
     
    283284    wxAuiPaneInfo& Show(bool show = true) { return SetFlag(optionHidden, !show); }
    284285    wxAuiPaneInfo& CaptionVisible(bool visible = true) { return SetFlag(optionCaption, visible); }
    285286    wxAuiPaneInfo& Maximize() { return SetFlag(optionMaximized, true); }
     287    wxAuiPaneInfo& Minimize() { return SetFlag(optionMinimized, true); }
    286288    wxAuiPaneInfo& Restore() { return SetFlag(optionMaximized, false); }
    287289    wxAuiPaneInfo& PaneBorder(bool visible = true) { return SetFlag(optionPaneBorder, visible); }
    288290    wxAuiPaneInfo& Gripper(bool visible = true) { return SetFlag(optionGripper, visible); }
     
    377379        optionGripperTop      = 1 << 15,
    378380        optionMaximized       = 1 << 16,
    379381        optionDockFixed       = 1 << 17,
     382        optionMinimized       = 1 << 18,
    380383
    381384        buttonClose           = 1 << 21,
    382385        buttonMaximize        = 1 << 22,
     
    446449    wxAuiPaneInfo& GetPane(wxWindow* window);
    447450    wxAuiPaneInfo& GetPane(const wxString& name);
    448451    wxAuiPaneInfoArray& GetAllPanes();
     452    void ShowPane(wxWindow *window, bool show = true);
    449453
    450454    bool AddPane(wxWindow* window,
    451455                 const wxAuiPaneInfo& pane_info);
     
    478482    void MaximizePane(wxAuiPaneInfo& pane_info);
    479483    void RestorePane(wxAuiPaneInfo& pane_info);
    480484    void RestoreMaximizedPane();
     485    void MinimizePane(wxAuiPaneInfo& paneInfo);
     486    void RestoreMinimizedPane(wxAuiPaneInfo& paneInfo);
    481487
    482488public:
    483489
     
    582588    void OnChildFocus(wxChildFocusEvent& evt);
    583589    void OnHintFadeTimer(wxTimerEvent& evt);
    584590    void OnFindManager(wxAuiManagerEvent& evt);
     591    void OnRestoreMinimizedPane(wxAuiManagerEvent& event);
    585592
    586593protected:
    587594
     
    617624    wxPoint m_last_mouse_move;   // last mouse move position (see OnMotion)
    618625    bool m_skipping;
    619626    bool m_has_maximized;
     627    bool m_has_minimized;
    620628
    621629    double m_dock_constraint_x;  // 0.0 .. 1.0; max pct of window width a dock can consume
    622630    double m_dock_constraint_y;  // 0.0 .. 1.0; max pct of window height a dock can consume
     
    807815extern WXDLLIMPEXP_AUI const wxEventType wxEVT_AUI_PANE_RESTORE;
    808816extern WXDLLIMPEXP_AUI const wxEventType wxEVT_AUI_RENDER;
    809817extern WXDLLIMPEXP_AUI const wxEventType wxEVT_AUI_FIND_MANAGER;
     818extern WXDLLIMPEXP_AUI const wxEventType wxEVT_AUI_PANE_MINIMIZE;
     819extern WXDLLIMPEXP_AUI const wxEventType wxEVT_AUI_PANE_MIN_RESTORE;
    810820
    811821typedef void (wxEvtHandler::*wxAuiManagerEventFunction)(wxAuiManagerEvent&);
    812822
     
    825835   wx__DECLARE_EVT0(wxEVT_AUI_RENDER, wxAuiManagerEventHandler(func))
    826836#define EVT_AUI_FIND_MANAGER(func) \
    827837   wx__DECLARE_EVT0(wxEVT_AUI_FIND_MANAGER, wxAuiManagerEventHandler(func))
     838#define EVT_AUI_PANE_MINIMIZE(func) \
     839    wx__DECLARE_EVT0(wxEVT_AUI_PANE_MINIMIZE, wxAuiManagerEventHandler(func))
     840#define EVT_AUI_PANE_MIN_RESTORE(func) \
     841    wx__DECLARE_EVT0(wxEVT_AUI_PANE_MIN_RESTORE, wxAuiManagerEventHandler(func))
    828842
    829843#else
    830844
     
    834848%constant wxEventType wxEVT_AUI_PANE_RESTORE;
    835849%constant wxEventType wxEVT_AUI_RENDER;
    836850%constant wxEventType wxEVT_AUI_FIND_MANAGER;
     851%constant wxEventType wxEVT_AUI_PANE_MINIMIZE;
     852%constant wxEventType wxEVT_AUI_PANE_MIN_RESTORE;
    837853
    838854%pythoncode {
    839855    EVT_AUI_PANE_BUTTON = wx.PyEventBinder( wxEVT_AUI_PANE_BUTTON )
     
    842858    EVT_AUI_PANE_RESTORE = wx.PyEventBinder( wxEVT_AUI_PANE_RESTORE )
    843859    EVT_AUI_RENDER = wx.PyEventBinder( wxEVT_AUI_RENDER )
    844860    EVT_AUI_FIND_MANAGER = wx.PyEventBinder( wxEVT_AUI_FIND_MANAGER )
     861    EVT_AUI_PANE_MINIMIZE = wx.PyEventBinder( wxEVT_AUI_PANE_MINIMIZE )
     862    EVT_AUI_PANE_MIN_RESTORE = wx.PyEventBinder( wxEVT_AUI_PANE_MIN_RESTORE )
    845863}
    846864#endif // SWIG
    847865
  • include/wx/aui/restore.xpm

     
     1/* XPM */
     2static char * restore_xpm[] = {
     3"16 15 3 1",
     4"       c None",
     5".      c #000000",
     6"+      c #FFFFFF",
     7"                ",
     8"     .......... ",
     9"     .++++++++. ",
     10"     .......... ",
     11"     .++++++++. ",
     12" ..........+++. ",
     13" .++++++++.+++. ",
     14" ..........+++. ",
     15" .++++++++..... ",
     16" .++++++++.     ",
     17" .++++++++.     ",
     18" .++++++++.     ",
     19" .++++++++.     ",
     20" ..........     ",
     21"                "};
  • samples/aui/auidemo.cpp

     
    854854    // add a bunch of panes
    855855    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    856856                  Name(wxT("test1")).Caption(wxT("Pane Caption")).
    857                   Top());
     857                  Top().MinimizeButton(true));
    858858
    859859    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    860860                  Name(wxT("test2")).Caption(wxT("Client Size Reporter")).
    861861                  Bottom().Position(1).
    862                   CloseButton(true).MaximizeButton(true));
     862                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    863863
    864864    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    865865                  Name(wxT("test3")).Caption(wxT("Client Size Reporter")).
    866866                  Bottom().
    867                   CloseButton(true).MaximizeButton(true));
     867                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    868868
    869869    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    870870                  Name(wxT("test4")).Caption(wxT("Pane Caption")).
     
    877877    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    878878                  Name(wxT("test6")).Caption(wxT("Client Size Reporter")).
    879879                  Right().Row(1).
    880                   CloseButton(true).MaximizeButton(true));
     880                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    881881
    882882    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    883883                  Name(wxT("test7")).Caption(wxT("Client Size Reporter")).
    884884                  Left().Layer(1).
    885                   CloseButton(true).MaximizeButton(true));
     885                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    886886
    887887    m_mgr.AddPane(CreateTreeCtrl(), wxAuiPaneInfo().
    888888                  Name(wxT("test8")).Caption(wxT("Tree Pane")).
    889889                  Left().Layer(1).Position(1).
    890                   CloseButton(true).MaximizeButton(true));
     890                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    891891
    892892    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    893893                  Name(wxT("test9")).Caption(wxT("Min Size 200x100")).
    894894                  BestSize(wxSize(200,100)).MinSize(wxSize(200,100)).
    895895                  Bottom().Layer(1).
    896                   CloseButton(true).MaximizeButton(true));
     896                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    897897
    898898    wxWindow* wnd10 = CreateTextCtrl(wxT("This pane will prompt the user before hiding."));
    899899    m_mgr.AddPane(wnd10, wxAuiPaneInfo().
    900900                  Name(wxT("test10")).Caption(wxT("Text Pane with Hide Prompt")).
    901                   Bottom().Layer(1).Position(1));
     901                  Bottom().Layer(1).Position(1).MinimizeButton(true));
    902902
    903903    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    904904                  Name(wxT("test11")).Caption(wxT("Fixed Pane")).
    905                   Bottom().Layer(1).Position(2).Fixed());
     905                  Bottom().Layer(1).Position(2).Fixed().MinimizeButton(true));
    906906
    907907
    908908    m_mgr.AddPane(new SettingsPanel(this,this), wxAuiPaneInfo().
    909909                  Name(wxT("settings")).Caption(wxT("Dock Manager Settings")).
    910                   Dockable(false).Float().Hide());
     910                  Dockable(false).Float().Hide().MinimizeButton(true));
    911911
    912912    // create some center panes
    913913
    914914    m_mgr.AddPane(CreateGrid(), wxAuiPaneInfo().Name(wxT("grid_content")).
    915                   CenterPane().Hide());
     915                  CenterPane().Hide().MinimizeButton(true));
    916916
    917917    m_mgr.AddPane(CreateTreeCtrl(), wxAuiPaneInfo().Name(wxT("tree_content")).
    918                   CenterPane().Hide());
     918                  CenterPane().Hide().MinimizeButton(true));
    919919
    920920    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().Name(wxT("sizereport_content")).
    921                   CenterPane().Hide());
     921                  CenterPane().Hide().MinimizeButton(true));
    922922
    923923    m_mgr.AddPane(CreateTextCtrl(), wxAuiPaneInfo().Name(wxT("text_content")).
    924                   CenterPane().Hide());
     924                  CenterPane().Hide().MinimizeButton(true));
    925925
    926926    m_mgr.AddPane(CreateHTMLCtrl(), wxAuiPaneInfo().Name(wxT("html_content")).
    927                   CenterPane().Hide());
     927                  CenterPane().Hide().MinimizeButton(true));
    928928
    929929    m_mgr.AddPane(CreateNotebook(), wxAuiPaneInfo().Name(wxT("notebook_content")).
    930930                  CenterPane().PaneBorder(false));
     
    13321332    m_mgr.AddPane(CreateTreeCtrl(), wxAuiPaneInfo().
    13331333                  Caption(wxT("Tree Control")).
    13341334                  Float().FloatingPosition(GetStartPosition()).
    1335                   FloatingSize(wxSize(150,300)));
     1335                  FloatingSize(wxSize(150,300)).MinimizeButton(true));
    13361336    m_mgr.Update();
    13371337}
    13381338
     
    13411341    m_mgr.AddPane(CreateGrid(), wxAuiPaneInfo().
    13421342                  Caption(wxT("Grid")).
    13431343                  Float().FloatingPosition(GetStartPosition()).
    1344                   FloatingSize(wxSize(300,200)));
     1344                  FloatingSize(wxSize(300,200)).MinimizeButton(true));
    13451345    m_mgr.Update();
    13461346}
    13471347
     
    13501350    m_mgr.AddPane(CreateHTMLCtrl(), wxAuiPaneInfo().
    13511351                  Caption(wxT("HTML Control")).
    13521352                  Float().FloatingPosition(GetStartPosition()).
    1353                   FloatingSize(wxSize(300,200)));
     1353                  FloatingSize(wxSize(300,200)).MinimizeButton(true));
    13541354    m_mgr.Update();
    13551355}
    13561356
     
    13601360                  Caption(wxT("Notebook")).
    13611361                  Float().FloatingPosition(GetStartPosition()).
    13621362                  //FloatingSize(300,200).
    1363                   CloseButton(true).MaximizeButton(true));
     1363                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    13641364    m_mgr.Update();
    13651365}
    13661366
     
    13681368{
    13691369    m_mgr.AddPane(CreateTextCtrl(), wxAuiPaneInfo().
    13701370                  Caption(wxT("Text Control")).
    1371                   Float().FloatingPosition(GetStartPosition()));
     1371                  Float().FloatingPosition(GetStartPosition()).MinimizeButton(true));
    13721372    m_mgr.Update();
    13731373}
    13741374
     
    13771377    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    13781378                  Caption(wxT("Client Size Reporter")).
    13791379                  Float().FloatingPosition(GetStartPosition()).
    1380                   CloseButton(true).MaximizeButton(true));
     1380                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    13811381    m_mgr.Update();
    13821382}
    13831383
  • src/aui/auibar.cpp

     
    23892389            }
    23902390            else
    23912391            {
    2392                 wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, m_action_item->id);
    2393                 e.SetEventObject(this);
    2394                 ProcessEvent(e);
    2395                 DoIdleUpdate();
     2392                if ( m_action_item->id == wxID_RESTORE_FRAME )
     2393                {
     2394                    // find aui manager
     2395                    wxAuiManager* manager = wxAuiManager::GetManager(this);
     2396
     2397                    if (!manager)
     2398                        return;
     2399
     2400                    wxAuiPaneInfo pane = manager->GetPane(this);
     2401                    if (pane.IsOk())
     2402                    {
     2403
     2404                        wxAuiManagerEvent e(wxEVT_AUI_PANE_MIN_RESTORE);
     2405
     2406                        e.SetManager(manager);
     2407                        e.SetPane(&pane);
     2408
     2409                        //manager->ProcessMgrEvent(e);
     2410                        manager->ProcessEvent(e);
     2411                        DoIdleUpdate();
     2412                    }
     2413                }
     2414                else
     2415                {
     2416                    wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, m_action_item->id);
     2417                    e.SetEventObject(this);
     2418                    ProcessEvent(e);
     2419                    DoIdleUpdate();
     2420                }
    23962421            }
    23972422        }
    23982423    }
  • src/aui/dockart.cpp

     
    277277        0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0x07, 0xf0,
    278278        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
    279279
     280    static unsigned char minimize_bits[] = {
     281        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xf7, 0xf7, 0x07, 0xf0,
     282        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
     283        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
     284
    280285    static unsigned char restore_bits[]={
    281286        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xf0, 0x1f, 0xf0, 0xdf, 0xf7,
    282287        0x07, 0xf4, 0x07, 0xf4, 0xf7, 0xf5, 0xf7, 0xf1, 0xf7, 0xfd, 0xf7, 0xfd,
     
    304309#endif
    305310
    306311#ifdef __WXMAC__
     312    m_inactive_minimize_bitmap = wxAuiBitmapFromBits(minimize_bits, 16, 16, *wxWHITE);
     313    m_active_minimize_bitmap = wxAuiBitmapFromBits(minimize_bits, 16, 16, *wxWHITE );
     314#else
     315    m_inactive_minimize_bitmap = wxAuiBitmapFromBits(minimize_bits, 16, 16, m_inactive_caption_text_colour);
     316    m_active_minimize_bitmap = wxAuiBitmapFromBits(minimize_bits, 16, 16, m_active_caption_text_colour);
     317#endif
     318
     319#ifdef __WXMAC__
    307320    m_inactive_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE);
    308321    m_active_restore_bitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE );
    309322#else
     
    713726                    bmp = m_inactive_maximize_bitmap;
    714727            }
    715728            break;
     729     case wxAUI_BUTTON_MINIMIZE:
     730        if (pane.state & wxAuiPaneInfo::optionActive)
     731            bmp = m_active_minimize_bitmap;
     732        else
     733            bmp = m_inactive_minimize_bitmap;
     734        break;
    716735    }
    717736
    718737
  • src/aui/framemanager.cpp

     
    3131#include "wx/aui/tabmdi.h"
    3232#include "wx/aui/auibar.h"
    3333
     34#include "wx/aui/restore.xpm"
     35
    3436#ifndef WX_PRECOMP
    3537    #include "wx/panel.h"
    3638    #include "wx/settings.h"
     
    6062DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_RESTORE)
    6163DEFINE_EVENT_TYPE(wxEVT_AUI_RENDER)
    6264DEFINE_EVENT_TYPE(wxEVT_AUI_FIND_MANAGER)
     65DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_MINIMIZE)
     66DEFINE_EVENT_TYPE(wxEVT_AUI_PANE_MIN_RESTORE)
    6367
    6468#ifdef __WXMAC__
    6569    // a few defines to avoid nameclashes
     
    576580    EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus)
    577581    EVT_AUI_FIND_MANAGER(wxAuiManager::OnFindManager)
    578582    EVT_TIMER(101, wxAuiManager::OnHintFadeTimer)
     583    EVT_AUI_PANE_MIN_RESTORE(wxAuiManager::OnRestoreMinimizedPane)
    579584END_EVENT_TABLE()
    580585
    581586
     
    589594    m_flags = flags;
    590595    m_skipping = false;
    591596    m_has_maximized = false;
     597    m_has_minimized = false;
    592598    m_frame = NULL;
    593599    m_dock_constraint_x = 0.3;
    594600    m_dock_constraint_y = 0.3;
     
    942948}
    943949
    944950
     951void wxAuiManager::ShowPane(wxWindow *window,bool show)
     952{
     953    wxAuiPaneInfo &p = GetPane(window);
     954    if (p.IsOk())
     955    {
     956/*        if (p.IsNotebookPage())
     957        {
     958            if (show)
     959            {
     960                wxAuiNotebook* notebook = m_notebooks[p.notebook_id];
     961                int id = notebook->GetPageIndex(p.window);
     962                if (id >= 0)
     963                    notebook->SetSelection(id);
     964                ShowPane(notebook,true);
     965            }
     966        }
     967        else*/
     968            p.Show(show);
     969        if (p.frame)
     970            p.frame->Raise();
     971        Update();
     972    }
     973}
     974
    945975bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
    946976{
    947977    wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed"));
     
    9931023    if (pinfo.dock_proportion == 0)
    9941024        pinfo.dock_proportion = 100000;
    9951025
     1026    if (pinfo.HasMinimizeButton())
     1027    {
     1028        wxAuiPaneButton button;
     1029        button.button_id = wxAUI_BUTTON_MINIMIZE;
     1030        pinfo.buttons.Add(button);
     1031    }
     1032
    9961033    if (pinfo.HasMaximizeButton())
    9971034    {
    9981035        wxAuiPaneButton button;
     
    13121349    // mark ourselves non-maximized
    13131350    pane_info.Restore();
    13141351    m_has_maximized = false;
     1352    m_has_minimized = false;
    13151353
    13161354    // last, show the window
    13171355    if (pane_info.window && !pane_info.window->IsShown())
     
    45504588                pane.Float();
    45514589        Update();
    45524590    }
     4591    //mn this performs the minimizing of a pane
     4592    else if (evt.button == wxAUI_BUTTON_MINIMIZE)
     4593    {
     4594        // fire pane close event
     4595        wxAuiManagerEvent e(wxEVT_AUI_PANE_MINIMIZE);
     4596        e.SetManager(this);
     4597        e.SetPane(evt.pane);
     4598        ProcessMgrEvent(e);
     4599
     4600        if (!e.GetVeto())
     4601        {
     4602            MinimizePane(pane);
     4603            Update();
     4604        }
     4605    }
    45534606}
    45544607
     4608void wxAuiManager::MinimizePane(wxAuiPaneInfo& paneInfo)
     4609{
     4610    if(!paneInfo.IsToolbar())
     4611    {
     4612
     4613        /*
     4614        Basically the idea is this.
     4615
     4616        1) create a toolbar, with a restore button
     4617
     4618        2) place the new toolbar in the toolbar area representative of the location of the pane
     4619        (NORTH/SOUTH/EAST/WEST, central area always to the right)
     4620
     4621        3) Hide the minimizing pane
     4622        */
     4623
     4624        // Create a new toolbar
     4625        // give it the same name as the minimized pane with _min appended
     4626
     4627        wxAuiToolBar* minimize_toolbar = new wxAuiToolBar(GetManagedWindow(), wxID_ANY, wxDefaultPosition, wxDefaultSize,
     4628            wxAUI_TB_DEFAULT_STYLE);
     4629        minimize_toolbar->SetToolBitmapSize(wxSize(16,16));
     4630
     4631        minimize_toolbar->AddTool(wxID_RESTORE_FRAME, paneInfo.name, wxBitmap(restore_xpm), wxT("restore" + paneInfo.caption));
     4632        minimize_toolbar->Realize();
     4633        wxString* toolpanelname = new wxString();
     4634        toolpanelname->Append(paneInfo.name);
     4635        toolpanelname->Append(wxT("_min"));
     4636
     4637        // add the toolbars to the manager
     4638
     4639        switch(paneInfo.dock_direction)
     4640        {
     4641        case wxAUI_DOCK_TOP:
     4642            {   
     4643                AddPane(minimize_toolbar, wxAuiPaneInfo().
     4644                    Name(*toolpanelname).Caption(paneInfo.caption).
     4645                    ToolbarPane().Top().BottomDockable(false).
     4646                    LeftDockable(false).RightDockable(false).DestroyOnClose());
     4647                break;
     4648            }
     4649                case wxAUI_DOCK_BOTTOM:
     4650            {
     4651                AddPane(minimize_toolbar, wxAuiPaneInfo().
     4652                    Name(*toolpanelname).Caption(paneInfo.caption).
     4653                    ToolbarPane().Bottom().TopDockable(false).
     4654                    LeftDockable(false).RightDockable(false).DestroyOnClose());
     4655                break;
     4656            }
     4657                case wxAUI_DOCK_LEFT:
     4658                        {
     4659                                AddPane(minimize_toolbar, wxAuiPaneInfo().
     4660                    Name(*toolpanelname).Caption(paneInfo.caption).
     4661                    ToolbarPane().Left().TopDockable(false).
     4662                    BottomDockable(false).RightDockable(false).DestroyOnClose());
     4663
     4664                                break;
     4665                        }
     4666                case wxAUI_DOCK_RIGHT:
     4667                case wxAUI_DOCK_CENTER:
     4668                        {
     4669                                AddPane(minimize_toolbar, wxAuiPaneInfo().
     4670                    Name(*toolpanelname).Caption(paneInfo.caption).
     4671                    ToolbarPane().Right().TopDockable(false).
     4672                    LeftDockable(false).BottomDockable(false).DestroyOnClose());
     4673                                break;
     4674                        }
     4675                }
     4676
     4677                // mark ourselves minimized
     4678                paneInfo.Minimize();
     4679                paneInfo.Show(false);
     4680                m_has_minimized = true;
     4681                // last, hide the window
     4682                if (paneInfo.window && paneInfo.window->IsShown())
     4683                        paneInfo.window->Show(false);
     4684        }
     4685        Update();
     4686}
     4687
     4688void wxAuiManager::OnRestoreMinimizedPane(wxAuiManagerEvent& evt)
     4689{
     4690        wxAuiPaneInfo& pane = *(evt.pane);
     4691        RestoreMinimizedPane(pane);
     4692}
     4693
     4694void wxAuiManager::RestoreMinimizedPane(wxAuiPaneInfo& paneInfo)
     4695{
     4696        wxString panename = paneInfo.name;
     4697        panename = panename.Left(panename.Length()-4);
     4698        wxAuiPaneInfo pane = GetPane(panename);
     4699        if (pane.IsOk())
     4700        {
     4701                ShowPane(pane.window);
     4702                pane.window->Show();
     4703                pane.Show(true);
     4704                m_has_minimized = false;
     4705                paneInfo.window->Show(false);
     4706                DetachPane(paneInfo.window);
     4707                paneInfo.Show(false);
     4708                paneInfo.Hide();
     4709                Update();
     4710        }
     4711}
     4712
    45554713#endif // wxUSE_AUI