Ticket #10185: wxAuiMinimize_VerticalClockwiseLabel_wx29.patch

File wxAuiMinimize_VerticalClockwiseLabel_wx29.patch, 64.5 KB (added by R.U.10, 7 years ago)
  • include/wx/aui/auibar.h

     
    1919#include "wx/control.h"
    2020#include "wx/sizer.h"
    2121#include "wx/pen.h"
     22#include "wx/image.h"
    2223
    2324class WXDLLIMPEXP_FWD_CORE wxClientDC;
    2425class WXDLLIMPEXP_FWD_AUI wxAuiPaneInfo;
     
    4142    wxAUI_TB_HORIZONTAL    = 1 << 7,
    4243    wxAUI_TB_PLAIN_BACKGROUND = 1 << 8,
    4344    wxAUI_TB_HORZ_TEXT     = (wxAUI_TB_HORZ_LAYOUT | wxAUI_TB_TEXT),
     45    wxAUI_TB_CLOCKWISE     = 1 << 8,
     46    wxAUI_TB_COUNTERCLOCKWISE = 1 << 9,
    4447    wxAUI_ORIENTATION_MASK = (wxAUI_TB_VERTICAL | wxAUI_TB_HORIZONTAL),
     48    wxAUI_TB_VERT_TEXT     = (wxAUI_TB_VERTICAL | wxAUI_TB_CLOCKWISE | wxAUI_TB_TEXT),
    4549    wxAUI_TB_DEFAULT_STYLE = 0
    4650};
    4751
     
    6064    wxAUI_TBTOOL_TEXT_BOTTOM = 3
    6165};
    6266
     67enum wxAuiToolBarToolOrientation
     68{
     69    wxAUI_TBTOOL_HORIZONTAL = 0,            // standard
     70    wxAUI_TBTOOL_VERT_CLOCKWISE = 1,        // rotation of 90° on the right
     71    wxAUI_TBTOOL_VERT_COUNTERCLOCKWISE = 2, // rotation of 90° on the left
     72};
    6373
     74
    6475// aui toolbar event class
    6576
    6677class WXDLLIMPEXP_AUI wxAuiToolBarEvent : public wxNotifyEvent
     
    119130    wxAuiToolBarItem()
    120131    {
    121132        m_window = NULL;
     133        m_clockWiseBmp = m_counterClockWiseBmp = wxNullBitmap;
     134        m_clockWiseDisBmp = m_counterClockWiseDisBmp = wxNullBitmap;
    122135        m_sizerItem = NULL;
    123136        m_spacerPixels = 0;
    124137        m_toolId = 0;
     
    130143        m_sticky = true;
    131144        m_userData = 0;
    132145        m_alignment = wxALIGN_CENTER;
     146        m_orientation = wxAUI_TBTOOL_HORIZONTAL;
    133147    }
    134148
    135149    wxAuiToolBarItem(const wxAuiToolBarItem& c)
     
    164178        m_sticky = c.m_sticky;
    165179        m_userData = c.m_userData;
    166180        m_alignment = c.m_alignment;
     181        m_orientation = c.m_orientation;
    167182    }
    168183
    169184
     
    186201    const wxString& GetLabel() const { return m_label; }
    187202
    188203    void SetBitmap(const wxBitmap& bmp) { m_bitmap = bmp; }
    189     const wxBitmap& GetBitmap() const { return m_bitmap; }
     204    const wxBitmap& GetBitmap() const { return GetRotatedBitmap(false); }
    190205
    191206    void SetDisabledBitmap(const wxBitmap& bmp) { m_disabledBitmap = bmp; }
    192     const wxBitmap& GetDisabledBitmap() const { return m_disabledBitmap; }
     207    const wxBitmap& GetDisabledBitmap() const { return GetRotatedBitmap(true); }
    193208
    194209    void SetHoverBitmap(const wxBitmap& bmp) { m_hoverBitmap = bmp; }
    195210    const wxBitmap& GetHoverBitmap() const { return m_hoverBitmap; }
     
    231246    void SetAlignment(int l) { m_alignment = l; }
    232247    int GetAlignment() const { return m_alignment; }
    233248
     249    void SetOrientation(int a) { m_orientation = a; }
     250    const int GetOrientation() const { return m_orientation; }
     251
    234252private:
    235253
     254    const wxBitmap& GetRotatedBitmap(bool disabled) const
     255    {
     256        const wxBitmap &bitmapToRotate = disabled ? m_disabledBitmap : m_bitmap;
     257        if (!bitmapToRotate.IsOk() || (m_orientation == wxAUI_TBTOOL_HORIZONTAL))
     258            return bitmapToRotate;
     259
     260        wxBitmap *rotatedBitmap = NULL;
     261        bool clockwise = true;
     262        switch(m_orientation)
     263        {
     264        case wxAUI_TBTOOL_VERT_CLOCKWISE:
     265            rotatedBitmap = disabled ? &m_clockWiseDisBmp : &m_clockWiseBmp;
     266                break;
     267        case wxAUI_TBTOOL_VERT_COUNTERCLOCKWISE:
     268            rotatedBitmap = disabled ? &m_counterClockWiseDisBmp : &m_counterClockWiseBmp;
     269            clockwise = false;
     270                break;
     271        }
     272
     273        if (!rotatedBitmap->IsOk())
     274            *rotatedBitmap = wxBitmap(bitmapToRotate.ConvertToImage().Rotate90(clockwise));
     275
     276        return *rotatedBitmap;
     277    }
     278
     279
    236280    wxWindow* m_window;          // item's associated window
    237281    wxString m_label;            // label displayed on the item
    238282    wxBitmap m_bitmap;           // item's bitmap
     
    252296    bool m_sticky;               // overrides button states if true (always active)
    253297    long m_userData;            // user-specified data
    254298    int m_alignment;             // sizer alignment flag, defaults to wxCENTER, may be wxEXPAND or any other
     299
     300    mutable wxBitmap m_clockWiseBmp;              // rotated item's bitmap
     301    mutable wxBitmap m_counterClockWiseBmp;       // rotated item's bitmap
     302    mutable wxBitmap m_clockWiseDisBmp;           // rotated item's disabled bitmap
     303    mutable wxBitmap m_counterClockWiseDisBmp;    // rotated item's disabled bitmap
     304    int m_orientation;                            // tool orientation, default wxAUI_TBTOOL_HORIZONTAL
    255305};
    256306
    257307#ifndef SWIG
     
    277327    virtual wxFont GetFont() = 0;
    278328    virtual void SetTextOrientation(int orientation) = 0;
    279329    virtual int GetTextOrientation() = 0;
     330    virtual void SetOrientation(int orientation) = 0;
     331    virtual int GetOrientation() = 0;
    280332
    281333    virtual void DrawBackground(
    282334                         wxDC& dc,
     
    363415    virtual wxFont GetFont();
    364416    virtual void SetTextOrientation(int orientation);
    365417    virtual int GetTextOrientation();
     418    virtual void SetOrientation(int orientation);
     419    virtual int GetOrientation();
    366420
    367421    virtual void DrawBackground(
    368422                wxDC& dc,
     
    429483    virtual int ShowDropDown(wxWindow* wnd,
    430484                             const wxAuiToolBarItemArray& items);
    431485
     486private:
     487    //Calculates the position of the bitmap and of the text for the given rect
     488    void GetToolsPosition(wxDC& dc,
     489                          const wxAuiToolBarItem& item,
     490                          const wxRect& rect,
     491                          wxRect &bmp_rect,
     492                          wxRect &text_rect);
     493
    432494protected:
    433495
    434496    wxBitmap m_buttonDropDownBmp;
     
    440502    wxFont m_font;
    441503    unsigned int m_flags;
    442504    int m_textOrientation;
     505    int m_orientation;
    443506
    444507    wxPen m_gripperPen1;
    445508    wxPen m_gripperPen2;
     
    520583    wxAuiToolBarItem* AddLabel(int toolId,
    521584                  const wxString& label = wxEmptyString,
    522585                  const int width = -1);
     586    static wxSize GetLabelSize(wxDC& dc,
     587                               const wxString& label,
     588                               bool vertical = false);
    523589    wxAuiToolBarItem* AddControl(wxControl* control,
    524590                    const wxString& label = wxEmptyString);
    525591    wxAuiToolBarItem* AddSeparator();
     
    574640    void SetToolTextOrientation(int orientation);
    575641    int  GetToolTextOrientation() const;
    576642
     643    void SetToolOrientation(int orientation);
     644    int  GetToolOrientation() const;
     645
    577646    void SetToolPacking(int packing);
    578647    int  GetToolPacking() const;
    579648
     
    677746    int m_toolBorderPadding;
    678747    int m_toolTextOrientation;
    679748    int m_overflowState;
     749    int m_toolOrientation;
    680750    bool m_dragging;
    681751    bool m_gripperVisible;
    682752    bool m_overflowVisible;
  • include/wx/aui/dockart.h

     
    150150    wxBitmap m_inactiveCloseBitmap;
    151151    wxBitmap m_inactivePinBitmap;
    152152    wxBitmap m_inactiveMaximizeBitmap;
     153    wxBitmap m_inactiveMinimizeBitmap;
    153154    wxBitmap m_inactiveRestoreBitmap;
    154155    wxBitmap m_activeCloseBitmap;
    155156    wxBitmap m_activePinBitmap;
    156157    wxBitmap m_activeMaximizeBitmap;
     158    wxBitmap m_activeMinimizeBitmap;
    157159    wxBitmap m_activeRestoreBitmap;
    158160    wxPen m_gripperPen1;
    159161    wxPen m_gripperPen2;
  • include/wx/aui/framemanager.h

     
    119119    wxAUI_INSERT_DOCK = 2
    120120};
    121121
     122enum wxAuiPaneMinimizeMode
     123{
     124    wxAUI_MINIMIZE_POS_AUTO     = 0,    // Minimizes the pane on the closest tool bar
     125    wxAUI_MINIMIZE_POS_TOP      = 0x01, // Minimizes the pane on the top tool bar
     126    wxAUI_MINIMIZE_POS_LEFT     = 0x02, // Minimizes the pane on its left tool bar
     127    wxAUI_MINIMIZE_POS_RIGHT    = 0x03, // Minimizes the pane on its right tool bar
     128    wxAUI_MINIMIZE_POS_BOTTOM   = 0x04, // Minimizes the pane on its bottom tool bar
     129    wxAUI_MINIMIZE_POS_MASK     = 0x05, // Mask to filter the position flags
     130    wxAUI_MINIMIZE_CAPT_HIDE    = 0x07, // Hides the caption of the minimized pane
     131    wxAUI_MINIMIZE_CAPT_AUTO    = 0x08, // Displays the caption in the best rotation (horz or clockwise)
     132    wxAUI_MINIMIZE_CAPT_HORZ    = 0x10, // Displays the caption horizontally
     133    wxAUI_MINIMIZE_CAPT_MASK    = 0x18  // Mask to filter the caption flags
     134};
    122135
    123136
    124137
     
    157170        dock_layer = 0;
    158171        dock_row = 0;
    159172        dock_pos = 0;
     173        minimize_mode = wxAUI_MINIMIZE_POS_AUTO|wxAUI_MINIMIZE_CAPT_AUTO;
    160174        floating_pos = wxDefaultPosition;
    161175        floating_size = wxDefaultSize;
    162176        best_size = wxDefaultSize;
     
    182196        dock_layer = c.dock_layer;
    183197        dock_row = c.dock_row;
    184198        dock_pos = c.dock_pos;
     199        minimize_mode = c.minimize_mode;
    185200        best_size = c.best_size;
    186201        min_size = c.min_size;
    187202        max_size = c.max_size;
     
    203218        dock_layer = c.dock_layer;
    204219        dock_row = c.dock_row;
    205220        dock_pos = c.dock_pos;
     221        minimize_mode = c.minimize_mode;
    206222        best_size = c.best_size;
    207223        min_size = c.min_size;
    208224        max_size = c.max_size;
     
    250266    bool IsMovable() const { return HasFlag(optionMovable); }
    251267    bool IsDestroyOnClose() const { return HasFlag(optionDestroyOnClose); }
    252268    bool IsMaximized() const { return HasFlag(optionMaximized); }
     269    bool IsMinimized() const { return HasFlag(optionMinimized); }
    253270    bool HasCaption() const { return HasFlag(optionCaption); }
    254271    bool HasGripper() const { return HasFlag(optionGripper); }
    255272    bool HasBorder() const { return HasFlag(optionPaneBorder); }
    256273    bool HasCloseButton() const { return HasFlag(buttonClose); }
    257274    bool HasMaximizeButton() const { return HasFlag(buttonMaximize); }
    258275    bool HasMinimizeButton() const { return HasFlag(buttonMinimize); }
     276    int GetMinimizeMode() const { return minimize_mode; }
    259277    bool HasPinButton() const { return HasFlag(buttonPin); }
    260278    bool HasGripperTop() const { return HasFlag(optionGripperTop); }
    261279
     
    302320    wxAuiPaneInfo& Show(bool show = true) { return SetFlag(optionHidden, !show); }
    303321    wxAuiPaneInfo& CaptionVisible(bool visible = true) { return SetFlag(optionCaption, visible); }
    304322    wxAuiPaneInfo& Maximize() { return SetFlag(optionMaximized, true); }
     323    wxAuiPaneInfo& Minimize() { return SetFlag(optionMinimized, true); }
     324    wxAuiPaneInfo& MinimizeMode(int mode) { minimize_mode = mode; return *this; }
    305325    wxAuiPaneInfo& Restore() { return SetFlag(optionMaximized, false); }
    306326    wxAuiPaneInfo& PaneBorder(bool visible = true) { return SetFlag(optionPaneBorder, visible); }
    307327    wxAuiPaneInfo& Gripper(bool visible = true) { return SetFlag(optionGripper, visible); }
     
    404424        optionGripperTop      = 1 << 15,
    405425        optionMaximized       = 1 << 16,
    406426        optionDockFixed       = 1 << 17,
     427        optionMinimized       = 1 << 18,
    407428
    408429        buttonClose           = 1 << 21,
    409430        buttonMaximize        = 1 << 22,
     
    431452    int dock_layer;       // layer number (0 = innermost layer)
    432453    int dock_row;         // row number on the docking bar (0 = first row)
    433454    int dock_pos;         // position inside the row (0 = first position)
     455    int minimize_mode;    // position of the minimized pane
    434456
    435457    wxSize best_size;     // size that the layout engine will prefer
    436458    wxSize min_size;      // minimum size the pane window can tolerate
     
    477499    wxAuiPaneInfo& GetPane(wxWindow* window);
    478500    wxAuiPaneInfo& GetPane(const wxString& name);
    479501    wxAuiPaneInfoArray& GetAllPanes();
     502    void ShowPane(wxWindow *window, bool show = true);
    480503
    481504    bool AddPane(wxWindow* window,
    482505                 const wxAuiPaneInfo& paneInfo);
     
    509532    void MaximizePane(wxAuiPaneInfo& paneInfo);
    510533    void RestorePane(wxAuiPaneInfo& paneInfo);
    511534    void RestoreMaximizedPane();
     535    void MinimizePane(wxAuiPaneInfo& paneInfo);
     536    void RestoreMinimizedPane(wxAuiPaneInfo& paneInfo);
    512537
    513538public:
    514539
     
    617642    void OnChildFocus(wxChildFocusEvent& evt);
    618643    void OnHintFadeTimer(wxTimerEvent& evt);
    619644    void OnFindManager(wxAuiManagerEvent& evt);
     645    void OnRestoreMinimizedPane(wxAuiManagerEvent& event);
    620646
    621647protected:
    622648
     
    653679    int  m_currentDragItem;
    654680    bool m_skipping;
    655681    bool m_hasMaximized;
     682    bool m_has_minimized;
    656683
    657684    double m_dockConstraintX;  // 0.0 .. 1.0; max pct of window width a dock can consume
    658685    double m_dockConstraintY;  // 0.0 .. 1.0; max pct of window height a dock can consume
     
    844871wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_ACTIVATED, wxAuiManagerEvent );
    845872wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_RENDER, wxAuiManagerEvent );
    846873wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_FIND_MANAGER, wxAuiManagerEvent );
     874wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_MINIMIZE, wxAuiManagerEvent );
     875wxDECLARE_EXPORTED_EVENT( WXDLLIMPEXP_AUI, wxEVT_AUI_PANE_MIN_RESTORE, wxAuiManagerEvent );
    847876
    848877typedef void (wxEvtHandler::*wxAuiManagerEventFunction)(wxAuiManagerEvent&);
    849878
     
    864893   wx__DECLARE_EVT0(wxEVT_AUI_RENDER, wxAuiManagerEventHandler(func))
    865894#define EVT_AUI_FIND_MANAGER(func) \
    866895   wx__DECLARE_EVT0(wxEVT_AUI_FIND_MANAGER, wxAuiManagerEventHandler(func))
     896#define EVT_AUI_PANE_MINIMIZE(func) \
     897    wx__DECLARE_EVT0(wxEVT_AUI_PANE_MINIMIZE, wxAuiManagerEventHandler(func))
     898#define EVT_AUI_PANE_MIN_RESTORE(func) \
     899    wx__DECLARE_EVT0(wxEVT_AUI_PANE_MIN_RESTORE, wxAuiManagerEventHandler(func))
    867900
    868901#else
    869902
     
    874907%constant wxEventType wxEVT_AUI_PANE_ACTIVATED;
    875908%constant wxEventType wxEVT_AUI_RENDER;
    876909%constant wxEventType wxEVT_AUI_FIND_MANAGER;
     910%constant wxEventType wxEVT_AUI_PANE_MINIMIZE;
     911%constant wxEventType wxEVT_AUI_PANE_MIN_RESTORE;
    877912
    878913%pythoncode {
    879914    EVT_AUI_PANE_BUTTON = wx.PyEventBinder( wxEVT_AUI_PANE_BUTTON )
     
    883918    EVT_AUI_PANE_ACTIVATED = wx.PyEventBinder( wxEVT_AUI_PANE_ACTIVATED )
    884919    EVT_AUI_RENDER = wx.PyEventBinder( wxEVT_AUI_RENDER )
    885920    EVT_AUI_FIND_MANAGER = wx.PyEventBinder( wxEVT_AUI_FIND_MANAGER )
     921    EVT_AUI_PANE_MINIMIZE = wx.PyEventBinder( wxEVT_AUI_PANE_MINIMIZE )
     922    EVT_AUI_PANE_MIN_RESTORE = wx.PyEventBinder( wxEVT_AUI_PANE_MIN_RESTORE )
    886923}
    887924#endif // SWIG
    888925
  • 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"                "};
  • interface/wx/aui/framemanager.h

     
    5555};
    5656
    5757/**
     58    Available flags for the function MinimizeMode().
     59*/
     60enum wxAuiPaneMinimizeMode
     61{
     62    wxAUI_MINIMIZE_POS_AUTO     = 0,    ///< Minimizes the pane on the closest tool bar
     63    wxAUI_MINIMIZE_POS_TOP      = 0x01, ///< Minimizes the pane on the top tool bar
     64    wxAUI_MINIMIZE_POS_LEFT     = 0x02, ///< Minimizes the pane on its left tool bar
     65    wxAUI_MINIMIZE_POS_RIGHT    = 0x03, ///< Minimizes the pane on its right tool bar
     66    wxAUI_MINIMIZE_POS_BOTTOM   = 0x04, ///< Minimizes the pane on its bottom tool bar
     67    wxAUI_MINIMIZE_POS_MASK     = 0x05, ///< Mask to filter the position flags
     68    wxAUI_MINIMIZE_CAPT_HIDE    = 0x07, ///< Hides the caption of the minimized pane
     69    wxAUI_MINIMIZE_CAPT_AUTO    = 0x08, ///< Displays the caption in the best rotation (horizontal or clockwise)
     70    wxAUI_MINIMIZE_CAPT_HORZ    = 0x10, ///< Displays the caption horizontally
     71    wxAUI_MINIMIZE_CAPT_MASK    = 0x18  ///< Mask to filter the caption flags
     72};
     73
     74
     75
     76/**
    5877    @class wxAuiManager
    5978
    6079    wxAuiManager is the central class of the wxAUI class framework.
     
    553572    //@}
    554573
    555574    /**
     575        GetMinimizeMode() returns the flags defined with the function MinimizeMode().
     576        The flags can be filtered with the following masks:
     577        @li wxAUI_MINIMIZE_POS_MASK: Filters the position flags.
     578        @li wxAUI_MINIMIZE_CAPT_MASK: Filters the caption flags.
     579    */
     580    int GetMinimizeMode() const;
     581
     582    /**
    556583        Gripper() indicates that a gripper should be drawn for the pane.
    557584    */
    558585    wxAuiPaneInfo& Gripper(bool visible = true);
     
    762789    wxAuiPaneInfo& MinimizeButton(bool visible = true);
    763790
    764791    /**
     792        Sets the expected minimized mode if the MinimizeButton() is visible.
     793
     794        The minimized pane can have a specific position in the work space:
     795       
     796        @li wxAUI_MINIMIZE_POS_AUTO: Minimizes the pane on the closest tool bar
     797        @li wxAUI_MINIMIZE_POS_TOP: Minimizes the pane on the top tool bar
     798        @li wxAUI_MINIMIZE_POS_LEFT: Minimizes the pane on its left tool bar
     799        @li wxAUI_MINIMIZE_POS_RIGHT: Minimizes the pane on its right tool bar
     800        @li wxAUI_MINIMIZE_POS_BOTTOM: Minimizes the pane on its bottom tool bar
     801       
     802        The caption of the minimized pane can be displayed in different modes:
     803       
     804        @li wxAUI_MINIMIZE_CAPT_HIDE: Hides the caption of the minimized pane
     805        @li wxAUI_MINIMIZE_CAPT_AUTO: Displays the caption in the best rotation
     806        (horizontal in the top and in the bottom tool bar or clockwise in the right
     807        and in the left tool bar)
     808        @li wxAUI_MINIMIZE_CAPT_HORZ: Displays the caption horizontally
     809    */
     810    wxAuiPaneInfo& MinimizeMode(int mode);
     811
     812    /**
    765813        Movable indicates whether a frame can be moved.
    766814    */
    767815    wxAuiPaneInfo& Movable(bool b = true);
  • samples/aui/auidemo.cpp

     
    8989        ID_Settings,
    9090        ID_CustomizeToolbar,
    9191        ID_DropDownToolbarItem,
     92        ID_MinimizePosAuto,
     93        ID_MinimizePosTop,
     94        ID_MinimizePosLeft,
     95        ID_MinimizePosRight,
     96        ID_MinimizePosBottom,
     97        ID_MinimizeCaptAuto,
     98        ID_MinimizeCaptHorz,
     99        ID_MinimizeCaptHide,
    92100        ID_NotebookNoCloseButton,
    93101        ID_NotebookCloseButton,
    94102        ID_NotebookCloseButtonAll,
     
    161169    void OnGradient(wxCommandEvent& evt);
    162170    void OnToolbarResizing(wxCommandEvent& evt);
    163171    void OnManagerFlag(wxCommandEvent& evt);
     172    void OnMinimizePosition(wxCommandEvent& evt);
     173    void OnMinimizeCaption(wxCommandEvent& evt);
    164174    void OnNotebookFlag(wxCommandEvent& evt);
    165175    void OnUpdateUI(wxUpdateUIEvent& evt);
    166176
     
    596606    EVT_MENU(ID_TransparentDrag, MyFrame::OnManagerFlag)
    597607    EVT_MENU(ID_LiveUpdate, MyFrame::OnManagerFlag)
    598608    EVT_MENU(ID_AllowActivePane, MyFrame::OnManagerFlag)
     609    EVT_MENU(ID_MinimizePosAuto, MyFrame::OnMinimizePosition)
     610    EVT_MENU(ID_MinimizePosTop, MyFrame::OnMinimizePosition)
     611    EVT_MENU(ID_MinimizePosLeft, MyFrame::OnMinimizePosition)
     612    EVT_MENU(ID_MinimizePosRight, MyFrame::OnMinimizePosition)
     613    EVT_MENU(ID_MinimizePosBottom, MyFrame::OnMinimizePosition)
     614    EVT_MENU(ID_MinimizeCaptAuto, MyFrame::OnMinimizeCaption)
     615    EVT_MENU(ID_MinimizeCaptHorz, MyFrame::OnMinimizeCaption)
     616    EVT_MENU(ID_MinimizeCaptHide, MyFrame::OnMinimizeCaption)
    599617    EVT_MENU(ID_NotebookTabFixedWidth, MyFrame::OnNotebookFlag)
    600618    EVT_MENU(ID_NotebookNoCloseButton, MyFrame::OnNotebookFlag)
    601619    EVT_MENU(ID_NotebookCloseButton, MyFrame::OnNotebookFlag)
     
    651669                   MyFrame::OnRestorePerspective)
    652670    EVT_AUITOOLBAR_TOOL_DROPDOWN(ID_DropDownToolbarItem, MyFrame::OnDropDownToolbarItem)
    653671    EVT_AUI_PANE_CLOSE(MyFrame::OnPaneClose)
     672    EVT_AUI_PANE_MINIMIZE(MyFrame::OnPaneClose)
    654673    EVT_AUINOTEBOOK_ALLOW_DND(wxID_ANY, MyFrame::OnAllowNotebookDnD)
    655674    EVT_AUINOTEBOOK_PAGE_CLOSE(wxID_ANY, MyFrame::OnNotebookPageClose)
    656675    EVT_AUINOTEBOOK_PAGE_CLOSED(wxID_ANY, MyFrame::OnNotebookPageClosed)
     
    709728    options_menu->AppendCheckItem(ID_AllowActivePane, _("Allow Active Pane"));
    710729    options_menu->AppendCheckItem(ID_LiveUpdate, _("Live Resize Update"));
    711730    options_menu->AppendSeparator();
     731    options_menu->AppendRadioItem(ID_MinimizePosAuto, _("Minimize in mode Auto"))->Check();
     732    options_menu->AppendRadioItem(ID_MinimizePosTop, _("Minimize on Top"));
     733    options_menu->AppendRadioItem(ID_MinimizePosLeft, _("Minimize on the Left"));
     734    options_menu->AppendRadioItem(ID_MinimizePosRight, _("Minimize on the Right"));
     735    options_menu->AppendRadioItem(ID_MinimizePosBottom, _("Minimize at the Bottom"));
     736    options_menu->AppendSeparator();
     737    options_menu->AppendRadioItem(ID_MinimizeCaptAuto, _("Auto Minimized Caption rotation"))->Check();
     738    options_menu->AppendRadioItem(ID_MinimizeCaptHorz, _("Horizontal Minimized Caption"));
     739    options_menu->AppendRadioItem(ID_MinimizeCaptHide, _("Hiden Minimized Caption"));
     740    options_menu->AppendSeparator();
    712741    options_menu->AppendRadioItem(ID_NoGradient, _("No Caption Gradient"));
    713742    options_menu->AppendRadioItem(ID_VerticalGradient, _("Vertical Caption Gradient"));
    714743    options_menu->AppendRadioItem(ID_HorizontalGradient, _("Horizontal Caption Gradient"));
     
    872901    tb5->SetCustomOverflowItems(prepend_items, append_items);
    873902    tb5->Realize();
    874903
     904    wxAuiToolBar* tb6 = new wxAuiToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize,
     905                                         wxAUI_TB_DEFAULT_STYLE | wxAUI_TB_OVERFLOW | wxAUI_TB_VERT_TEXT);
     906    tb6->SetToolBitmapSize(wxSize(48,48));
     907    tb6->AddTool(ID_SampleItem+35, wxT("Clockwise 1"), wxArtProvider::GetBitmap(wxART_ERROR, wxART_OTHER, wxSize(16,16)));
     908    tb6->AddSeparator();
     909    tb6->AddTool(ID_SampleItem+36, wxT("Clockwise 2"), wxArtProvider::GetBitmap(wxART_QUESTION, wxART_OTHER, wxSize(16,16)));
     910    tb6->AddTool(ID_DropDownToolbarItem, wxT("Clockwise 3"), wxArtProvider::GetBitmap(wxART_WARNING, wxART_OTHER, wxSize(16,16)));
     911    tb6->SetCustomOverflowItems(prepend_items, append_items);
     912    tb6->SetToolDropDown(ID_DropDownToolbarItem, true);
     913    tb6->Realize();
     914
    875915    // add a bunch of panes
    876916    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    877917                  Name(wxT("test1")).Caption(wxT("Pane Caption")).
    878                   Top());
     918                  Top().MinimizeButton(true));
    879919
    880920    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    881921                  Name(wxT("test2")).Caption(wxT("Client Size Reporter")).
    882922                  Bottom().Position(1).
    883                   CloseButton(true).MaximizeButton(true));
     923                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    884924
    885925    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    886926                  Name(wxT("test3")).Caption(wxT("Client Size Reporter")).
    887927                  Bottom().
    888                   CloseButton(true).MaximizeButton(true));
     928                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    889929
    890930    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    891931                  Name(wxT("test4")).Caption(wxT("Pane Caption")).
     
    898938    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    899939                  Name(wxT("test6")).Caption(wxT("Client Size Reporter")).
    900940                  Right().Row(1).
    901                   CloseButton(true).MaximizeButton(true));
     941                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    902942
    903943    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    904944                  Name(wxT("test7")).Caption(wxT("Client Size Reporter")).
    905945                  Left().Layer(1).
    906                   CloseButton(true).MaximizeButton(true));
     946                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    907947
    908948    m_mgr.AddPane(CreateTreeCtrl(), wxAuiPaneInfo().
    909949                  Name(wxT("test8")).Caption(wxT("Tree Pane")).
    910950                  Left().Layer(1).Position(1).
    911                   CloseButton(true).MaximizeButton(true));
     951                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    912952
    913953    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    914954                  Name(wxT("test9")).Caption(wxT("Min Size 200x100")).
    915955                  BestSize(wxSize(200,100)).MinSize(wxSize(200,100)).
    916956                  Bottom().Layer(1).
    917                   CloseButton(true).MaximizeButton(true));
     957                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    918958
    919959    wxWindow* wnd10 = CreateTextCtrl(wxT("This pane will prompt the user before hiding."));
    920960
     
    926966
    927967    m_mgr.AddPane(wnd10, wxAuiPaneInfo().
    928968                  Name(wxT("test10")).Caption(wxT("Text Pane with Hide Prompt")).
    929                   Bottom().Layer(1).Position(1).
     969                  Bottom().Layer(1).Position(1).MinimizeButton(true).
    930970                  Icon(wxArtProvider::GetBitmap(wxART_WARNING,
    931971                                                wxART_OTHER,
    932972                                                wxSize(iconSize, iconSize))));
    933973
    934974    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    935975                  Name(wxT("test11")).Caption(wxT("Fixed Pane")).
    936                   Bottom().Layer(1).Position(2).Fixed());
     976                  Bottom().Layer(1).Position(2).Fixed().MinimizeButton(true));
    937977
    938978
    939979    m_mgr.AddPane(new SettingsPanel(this,this), wxAuiPaneInfo().
    940980                  Name(wxT("settings")).Caption(wxT("Dock Manager Settings")).
    941                   Dockable(false).Float().Hide());
     981                  Dockable(false).Float().Hide().MinimizeButton(true));
    942982
    943983    // create some center panes
    944984
    945985    m_mgr.AddPane(CreateGrid(), wxAuiPaneInfo().Name(wxT("grid_content")).
    946                   CenterPane().Hide());
     986                  CenterPane().Hide().MinimizeButton(true));
    947987
    948988    m_mgr.AddPane(CreateTreeCtrl(), wxAuiPaneInfo().Name(wxT("tree_content")).
    949                   CenterPane().Hide());
     989                  CenterPane().Hide().MinimizeButton(true));
    950990
    951991    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().Name(wxT("sizereport_content")).
    952                   CenterPane().Hide());
     992                  CenterPane().Hide().MinimizeButton(true));
    953993
    954994    m_mgr.AddPane(CreateTextCtrl(), wxAuiPaneInfo().Name(wxT("text_content")).
    955                   CenterPane().Hide());
     995                  CenterPane().Hide().MinimizeButton(true));
    956996
    957997    m_mgr.AddPane(CreateHTMLCtrl(), wxAuiPaneInfo().Name(wxT("html_content")).
    958                   CenterPane().Hide());
     998                  CenterPane().Hide().MinimizeButton(true));
    959999
    9601000    m_mgr.AddPane(CreateNotebook(), wxAuiPaneInfo().Name(wxT("notebook_content")).
    9611001                  CenterPane().PaneBorder(false));
     
    9821022                  ToolbarPane().Left().
    9831023                  GripperTop());
    9841024
     1025    m_mgr.AddPane(tb6, wxAuiPaneInfo().
     1026                  Name(wxT("tb6")).Caption(wxT("Sample Vertical Clockwise Rotated Toolbar")).
     1027                  ToolbarPane().Right().
     1028                  GripperTop().
     1029                  TopDockable(false).BottomDockable(false));
     1030
    9851031    m_mgr.AddPane(new wxButton(this, wxID_ANY, _("Test Button")),
    986                   wxAuiPaneInfo().Name(wxT("tb6")).
     1032                  wxAuiPaneInfo().Name(wxT("tb7")).
    9871033                  ToolbarPane().Top().Row(2).Position(1).
    9881034                  LeftDockable(false).RightDockable(false));
    9891035
     
    9971043        if (!all_panes.Item(i).IsToolbar())
    9981044            all_panes.Item(i).Hide();
    9991045    m_mgr.GetPane(wxT("tb1")).Hide();
    1000     m_mgr.GetPane(wxT("tb6")).Hide();
     1046    m_mgr.GetPane(wxT("tb7")).Hide();
    10011047    m_mgr.GetPane(wxT("test8")).Show().Left().Layer(0).Row(0).Position(0);
    10021048    m_mgr.GetPane(wxT("test10")).Show().Bottom().Layer(0).Row(0).Position(0);
    10031049    m_mgr.GetPane(wxT("notebook_content")).Show();
     
    11311177    m_mgr.Update();
    11321178}
    11331179
     1180void MyFrame::OnMinimizePosition(wxCommandEvent& event)
     1181{
     1182    long minize_mode = 0;
     1183    switch(event.GetId())
     1184    {
     1185    case ID_MinimizePosAuto:
     1186        minize_mode |= wxAUI_MINIMIZE_POS_AUTO;
     1187        break;
     1188    case ID_MinimizePosTop:
     1189        minize_mode |= wxAUI_MINIMIZE_POS_TOP;
     1190            break;
     1191    case ID_MinimizePosLeft:
     1192        minize_mode |= wxAUI_MINIMIZE_POS_LEFT;
     1193            break;
     1194    case ID_MinimizePosRight:
     1195        minize_mode |= wxAUI_MINIMIZE_POS_RIGHT;
     1196        break;
     1197    case ID_MinimizePosBottom:
     1198        minize_mode |= wxAUI_MINIMIZE_POS_BOTTOM;
     1199        break;
     1200    }
    11341201
     1202
     1203    size_t i = 0, count;
     1204    wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
     1205    for (i = 0, count = all_panes.GetCount(); i < count; ++i)
     1206    {
     1207        wxAuiPaneInfo& pane = all_panes.Item(i);
     1208        pane.MinimizeMode(minize_mode | (pane.GetMinimizeMode() & wxAUI_MINIMIZE_CAPT_MASK));
     1209    }
     1210}
     1211
     1212void MyFrame::OnMinimizeCaption(wxCommandEvent& event)
     1213{
     1214    long minize_mode = 0;
     1215    switch(event.GetId())
     1216    {
     1217    case ID_MinimizeCaptAuto:
     1218        minize_mode |= wxAUI_MINIMIZE_CAPT_AUTO;
     1219            break;
     1220    case ID_MinimizeCaptHorz:
     1221        minize_mode |= wxAUI_MINIMIZE_CAPT_HORZ;
     1222            break;
     1223    case ID_MinimizeCaptHide:
     1224        minize_mode |= wxAUI_MINIMIZE_CAPT_HIDE;
     1225        break;
     1226    }
     1227
     1228
     1229    size_t i = 0, count;
     1230    wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
     1231    for (i = 0, count = all_panes.GetCount(); i < count; ++i)
     1232    {
     1233        wxAuiPaneInfo& pane = all_panes.Item(i);
     1234        pane.MinimizeMode(minize_mode | (pane.GetMinimizeMode() & wxAUI_MINIMIZE_POS_MASK));
     1235    }
     1236}
     1237
    11351238void MyFrame::OnNotebookFlag(wxCommandEvent& event)
    11361239{
    11371240    int id = event.GetId();
     
    13141417{
    13151418    if (evt.pane->name == wxT("test10"))
    13161419    {
    1317         int res = wxMessageBox(wxT("Are you sure you want to close/hide this pane?"),
     1420        wxString msg = wxT("Are you sure you want to ");
     1421        if (evt.GetEventType() == wxEVT_AUI_PANE_MINIMIZE)
     1422            msg += wxT("minimize ");
     1423        else
     1424            msg += wxT("close/hide ");
     1425
     1426        int res = wxMessageBox(msg + wxT("this pane?"),
    13181427                               wxT("wxAUI"),
    13191428                               wxYES_NO,
    13201429                               this);
     
    14061515    m_mgr.AddPane(CreateTreeCtrl(), wxAuiPaneInfo().
    14071516                  Caption(wxT("Tree Control")).
    14081517                  Float().FloatingPosition(GetStartPosition()).
    1409                   FloatingSize(wxSize(150,300)));
     1518                  FloatingSize(wxSize(150,300)).MinimizeButton(true));
    14101519    m_mgr.Update();
    14111520}
    14121521
     
    14151524    m_mgr.AddPane(CreateGrid(), wxAuiPaneInfo().
    14161525                  Caption(wxT("Grid")).
    14171526                  Float().FloatingPosition(GetStartPosition()).
    1418                   FloatingSize(wxSize(300,200)));
     1527                  FloatingSize(wxSize(300,200)).MinimizeButton(true));
    14191528    m_mgr.Update();
    14201529}
    14211530
     
    14241533    m_mgr.AddPane(CreateHTMLCtrl(), wxAuiPaneInfo().
    14251534                  Caption(wxT("HTML Control")).
    14261535                  Float().FloatingPosition(GetStartPosition()).
    1427                   FloatingSize(wxSize(300,200)));
     1536                  FloatingSize(wxSize(300,200)).MinimizeButton(true));
    14281537    m_mgr.Update();
    14291538}
    14301539
     
    14341543                  Caption(wxT("Notebook")).
    14351544                  Float().FloatingPosition(GetStartPosition()).
    14361545                  //FloatingSize(300,200).
    1437                   CloseButton(true).MaximizeButton(true));
     1546                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    14381547    m_mgr.Update();
    14391548}
    14401549
     
    14421551{
    14431552    m_mgr.AddPane(CreateTextCtrl(), wxAuiPaneInfo().
    14441553                  Caption(wxT("Text Control")).
    1445                   Float().FloatingPosition(GetStartPosition()));
     1554                  Float().FloatingPosition(GetStartPosition()).MinimizeButton(true));
    14461555    m_mgr.Update();
    14471556}
    14481557
     
    14511560    m_mgr.AddPane(CreateSizeReportCtrl(), wxAuiPaneInfo().
    14521561                  Caption(wxT("Client Size Reporter")).
    14531562                  Float().FloatingPosition(GetStartPosition()).
    1454                   CloseButton(true).MaximizeButton(true));
     1563                  CloseButton(true).MaximizeButton(true).MinimizeButton(true));
    14551564    m_mgr.Update();
    14561565}
    14571566
  • src/aui/auibar.cpp

     
    132132    m_flags = 0;
    133133    m_textOrientation = wxAUI_TBTOOL_TEXT_BOTTOM;
    134134    m_highlightColour = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
     135    m_orientation = wxAUI_TBTOOL_HORIZONTAL;
    135136
    136137    m_separatorSize = 7;
    137138    m_gripperSize = 7;
     
    187188    m_textOrientation = orientation;
    188189}
    189190
     191void wxAuiDefaultToolBarArt::SetOrientation(int orientation)
     192{
     193    m_orientation = orientation;
     194}
     195
    190196unsigned int wxAuiDefaultToolBarArt::GetFlags()
    191197{
    192198    return m_flags;
     
    202208    return m_textOrientation;
    203209}
    204210
     211int wxAuiDefaultToolBarArt::GetOrientation()
     212{
     213    return m_orientation;
     214}
     215
    205216void wxAuiDefaultToolBarArt::DrawBackground(
    206217                                    wxDC& dc,
    207218                                    wxWindow* WXUNUSED(wnd),
     
    235246{
    236247    dc.SetFont(m_font);
    237248    dc.SetTextForeground(*wxBLACK);
     249    bool horizontal = (item.GetOrientation() == wxAUI_TBTOOL_HORIZONTAL);
    238250
    239     // we only care about the text height here since the text
    240     // will get cropped based on the width of the item
    241     int textWidth = 0, textHeight = 0;
    242     dc.GetTextExtent(wxT("ABCDHgj"), &textWidth, &textHeight);
     251    wxSize labelSize = wxAuiToolBar::GetLabelSize(dc, item.GetLabel(), !horizontal);
     252    int textWidth = labelSize.GetWidth(), textHeight = labelSize.GetHeight();
    243253
    244     // set the clipping region
    245     wxRect clipRect = rect;
    246     clipRect.width -= 1;
    247     dc.SetClippingRegion(clipRect);
    248 
    249254    int textX, textY;
    250     textX = rect.x + 1;
    251     textY = rect.y + (rect.height-textHeight)/2;
    252     dc.DrawText(item.GetLabel(), textX, textY);
    253     dc.DestroyClippingRegion();
     255    switch(item.GetOrientation())
     256    {
     257    default:
     258    case wxAUI_TBTOOL_HORIZONTAL:
     259        textX = rect.x;
     260        textY = rect.y + (rect.height-textHeight)/2;
     261        dc.DrawText(item.GetLabel(), textX, textY);
     262        break;
     263    case wxAUI_TBTOOL_VERT_CLOCKWISE:
     264        textX = rect.x + (rect.width+textWidth)/2;
     265        textY = rect.y;
     266        dc.DrawRotatedText(item.GetLabel(), textX, textY, 270);
     267        break;
     268    case wxAUI_TBTOOL_VERT_COUNTERCLOCKWISE:
     269        textX = rect.x + (rect.width-textWidth)/2;
     270        textY = rect.y + textHeight;
     271        dc.DrawRotatedText(item.GetLabel(), textX, textY, 90);
     272        break;
     273    }
    254274}
    255275
    256276
    257277void wxAuiDefaultToolBarArt::DrawButton(
    258278                                    wxDC& dc,
    259                                     wxWindow* WXUNUSED(wnd),
     279                                    wxWindow* wnd,
    260280                                    const wxAuiToolBarItem& item,
    261281                                    const wxRect& rect)
    262282{
    263     int textWidth = 0, textHeight = 0;
     283    wxRect bmpRect;
     284    wxRect textRect;
     285    GetToolsPosition(dc, item, rect, bmpRect, textRect);
    264286
    265     if (m_flags & wxAUI_TB_TEXT)
    266     {
    267         dc.SetFont(m_font);
    268 
    269         int tx, ty;
    270 
    271         dc.GetTextExtent(wxT("ABCDHgj"), &tx, &textHeight);
    272         textWidth = 0;
    273         dc.GetTextExtent(item.GetLabel(), &textWidth, &ty);
    274     }
    275 
    276     int bmpX = 0, bmpY = 0;
    277     int textX = 0, textY = 0;
    278 
    279     if (m_textOrientation == wxAUI_TBTOOL_TEXT_BOTTOM)
    280     {
    281         bmpX = rect.x +
    282                 (rect.width/2) -
    283                 (item.GetBitmap().GetWidth()/2);
    284 
    285         bmpY = rect.y +
    286                 ((rect.height-textHeight)/2) -
    287                 (item.GetBitmap().GetHeight()/2);
    288 
    289         textX = rect.x + (rect.width/2) - (textWidth/2) + 1;
    290         textY = rect.y + rect.height - textHeight - 1;
    291     }
    292     else if (m_textOrientation == wxAUI_TBTOOL_TEXT_RIGHT)
    293     {
    294         bmpX = rect.x + 3;
    295 
    296         bmpY = rect.y +
    297                 (rect.height/2) -
    298                 (item.GetBitmap().GetHeight()/2);
    299 
    300         textX = bmpX + 3 + item.GetBitmap().GetWidth();
    301         textY = rect.y +
    302                  (rect.height/2) -
    303                  (textHeight/2);
    304     }
    305 
    306 
    307287    if (!(item.GetState() & wxAUI_BUTTON_STATE_DISABLED))
    308288    {
    309289        if (item.GetState() & wxAUI_BUTTON_STATE_PRESSED)
     
    341321        bmp = item.GetBitmap();
    342322
    343323    if ( bmp.IsOk() )
    344         dc.DrawBitmap(bmp, bmpX, bmpY, true);
     324        dc.DrawBitmap(bmp, bmpRect.x, bmpRect.y, true);
    345325
    346326    // set the item's text color based on if it is disabled
    347327    dc.SetTextForeground(*wxBLACK);
     
    349329        dc.SetTextForeground(DISABLED_TEXT_COLOR);
    350330
    351331    if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
    352     {
    353         dc.DrawText(item.GetLabel(), textX, textY);
    354     }
     332        DrawLabel(dc, wnd, item, textRect);
    355333}
    356334
    357335
    358336void wxAuiDefaultToolBarArt::DrawDropDownButton(
    359337                                    wxDC& dc,
    360                                     wxWindow* WXUNUSED(wnd),
     338                                    wxWindow* wnd,
    361339                                    const wxAuiToolBarItem& item,
    362340                                    const wxRect& rect)
    363341{
    364     int textWidth = 0, textHeight = 0, textX = 0, textY = 0;
    365     int bmpX = 0, bmpY = 0, dropBmpX = 0, dropBmpY = 0;
     342    int dropBmpX = 0, dropBmpY = 0;
    366343
    367     wxRect buttonRect = wxRect(rect.x,
    368                                 rect.y,
    369                                 rect.width-BUTTON_DROPDOWN_WIDTH,
    370                                 rect.height);
    371     wxRect dropDownRect = wxRect(rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1,
    372                                   rect.y,
    373                                   BUTTON_DROPDOWN_WIDTH+1,
    374                                   rect.height);
    375 
    376     if (m_flags & wxAUI_TB_TEXT)
     344    wxRect buttonRect;
     345    wxRect dropDownRect;
     346    bool horizontal = (item.GetOrientation() == wxAUI_TBTOOL_HORIZONTAL);
     347    if (horizontal)
    377348    {
    378         dc.SetFont(m_font);
     349        buttonRect = wxRect(rect.x,
     350                            rect.y,
     351                            rect.width-BUTTON_DROPDOWN_WIDTH,
     352                            rect.height);
     353        dropDownRect = wxRect(rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1,
     354                              rect.y,
     355                              BUTTON_DROPDOWN_WIDTH+1,
     356                              rect.height);
     357    }
     358    else
     359    {
     360        buttonRect = wxRect(rect.x,
     361                            rect.y,
     362                            rect.width,
     363                            rect.height-BUTTON_DROPDOWN_WIDTH);
     364        dropDownRect = wxRect(rect.x,
     365                              rect.y+rect.height-BUTTON_DROPDOWN_WIDTH-1,
     366                              rect.width,
     367                              BUTTON_DROPDOWN_WIDTH+1);
     368    }
    379369
    380         int tx, ty;
    381         if (m_flags & wxAUI_TB_TEXT)
    382         {
    383             dc.GetTextExtent(wxT("ABCDHgj"), &tx, &textHeight);
    384             textWidth = 0;
    385         }
    386370
    387         dc.GetTextExtent(item.GetLabel(), &textWidth, &ty);
     371    int dropBmpWidth = m_buttonDropDownBmp.GetWidth();
     372    int dropBmpHeight = m_buttonDropDownBmp.GetHeight();
     373    if (!horizontal)
     374    {
     375        int tmp = dropBmpWidth;
     376        dropBmpWidth = dropBmpHeight;
     377        dropBmpHeight = tmp;
    388378    }
    389 
    390 
    391 
    392379    dropBmpX = dropDownRect.x +
    393                 (dropDownRect.width/2) -
    394                 (m_buttonDropDownBmp.GetWidth()/2);
     380               (dropDownRect.width/2) -
     381               (dropBmpWidth/2);
    395382    dropBmpY = dropDownRect.y +
    396                 (dropDownRect.height/2) -
    397                 (m_buttonDropDownBmp.GetHeight()/2);
     383               (dropDownRect.height/2) -
     384               (dropBmpHeight/2);
    398385
    399386
    400     if (m_textOrientation == wxAUI_TBTOOL_TEXT_BOTTOM)
    401     {
    402         bmpX = buttonRect.x +
    403                 (buttonRect.width/2) -
    404                 (item.GetBitmap().GetWidth()/2);
    405         bmpY = buttonRect.y +
    406                 ((buttonRect.height-textHeight)/2) -
    407                 (item.GetBitmap().GetHeight()/2);
     387    wxRect bmpRect;
     388    wxRect textRect;
     389    GetToolsPosition(dc, item, buttonRect, bmpRect, textRect);
    408390
    409         textX = rect.x + (rect.width/2) - (textWidth/2) + 1;
    410         textY = rect.y + rect.height - textHeight - 1;
    411     }
    412     else if (m_textOrientation == wxAUI_TBTOOL_TEXT_RIGHT)
    413     {
    414         bmpX = rect.x + 3;
    415 
    416         bmpY = rect.y +
    417                 (rect.height/2) -
    418                 (item.GetBitmap().GetHeight()/2);
    419 
    420         textX = bmpX + 3 + item.GetBitmap().GetWidth();
    421         textY = rect.y +
    422                  (rect.height/2) -
    423                  (textHeight/2);
    424     }
    425 
    426 
    427391    if (item.GetState() & wxAUI_BUTTON_STATE_PRESSED)
    428392    {
    429393        dc.SetPen(wxPen(m_highlightColour));
     
    467431    if (!bmp.IsOk())
    468432        return;
    469433
    470     dc.DrawBitmap(bmp, bmpX, bmpY, true);
    471     dc.DrawBitmap(dropbmp, dropBmpX, dropBmpY, true);
     434    dc.DrawBitmap(bmp, bmpRect.x, bmpRect.y, true);
     435    if (horizontal)
     436    {
     437        dc.DrawBitmap(dropbmp, dropBmpX, dropBmpY, true);
     438    }
     439    else
     440    {
     441        dc.DrawBitmap(dropbmp.ConvertToImage().
     442            Rotate90(item.GetOrientation() == wxAUI_TBTOOL_VERT_CLOCKWISE),
     443            dropBmpX, dropBmpY, true);
     444    }
    472445
    473446    // set the item's text color based on if it is disabled
    474447    dc.SetTextForeground(*wxBLACK);
     
    476449        dc.SetTextForeground(DISABLED_TEXT_COLOR);
    477450
    478451    if ( (m_flags & wxAUI_TB_TEXT) && !item.GetLabel().empty() )
    479     {
    480         dc.DrawText(item.GetLabel(), textX, textY);
    481     }
     452        DrawLabel(dc, wnd, item, textRect);
    482453}
    483454
    484455void wxAuiDefaultToolBarArt::DrawControlLabel(
     
    498469
    499470    dc.SetFont(m_font);
    500471
    501     int tx, ty;
    502     if (m_flags & wxAUI_TB_TEXT)
    503     {
    504         dc.GetTextExtent(wxT("ABCDHgj"), &tx, &textHeight);
    505         textWidth = 0;
    506     }
     472    wxSize labelSize = wxAuiToolBar::GetLabelSize(dc, item.GetLabel(),
     473        item.GetOrientation() != wxAUI_TBTOOL_HORIZONTAL);
    507474
    508     dc.GetTextExtent(item.GetLabel(), &textWidth, &ty);
     475    textHeight = labelSize.GetHeight();
     476    textWidth = labelSize.GetWidth();
    509477
     478
    510479    // don't draw the label if it is wider than the item width
    511480    if (textWidth > rect.width)
    512481        return;
     
    529498                                        const wxAuiToolBarItem& item)
    530499{
    531500    dc.SetFont(m_font);
     501    wxSize label_size = wxAuiToolBar::GetLabelSize(dc, item.GetLabel(),
     502        m_orientation != wxAUI_TBTOOL_HORIZONTAL);
    532503
    533     // get label's height
    534     int width = 0, height = 0;
    535     dc.GetTextExtent(wxT("ABCDHgj"), &width, &height);
    536 
    537     // get item's width
    538     width = item.GetMinSize().GetWidth();
    539 
    540     if (width == -1)
    541     {
    542         // no width specified, measure the text ourselves
    543         width = dc.GetTextExtent(item.GetLabel()).GetX();
    544     }
    545 
    546     return wxSize(width, height);
     504    return wxSize(item.GetMinSize().GetWidth(), label_size.GetHeight());
    547505}
    548506
    549507wxSize wxAuiDefaultToolBarArt::GetToolSize(
     
    560518    if (m_flags & wxAUI_TB_TEXT)
    561519    {
    562520        dc.SetFont(m_font);
    563         int tx, ty;
     521        wxSize label_size = wxAuiToolBar::GetLabelSize(dc, item.GetLabel(),
     522            GetOrientation() != wxAUI_TBTOOL_HORIZONTAL);
    564523
     524        int padding = 6;
    565525        if (m_textOrientation == wxAUI_TBTOOL_TEXT_BOTTOM)
    566526        {
    567             dc.GetTextExtent(wxT("ABCDHgj"), &tx, &ty);
    568             height += ty;
     527            if (GetOrientation() != wxAUI_TBTOOL_HORIZONTAL)
     528            {
     529                height += 3; // space between top border and bitmap
     530                height += 3; // space between bitmap and text
     531                padding = 0;
     532            }
    569533
     534            height += label_size.GetHeight();
     535
    570536            if ( !item.GetLabel().empty() )
    571             {
    572                 dc.GetTextExtent(item.GetLabel(), &tx, &ty);
    573                 width = wxMax(width, tx+6);
    574             }
     537                width = wxMax(width, label_size.GetWidth()+padding);
    575538        }
    576539        else if ( m_textOrientation == wxAUI_TBTOOL_TEXT_RIGHT &&
    577540                  !item.GetLabel().empty() )
    578541        {
    579             width += 3; // space between left border and bitmap
    580             width += 3; // space between bitmap and text
     542            if (GetOrientation() == wxAUI_TBTOOL_HORIZONTAL)
     543            {
     544                width += 3; // space between left border and bitmap
     545                width += 3; // space between bitmap and text
     546                padding = 0;
     547            }
    581548
    582549            if ( !item.GetLabel().empty() )
    583550            {
    584                 dc.GetTextExtent(item.GetLabel(), &tx, &ty);
    585                 width += tx;
    586                 height = wxMax(height, ty);
     551                width += label_size.GetWidth();
     552                height = wxMax(height, label_size.GetHeight()+padding);
    587553            }
    588554        }
    589555    }
    590556
    591557    // if the tool has a dropdown button, add it to the width
    592558    if (item.HasDropDown())
    593         width += (BUTTON_DROPDOWN_WIDTH+4);
     559    {
     560        if (item.GetOrientation() == wxAUI_TBTOOL_HORIZONTAL)
     561            width += (BUTTON_DROPDOWN_WIDTH+4);
     562        else
     563            height += (BUTTON_DROPDOWN_WIDTH+4);
     564    }
    594565
    595566    return wxSize(width, height);
    596567}
     
    744715
    745716            wxMenuItem* m =  new wxMenuItem(&menuPopup, item.GetId(), text, item.GetShortHelp());
    746717
     718            int orientation = item.GetOrientation();
     719            item.SetOrientation(wxAUI_TBTOOL_HORIZONTAL);
    747720            m->SetBitmap(item.GetBitmap());
     721            item.SetOrientation(orientation);
    748722            menuPopup.Append(m);
    749723            items_added++;
    750724        }
     
    773747}
    774748
    775749
     750void wxAuiDefaultToolBarArt::GetToolsPosition(wxDC& dc,
     751                                              const wxAuiToolBarItem& item,
     752                                              const wxRect& rect,
     753                                              wxRect &bmp_rect,
     754                                              wxRect &text_rect)
     755{
     756    int text_width = 0, text_height = 0;
     757    bool horizontal = (m_orientation == wxAUI_TBTOOL_HORIZONTAL);
     758    bool text_bottom = (m_textOrientation == wxAUI_TBTOOL_TEXT_BOTTOM);
     759    bool text_right = (m_textOrientation == wxAUI_TBTOOL_TEXT_RIGHT);
     760    int bmp_with = item.GetBitmap().GetWidth();
     761    int bmp_height = item.GetBitmap().GetHeight();
    776762
     763    if (m_flags & wxAUI_TB_TEXT)
     764    {
     765        dc.SetFont(m_font);
    777766
     767        wxSize label_size = wxAuiToolBar::GetLabelSize(dc, item.GetLabel(), !horizontal);
     768
     769        text_height = label_size.GetHeight();
     770        text_width = label_size.GetWidth();
     771    }
     772
     773    int bmp_x = 0, bmp_y = 0;
     774    int text_x = 0, text_y = 0;
     775
     776    if (horizontal && text_bottom)
     777    {
     778        bmp_x = rect.x +
     779                (rect.width/2) -
     780                (bmp_with/2);
     781        bmp_y = rect.y + 3;
     782
     783        text_x = rect.x +
     784                 (rect.width/2) -
     785                 (text_width/2);
     786        text_y = rect.y +
     787                 ((bmp_y - rect.y) * 2) +
     788                 bmp_height;
     789    }
     790    else if (horizontal && text_right)
     791    {
     792        bmp_x = rect.x + 3;
     793        bmp_y = rect.y +
     794                (rect.height/2) -
     795                (bmp_height / 2);
     796
     797        text_x = rect.x +
     798                 ((bmp_x - rect.x) * 2) +
     799                 bmp_with;
     800        text_y = rect.y +
     801                 (rect.height/2) -
     802                 (text_height/2);
     803    }
     804    else if (!horizontal && text_bottom)
     805    {
     806        bmp_x = rect.x +
     807                (rect.width / 2) -
     808                (bmp_with / 2);
     809        bmp_y = rect.y + 3;
     810
     811        text_x = rect.x +
     812                 (rect.width / 2) -
     813                 (text_width / 2);
     814        text_y = rect.y +
     815                 ((bmp_y - rect.y) * 2) +
     816                 bmp_height;
     817    }
     818    bmp_rect.SetPosition(wxPoint(bmp_x, bmp_y));
     819    bmp_rect.SetSize(wxSize(bmp_with, bmp_height));
     820    text_rect.SetPosition(wxPoint(text_x, text_y));
     821    text_rect.SetSize(wxSize(text_width, text_height));
     822}
     823
     824
    778825static wxOrientation GetOrientation(long& style)
    779826{
    780827    switch (style & wxAUI_ORIENTATION_MASK)
     
    824871    m_toolPacking = 2;
    825872    m_toolBorderPadding = 3;
    826873    m_toolTextOrientation = wxAUI_TBTOOL_TEXT_BOTTOM;
     874    m_toolOrientation = wxAUI_TBTOOL_HORIZONTAL;
    827875    m_gripperSizerItem = NULL;
    828876    m_overflowSizerItem = NULL;
    829877    m_dragging = false;
     
    861909    SetExtraStyle(wxWS_EX_PROCESS_IDLE);
    862910    if (style & wxAUI_TB_HORZ_LAYOUT)
    863911        SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT);
     912    else if (style & wxAUI_TB_VERTICAL)
     913    {
     914        if (style & wxAUI_TB_CLOCKWISE)
     915            SetToolOrientation(wxAUI_TBTOOL_VERT_CLOCKWISE);
     916        else if (style & wxAUI_TB_COUNTERCLOCKWISE)
     917            SetToolOrientation(wxAUI_TBTOOL_VERT_COUNTERCLOCKWISE);
     918    }
    864919    SetBackgroundStyle(wxBG_STYLE_CUSTOM);
    865920
    866921    return true;
     
    902957        SetToolTextOrientation(wxAUI_TBTOOL_TEXT_RIGHT);
    903958    else
    904959        SetToolTextOrientation(wxAUI_TBTOOL_TEXT_BOTTOM);
     960    if (style & wxAUI_TB_VERTICAL)
     961    {
     962        if (style & wxAUI_TB_CLOCKWISE)
     963            SetToolOrientation(wxAUI_TBTOOL_VERT_CLOCKWISE);
     964        else if (style & wxAUI_TB_COUNTERCLOCKWISE)
     965            SetToolOrientation(wxAUI_TBTOOL_VERT_COUNTERCLOCKWISE);
     966    }
    905967}
    906968
    907969void wxAuiToolBar::SetArtProvider(wxAuiToolBarArt* art)
     
    914976    {
    915977        SetArtFlags();
    916978        m_art->SetTextOrientation(m_toolTextOrientation);
     979        m_art->SetOrientation(m_toolOrientation);
    917980    }
    918981}
    919982
     
    9691032    item.m_minSize = wxDefaultSize;
    9701033    item.m_userData = 0;
    9711034    item.m_sticky = false;
    972 
     1035    item.m_orientation = m_toolOrientation;
     1036   
    9731037    if (item.m_toolId == wxID_ANY)
    9741038        item.m_toolId = wxNewId();
    9751039
     
    10041068    item.m_minSize = control->GetEffectiveMinSize();
    10051069    item.m_userData = 0;
    10061070    item.m_sticky = false;
     1071    item.m_orientation = m_toolOrientation;
    10071072
    10081073    m_items.Add(item);
    10091074    return &m_items.Last();
     
    10331098    item.m_minSize = min_size;
    10341099    item.m_userData = 0;
    10351100    item.m_sticky = false;
     1101    item.m_orientation = m_toolOrientation;
    10361102
    10371103    if (item.m_toolId == wxID_ANY)
    10381104        item.m_toolId = wxNewId();
    1039 
     1105       
    10401106    m_items.Add(item);
    10411107    return &m_items.Last();
    10421108}
    10431109
     1110wxSize wxAuiToolBar::GetLabelSize(wxDC& dc, const wxString& label, bool vertical)
     1111{
     1112    int tx, ty;
     1113    int text_width = 0, text_height = 0;
     1114
     1115    // get the text height
     1116    dc.GetTextExtent(wxT("ABCDHgj"), &tx, &text_height);
     1117
     1118    // get the text width
     1119    if ( !label.empty() )
     1120        dc.GetTextExtent(label, &text_width, &ty);
     1121
     1122    if (vertical)
     1123    {
     1124        int tmp = text_height;
     1125        text_height = text_width;
     1126        text_width = tmp;
     1127    }
     1128
     1129    return wxSize(text_width, text_height);
     1130}
     1131
    10441132wxAuiToolBarItem* wxAuiToolBar::AddSeparator()
    10451133{
    10461134    wxAuiToolBarItem item;
     
    10581146    item.m_minSize = wxDefaultSize;
    10591147    item.m_userData = 0;
    10601148    item.m_sticky = false;
     1149    item.m_orientation = m_toolOrientation;
    10611150
    10621151    m_items.Add(item);
    10631152    return &m_items.Last();
     
    10811170    item.m_minSize = wxDefaultSize;
    10821171    item.m_userData = 0;
    10831172    item.m_sticky = false;
     1173    item.m_orientation = m_toolOrientation;
    10841174
    10851175    m_items.Add(item);
    10861176    return &m_items.Last();
     
    11041194    item.m_minSize = wxDefaultSize;
    11051195    item.m_userData = 0;
    11061196    item.m_sticky = false;
     1197    item.m_orientation = m_toolOrientation;
    11071198
    11081199    m_items.Add(item);
    11091200    return &m_items.Last();
     
    13421433    return m_toolTextOrientation;
    13431434}
    13441435
     1436
     1437void wxAuiToolBar::SetToolOrientation(int orientation)
     1438{
     1439    m_toolOrientation = orientation;
     1440
     1441    if (m_art)
     1442    {
     1443        m_art->SetOrientation(orientation);
     1444    }
     1445}
     1446
     1447int wxAuiToolBar::GetToolOrientation() const
     1448{
     1449    return m_toolOrientation;
     1450}
     1451
    13451452void wxAuiToolBar::SetToolPacking(int packing)
    13461453{
    13471454    m_toolPacking = packing;
     
    21322239wxSize wxAuiToolBar::GetLabelSize(const wxString& label)
    21332240{
    21342241    wxClientDC dc(this);
    2135 
    2136     int tx, ty;
    2137     int textWidth = 0, textHeight = 0;
    2138 
    21392242    dc.SetFont(m_font);
    2140 
    2141     // get the text height
    2142     dc.GetTextExtent(wxT("ABCDHgj"), &tx, &textHeight);
    2143 
    2144     // get the text width
    2145     dc.GetTextExtent(label, &textWidth, &ty);
    2146 
    2147     return wxSize(textWidth, textHeight);
     2243    return wxAuiToolBar::GetLabelSize(dc, label,
     2244        m_toolOrientation != wxAUI_TBTOOL_HORIZONTAL);
    21482245}
    21492246
    21502247
     
    25762673        e.SetToolId(m_actionItem->m_toolId);
    25772674
    25782675        int mouse_x = evt.GetX();
     2676        int mouse_y = evt.GetY();
    25792677        wxRect rect = m_actionItem->m_sizerItem->GetRect();
    25802678        const bool dropDownHit = m_actionItem->m_dropDown &&
     2679                                 (m_actionItem->m_orientation == wxAUI_TBTOOL_HORIZONTAL &&
    25812680                                 mouse_x >= (rect.x+rect.width-BUTTON_DROPDOWN_WIDTH-1) &&
    2582                                  mouse_x < (rect.x+rect.width);
     2681                                 mouse_x < (rect.x+rect.width)) ||
     2682                                 (m_actionItem->m_orientation != wxAUI_TBTOOL_HORIZONTAL &&
     2683                                 mouse_y >= (rect.y+rect.height-BUTTON_DROPDOWN_WIDTH-1) &&
     2684                                 mouse_y < (rect.y+rect.height));
    25832685        e.SetDropDownClicked(dropDownHit);
    25842686
    25852687        e.SetClickPoint(evt.GetPosition());
     
    26492751
    26502752                e.SetInt(toggle);
    26512753            }
     2754            else if ( m_actionItem->m_toolId == wxID_RESTORE_FRAME )
     2755            {
     2756                // find aui manager
     2757                wxAuiManager* manager = wxAuiManager::GetManager(this);
    26522758
     2759                if (!manager)
     2760                    return;
     2761
     2762                wxAuiPaneInfo pane = manager->GetPane(this);
     2763                if (pane.IsOk())
     2764                {
     2765
     2766                    wxAuiManagerEvent e(wxEVT_AUI_PANE_MIN_RESTORE);
     2767
     2768                    e.SetManager(manager);
     2769                    e.SetPane(&pane);
     2770
     2771                    ReleaseMouse();
     2772
     2773                    //manager->ProcessMgrEvent(e);
     2774                    manager->ProcessEvent(e);
     2775                    if (!e.GetVeto())
     2776                        DoIdleUpdate();
     2777                    return;
     2778                }
     2779            }
     2780
    26532781            // we have to release the mouse *before* sending the event, because
    26542782            // we don't know what a handler might do. It could open up a popup
    26552783            // menu for example and that would make us lose our capture anyway.
  • src/aui/dockart.cpp

     
    252252        0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0x07, 0xf0,
    253253        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
    254254
     255    static const unsigned char minimize_bits[] = {
     256        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xf7, 0xf7, 0x07, 0xf0,
     257        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
     258        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
     259
    255260    static const unsigned char restore_bits[]={
    256261        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xf0, 0x1f, 0xf0, 0xdf, 0xf7,
    257262        0x07, 0xf4, 0x07, 0xf4, 0xf7, 0xf5, 0xf7, 0xf1, 0xf7, 0xfd, 0xf7, 0xfd,
     
    279284#endif
    280285
    281286#ifdef __WXMAC__
     287    m_inactiveMinimizeBitmap = wxAuiBitmapFromBits(minimize_bits, 16, 16, *wxWHITE);
     288    m_activeMinimizeBitmap = wxAuiBitmapFromBits(minimize_bits, 16, 16, *wxWHITE );
     289#else
     290    m_inactiveMinimizeBitmap = wxAuiBitmapFromBits(minimize_bits, 16, 16, m_inactiveCaptionTextColour);
     291    m_activeMinimizeBitmap = wxAuiBitmapFromBits(minimize_bits, 16, 16, m_activeCaptionTextColour);
     292#endif
     293
     294#ifdef __WXMAC__
    282295    m_inactiveRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE);
    283296    m_activeRestoreBitmap = wxAuiBitmapFromBits(restore_bits, 16, 16, *wxWHITE );
    284297#else
     
    708721                    bmp = m_inactiveMaximizeBitmap;
    709722            }
    710723            break;
     724     case wxAUI_BUTTON_MINIMIZE:
     725        if (pane.state & wxAuiPaneInfo::optionActive)
     726            bmp = m_activeMinimizeBitmap;
     727        else
     728            bmp = m_inactiveMinimizeBitmap;
     729        break;
    711730    }
    712731
    713732
  • src/aui/framemanager.cpp

     
    3232#include "wx/aui/auibar.h"
    3333#include "wx/mdi.h"
    3434
     35#include "wx/aui/restore.xpm"
     36
    3537#ifndef WX_PRECOMP
    3638    #include "wx/panel.h"
    3739    #include "wx/settings.h"
     
    6264wxDEFINE_EVENT( wxEVT_AUI_PANE_ACTIVATED, wxAuiManagerEvent );
    6365wxDEFINE_EVENT( wxEVT_AUI_RENDER, wxAuiManagerEvent );
    6466wxDEFINE_EVENT( wxEVT_AUI_FIND_MANAGER, wxAuiManagerEvent );
     67wxDEFINE_EVENT( wxEVT_AUI_PANE_MINIMIZE, wxAuiManagerEvent );
     68wxDEFINE_EVENT( wxEVT_AUI_PANE_MIN_RESTORE, wxAuiManagerEvent );
    6569
    6670#ifdef __WXMAC__
    6771    // a few defines to avoid nameclashes
     
    610614    EVT_MOUSE_CAPTURE_LOST(wxAuiManager::OnCaptureLost)
    611615    EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus)
    612616    EVT_AUI_FIND_MANAGER(wxAuiManager::OnFindManager)
     617    EVT_AUI_PANE_MIN_RESTORE(wxAuiManager::OnRestoreMinimizedPane)
    613618END_EVENT_TABLE()
    614619
    615620
     
    624629    m_flags = flags;
    625630    m_skipping = false;
    626631    m_hasMaximized = false;
     632    m_has_minimized = false;
    627633    m_frame = NULL;
    628634    m_dockConstraintX = 0.3;
    629635    m_dockConstraintY = 0.3;
     
    990996}
    991997
    992998
     999void wxAuiManager::ShowPane(wxWindow *window,bool show)
     1000{
     1001    wxAuiPaneInfo &p = GetPane(window);
     1002    if (p.IsOk())
     1003    {
     1004/*        if (p.IsNotebookPage())
     1005        {
     1006            if (show)
     1007            {
     1008                wxAuiNotebook* notebook = m_notebooks[p.notebook_id];
     1009                int id = notebook->GetPageIndex(p.window);
     1010                if (id >= 0)
     1011                    notebook->SetSelection(id);
     1012                ShowPane(notebook,true);
     1013            }
     1014        }
     1015        else*/
     1016            p.Show(show);
     1017        if (p.frame)
     1018            p.frame->Raise();
     1019        Update();
     1020    }
     1021}
     1022
    9931023bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& paneInfo)
    9941024{
    9951025    wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed"));
     
    10741104    if (pinfo.dock_proportion == 0)
    10751105        pinfo.dock_proportion = 100000;
    10761106
     1107    if (pinfo.HasMinimizeButton())
     1108    {
     1109        wxAuiPaneButton button;
     1110        button.button_id = wxAUI_BUTTON_MINIMIZE;
     1111        pinfo.buttons.Add(button);
     1112    }
     1113
    10771114    if (pinfo.HasMaximizeButton())
    10781115    {
    10791116        wxAuiPaneButton button;
     
    13871424    // mark ourselves non-maximized
    13881425    paneInfo.Restore();
    13891426    m_hasMaximized = false;
     1427    m_has_minimized = false;
    13901428
    13911429    // last, show the window
    13921430    if (paneInfo.window && !paneInfo.window->IsShown())
     
    48444882        pane.Float();
    48454883        Update();
    48464884    }
     4885    //mn this performs the minimizing of a pane
     4886    else if (evt.button == wxAUI_BUTTON_MINIMIZE)
     4887    {
     4888        // fire pane close event
     4889        wxAuiManagerEvent e(wxEVT_AUI_PANE_MINIMIZE);
     4890        e.SetManager(this);
     4891        e.SetPane(evt.pane);
     4892        ProcessMgrEvent(e);
     4893
     4894        if (!e.GetVeto())
     4895        {
     4896            MinimizePane(pane);
     4897            Update();
     4898        }
     4899    }
    48474900}
    48484901
     4902void wxAuiManager::MinimizePane(wxAuiPaneInfo& paneInfo)
     4903{
     4904    if(!paneInfo.IsToolbar())
     4905    {
     4906
     4907        /*
     4908        Basically the idea is this.
     4909
     4910        1) create a toolbar, with a restore button
     4911
     4912        2) place the new toolbar in the toolbar area representative of the location of the pane
     4913        (NORTH/SOUTH/EAST/WEST, central area always to the right) or user defined
     4914
     4915        3) Hide the minimizing pane
     4916        */
     4917
     4918
     4919        // personalize the toolbar style
     4920        long tbStyle = wxAUI_TB_DEFAULT_STYLE;
     4921        long posMask = paneInfo.minimize_mode & wxAUI_MINIMIZE_POS_MASK;
     4922        long captMask = paneInfo.minimize_mode & wxAUI_MINIMIZE_CAPT_MASK;
     4923        int dockDirection = paneInfo.dock_direction;
     4924        if (captMask != 0)
     4925            tbStyle |= wxAUI_TB_TEXT;
     4926        if ((posMask == wxAUI_MINIMIZE_POS_TOP) ||
     4927            (posMask == wxAUI_MINIMIZE_POS_BOTTOM))
     4928        {
     4929            tbStyle |= wxAUI_TB_HORZ_LAYOUT;
     4930            if (posMask == wxAUI_MINIMIZE_POS_TOP)
     4931                dockDirection = wxAUI_DOCK_TOP;
     4932            else
     4933                dockDirection = wxAUI_DOCK_BOTTOM;
     4934        }
     4935        else if ((posMask == wxAUI_MINIMIZE_POS_RIGHT) ||
     4936                 (posMask == wxAUI_MINIMIZE_POS_LEFT))
     4937        {
     4938            tbStyle |= wxAUI_TB_VERTICAL;
     4939            if (captMask == wxAUI_MINIMIZE_CAPT_AUTO)
     4940                tbStyle |= wxAUI_TB_CLOCKWISE;
     4941            if ((posMask == wxAUI_MINIMIZE_POS_LEFT))
     4942                dockDirection = wxAUI_DOCK_LEFT;
     4943            else if ((posMask == wxAUI_MINIMIZE_POS_RIGHT))
     4944                dockDirection = wxAUI_DOCK_RIGHT;
     4945            else if ((posMask == wxAUI_MINIMIZE_POS_BOTTOM))
     4946                dockDirection = wxAUI_DOCK_BOTTOM;
     4947        }
     4948        else //wxAUI_MINIMIZE_POS_AUTO or undefined
     4949        {
     4950            if ((paneInfo.dock_direction == wxAUI_DOCK_TOP) ||
     4951                (paneInfo.dock_direction == wxAUI_DOCK_BOTTOM))
     4952            {
     4953                tbStyle |= wxAUI_TB_HORZ_LAYOUT;
     4954            }
     4955            else if ((paneInfo.dock_direction == wxAUI_DOCK_LEFT) ||
     4956                     (paneInfo.dock_direction == wxAUI_DOCK_RIGHT) ||
     4957                     (paneInfo.dock_direction == wxAUI_DOCK_CENTER))
     4958            {
     4959                tbStyle |= wxAUI_TB_VERTICAL;
     4960                if (captMask == wxAUI_MINIMIZE_CAPT_AUTO)
     4961                    tbStyle |= wxAUI_TB_CLOCKWISE;
     4962            }
     4963        }
     4964
     4965
     4966
     4967        // Create a new toolbar
     4968        // give it the same name as the minimized pane with _min appended
     4969        wxAuiToolBar* minimize_toolbar = new wxAuiToolBar(GetManagedWindow(),
     4970            wxID_ANY, wxDefaultPosition, wxDefaultSize, tbStyle);
     4971        minimize_toolbar->SetToolBitmapSize(wxSize(16,16));
     4972
     4973        minimize_toolbar->AddTool(wxID_RESTORE_FRAME,
     4974            paneInfo.caption,
     4975            wxBitmap(restore_xpm),
     4976            wxT("Restore " + paneInfo.caption));
     4977        minimize_toolbar->Realize();
     4978        wxString toolpanelname;
     4979        toolpanelname.Append(paneInfo.name);
     4980        toolpanelname.Append(wxT("_min"));
     4981
     4982        // add the toolbars to the manager
     4983
     4984        switch(dockDirection)
     4985        {
     4986        case wxAUI_DOCK_TOP:
     4987            {   
     4988                AddPane(minimize_toolbar, wxAuiPaneInfo().
     4989                    Name(toolpanelname).Caption(paneInfo.caption).
     4990                    ToolbarPane().Top().BottomDockable(false).
     4991                    LeftDockable(false).RightDockable(false).DestroyOnClose());
     4992                break;
     4993            }
     4994        case wxAUI_DOCK_BOTTOM:
     4995            {
     4996                AddPane(minimize_toolbar, wxAuiPaneInfo().
     4997                    Name(toolpanelname).Caption(paneInfo.caption).
     4998                    ToolbarPane().Bottom().TopDockable(false).
     4999                    LeftDockable(false).RightDockable(false).DestroyOnClose());
     5000                break;
     5001            }
     5002        case wxAUI_DOCK_LEFT:
     5003            {
     5004                AddPane(minimize_toolbar, wxAuiPaneInfo().
     5005                    Name(toolpanelname).Caption(paneInfo.caption).
     5006                    ToolbarPane().Left().TopDockable(false).
     5007                    BottomDockable(false).RightDockable(false).DestroyOnClose());
     5008
     5009                break;
     5010            }
     5011        case wxAUI_DOCK_RIGHT:
     5012        case wxAUI_DOCK_CENTER:
     5013            {
     5014                AddPane(minimize_toolbar, wxAuiPaneInfo().
     5015                    Name(toolpanelname).Caption(paneInfo.caption).
     5016                    ToolbarPane().Right().TopDockable(false).
     5017                    LeftDockable(false).BottomDockable(false).DestroyOnClose());
     5018                break;
     5019            }
     5020        }
     5021
     5022        // mark ourselves minimized
     5023        paneInfo.Minimize();
     5024        paneInfo.Show(false);
     5025        m_has_minimized = true;
     5026        // last, hide the window
     5027        if (paneInfo.window && paneInfo.window->IsShown())
     5028            paneInfo.window->Show(false);
     5029    }
     5030    Update();
     5031}
     5032
     5033void wxAuiManager::OnRestoreMinimizedPane(wxAuiManagerEvent& evt)
     5034{
     5035    wxAuiPaneInfo& pane = *(evt.pane);
     5036    if (pane.IsOk())
     5037    {
     5038        RestoreMinimizedPane(pane);
     5039        evt.Veto();
     5040    }
     5041}
     5042
     5043void wxAuiManager::RestoreMinimizedPane(wxAuiPaneInfo& paneInfo)
     5044{
     5045    wxString panename = paneInfo.name;
     5046    panename = panename.Left(panename.Length()-4);
     5047    wxAuiPaneInfo pane = GetPane(panename);
     5048    if (pane.IsOk())
     5049    {
     5050        ShowPane(pane.window);
     5051        pane.window->Show();
     5052        pane.Show(true);
     5053        m_has_minimized = false;
     5054        paneInfo.window->Show(false);
     5055        ClosePane(paneInfo);
     5056        Update();
     5057    }
     5058}
     5059
    48495060#endif // wxUSE_AUI