albaGUIDockManager.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaGUIDockManager
 Authors: Benjamin I. Williams
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef __albaGUIDockManager__H
#define __albaGUIDockManager__H
 
#include "albaDefines.h"
 
enum wxFrameManagerDock
{
    wxAUI_DOCK_NONE = 0,
    wxAUI_DOCK_TOP = 1,
    wxAUI_DOCK_RIGHT = 2,
    wxAUI_DOCK_BOTTOM = 3,
    wxAUI_DOCK_LEFT = 4,
    wxAUI_DOCK_CENTER = 5,
    wxAUI_DOCK_CENTRE = wxAUI_DOCK_CENTER
};
 
enum wxFrameManagerOption
{
    wxAUI_MGR_ALLOW_FLOATING        = 1 << 0,
    wxAUI_MGR_ALLOW_ACTIVE_PANE     = 1 << 1,
    wxAUI_MGR_TRANSPARENT_DRAG      = 1 << 2,
    wxAUI_MGR_TRANSPARENT_HINT      = 1 << 3,
    wxAUI_MGR_TRANSPARENT_HINT_FADE = 1 << 4,
 
    wxAUI_MGR_DEFAULT = wxAUI_MGR_ALLOW_FLOATING |
                        wxAUI_MGR_TRANSPARENT_HINT |
                        wxAUI_MGR_TRANSPARENT_HINT_FADE
};
 
enum wxPaneDockArtSetting
{
    wxAUI_ART_SASH_SIZE = 0,
    wxAUI_ART_CAPTION_SIZE = 1,
    wxAUI_ART_GRIPPER_SIZE = 2,
    wxAUI_ART_PANE_BORDER_SIZE = 3,
    wxAUI_ART_PANE_BUTTON_SIZE = 4,
    wxAUI_ART_BACKGROUND_COLOUR = 5,
    wxAUI_ART_SASH_COLOUR = 6,
    wxAUI_ART_ACTIVE_CAPTION_COLOUR = 7,
    wxAUI_ART_ACTIVE_CAPTION_GRADIENT_COLOUR = 8,
    wxAUI_ART_INACTIVE_CAPTION_COLOUR = 9,
    wxAUI_ART_INACTIVE_CAPTION_GRADIENT_COLOUR = 10,
    wxAUI_ART_ACTIVE_CAPTION_TEXT_COLOUR = 11,
    wxAUI_ART_INACTIVE_CAPTION_TEXT_COLOUR = 12,
    wxAUI_ART_BORDER_COLOUR = 13,
    wxAUI_ART_GRIPPER_COLOUR = 14,
    wxAUI_ART_CAPTION_FONT = 15,
    wxAUI_ART_GRADIENT_TYPE = 16
};
 
enum wxPaneDockArtGradients
{
    wxAUI_GRADIENT_NONE = 0,
    wxAUI_GRADIENT_VERTICAL = 1,
    wxAUI_GRADIENT_HORIZONTAL = 2
};
 
enum wxPaneButtonState
{
    wxAUI_BUTTON_STATE_NORMAL = 0,
    wxAUI_BUTTON_STATE_HOVER = 1,
    wxAUI_BUTTON_STATE_PRESSED = 2
};
 
enum wxPaneInsertLevel
{
    wxAUI_INSERT_PANE = 0,
    wxAUI_INSERT_ROW = 1,
    wxAUI_INSERT_DOCK = 2
};
 
 
 
// forwards and array declarations
class ALBA_EXPORT wxDockUIPart;
class ALBA_EXPORT wxPaneButton;
class ALBA_EXPORT wxPaneInfo;
class ALBA_EXPORT wxDockInfo;
class ALBA_EXPORT wxDockArt;
class ALBA_EXPORT wxFrameManagerEvent;
 
WX_DECLARE_OBJARRAY_WITH_DECL(wxDockInfo, wxDockInfoArray,class ALBA_EXPORT);
WX_DECLARE_OBJARRAY_WITH_DECL(wxDockUIPart, wxDockUIPartArray,class ALBA_EXPORT);
WX_DECLARE_OBJARRAY_WITH_DECL(wxPaneButton, wxPaneButtonArray,class ALBA_EXPORT);
WX_DECLARE_OBJARRAY_WITH_DECL(wxPaneInfo, wxPaneInfoArray,class ALBA_EXPORT);
WX_DEFINE_ARRAY_PTR(wxPaneInfo*, wxPaneInfoPtrArray);
WX_DEFINE_ARRAY_PTR(wxDockInfo*, wxDockInfoPtrArray);
 
ALBA_EXPORT extern wxDockInfo wxNullDockInfo;
ALBA_EXPORT extern wxPaneInfo wxNullPaneInfo;
 
 
 
class ALBA_EXPORT wxPaneInfo
{
public:
 
    wxPaneInfo()
    {
        m_Window = NULL;
        m_Frame = NULL;
        m_State = 0;
        m_DockDirection = wxAUI_DOCK_LEFT;
        m_DockLayer = 0;
        m_DockRow = 0;
        m_DockPos = 0;
        m_FloatingPos = wxDefaultPosition;
        m_FloatingSize = wxDefaultSize;
        m_BestSize = wxDefaultSize;
        m_MinSize = wxDefaultSize;
        m_MaxSize = wxDefaultSize;
        m_DockProportion = 0;
        
        DefaultPane();
    }
 
    wxPaneInfo(const wxPaneInfo& c)
    {
        m_Name = c.m_Name;
        m_Caption = c.m_Caption;
        m_Window = c.m_Window;
        m_Frame = c.m_Frame;
        m_State = c.m_State;
        m_DockDirection = c.m_DockDirection;
        m_DockLayer = c.m_DockLayer;
        m_DockRow = c.m_DockRow;
        m_DockPos = c.m_DockPos;
        m_BestSize = c.m_BestSize;
        m_MinSize = c.m_MinSize;
        m_MaxSize = c.m_MaxSize;
        m_FloatingPos = c.m_FloatingPos;
        m_FloatingSize = c.m_FloatingSize;
        m_DockProportion = c.m_DockProportion;
        m_Buttons = c.m_Buttons;
        m_Rect = c.m_Rect;
    }
 
    wxPaneInfo& operator=(const wxPaneInfo& c)
    {
        m_Name = c.m_Name;
        m_Caption = c.m_Caption;
        m_Window = c.m_Window;
        m_Frame = c.m_Frame;
        m_State = c.m_State;
        m_DockDirection = c.m_DockDirection;
        m_DockLayer = c.m_DockLayer;
        m_DockRow = c.m_DockRow;
        m_DockPos = c.m_DockPos;
        m_BestSize = c.m_BestSize;
        m_MinSize = c.m_MinSize;
        m_MaxSize = c.m_MaxSize;
        m_FloatingPos = c.m_FloatingPos;
        m_FloatingSize = c.m_FloatingSize;
        m_DockProportion = c.m_DockProportion;
        m_Buttons = c.m_Buttons;
        m_Rect = c.m_Rect;
        return *this;
    }
 
    bool IsOk() const { return (m_Window != NULL) ? true : false; }
    bool IsFixed() const { return !HasFlag(optionResizable); }
    bool IsResizable() const { return HasFlag(optionResizable); }
    bool IsShown() const { return !HasFlag(optionHidden); }
    bool IsFloating() const { return HasFlag(optionFloating); }
    bool IsDocked() const { return !HasFlag(optionFloating); }
    bool IsToolbar() const { return HasFlag(optionToolbar); }
    bool IsTopDockable() const { return HasFlag(optionTopDockable); }
    bool IsBottomDockable() const { return HasFlag(optionBottomDockable); }
    bool IsLeftDockable() const { return HasFlag(optionLeftDockable); }
    bool IsRightDockable() const { return HasFlag(optionRightDockable); }
    bool IsFloatable() const { return HasFlag(optionFloatable); }
    bool IsMovable() const { return HasFlag(optionMovable); }
    bool HasCaption() const { return HasFlag(optionCaption); }
    bool HasGripper() const { return HasFlag(optionGripper); }
    bool HasBorder() const { return HasFlag(optionPaneBorder); }
    bool HasCloseButton() const { return HasFlag(buttonClose); }
    bool HasMaximizeButton() const { return HasFlag(buttonMaximize); }
    bool HasMinimizeButton() const { return HasFlag(buttonMinimize); }
    bool HasPinButton() const { return HasFlag(buttonPin); }
    
    wxPaneInfo& Window(wxWindow* w) { m_Window = w; return *this; }
    wxPaneInfo& Name(const wxString& n) { m_Name = n; return *this; }
    wxPaneInfo& Caption(const wxString& c) { m_Caption = c; return *this; }
    wxPaneInfo& Left() { m_DockDirection = wxAUI_DOCK_LEFT; return *this; }
    wxPaneInfo& Right() { m_DockDirection = wxAUI_DOCK_RIGHT; return *this; }
    wxPaneInfo& Top() { m_DockDirection = wxAUI_DOCK_TOP; return *this; }
    wxPaneInfo& Bottom() { m_DockDirection = wxAUI_DOCK_BOTTOM; return *this; }
    wxPaneInfo& Center() { m_DockDirection = wxAUI_DOCK_CENTER; return *this; }
    wxPaneInfo& Centre() { m_DockDirection = wxAUI_DOCK_CENTRE; return *this; }
    wxPaneInfo& Direction(int direction) { m_DockDirection = direction; return *this; }
    wxPaneInfo& Layer(int layer) { m_DockLayer = layer; return *this; }
    wxPaneInfo& Row(int row) { m_DockRow = row; return *this; }
    wxPaneInfo& Position(int pos) { m_DockPos = pos; return *this; }
    wxPaneInfo& BestSize(const wxSize& size) { m_BestSize = size; return *this; }
    wxPaneInfo& MinSize(const wxSize& size) { m_MinSize = size; return *this; }
    wxPaneInfo& MaxSize(const wxSize& size) { m_MaxSize = size; return *this; }
    wxPaneInfo& BestSize(int x, int y) { m_BestSize.Set(x,y); return *this; }
    wxPaneInfo& MinSize(int x, int y) { m_MinSize.Set(x,y); return *this; }
    wxPaneInfo& MaxSize(int x, int y) { m_MaxSize.Set(x,y); return *this; }
    wxPaneInfo& FloatingPosition(const wxPoint& pos) { m_FloatingPos = pos; return *this; }
    wxPaneInfo& FloatingPosition(int x, int y) { m_FloatingPos.x = x; m_FloatingPos.y = y; return *this; }
    wxPaneInfo& FloatingSize(const wxSize& size) { m_FloatingSize = size; return *this; }
    wxPaneInfo& FloatingSize(int x, int y) { m_FloatingSize.Set(x,y); return *this; }
    wxPaneInfo& Fixed() { return SetFlag(optionResizable, false); }
    wxPaneInfo& Resizable(bool resizable = true) { return SetFlag(optionResizable, resizable); }
    wxPaneInfo& Dock() { return SetFlag(optionFloating, false); }
    wxPaneInfo& Float() { return SetFlag(optionFloating, true); }
    wxPaneInfo& Hide() { return SetFlag(optionHidden, true); }
    wxPaneInfo& Show(bool show = true) { return SetFlag(optionHidden, !show); }
    wxPaneInfo& CaptionVisible(bool visible = true) { return SetFlag(optionCaption, visible); }
    wxPaneInfo& PaneBorder(bool visible = true) { return SetFlag(optionPaneBorder, visible); }
    wxPaneInfo& Gripper(bool visible = true) { return SetFlag(optionGripper, visible); }
    wxPaneInfo& CloseButton(bool visible = true) { return SetFlag(buttonClose, visible); }
    wxPaneInfo& MaximizeButton(bool visible = true) { return SetFlag(buttonMaximize, visible); }
    wxPaneInfo& MinimizeButton(bool visible = true) { return SetFlag(buttonMinimize, visible); }
    wxPaneInfo& PinButton(bool visible = true) { return SetFlag(buttonPin, visible); }
    wxPaneInfo& DestroyOnClose(bool b = true) { return SetFlag(optionDestroyOnClose, b); }
    wxPaneInfo& TopDockable(bool b = true) { return SetFlag(optionTopDockable, b); }
    wxPaneInfo& BottomDockable(bool b = true) { return SetFlag(optionBottomDockable, b); }
    wxPaneInfo& LeftDockable(bool b = true) { return SetFlag(optionLeftDockable, b); }
    wxPaneInfo& RightDockable(bool b = true) { return SetFlag(optionRightDockable, b); } 
    wxPaneInfo& Floatable(bool b = true) { return SetFlag(optionFloatable, b); }
    wxPaneInfo& Movable(bool b = true) { return SetFlag(optionMovable, b); }
    wxPaneInfo& Dockable(bool b = true)
    {
        return TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b);
    }
 
    wxPaneInfo& DefaultPane()
    {
        m_State |= optionTopDockable | optionBottomDockable |
                 optionLeftDockable | optionRightDockable |
                 optionFloatable | optionMovable | optionResizable |
                 optionCaption | optionPaneBorder | buttonClose;
        return *this;
    }
    
    wxPaneInfo& CentrePane() { return CenterPane(); }
    wxPaneInfo& CenterPane()
    {
        m_State = 0;
        return Center().PaneBorder().Resizable();
    }
    
    wxPaneInfo& ToolbarPane()
    {
        DefaultPane();
        m_State |= (optionToolbar | optionGripper);
        m_State &= ~(optionResizable | optionCaption);
        if (m_DockLayer == 0)
            m_DockLayer = 10;
        return *this;
    }
 
    wxPaneInfo& SetFlag(unsigned int flag, bool option_state)
    {
        if (option_state)
            m_State |= flag;
             else
            m_State &= ~flag;
        return *this;
    }
    
    bool HasFlag(unsigned int flag) const
    {
        return (m_State & flag) ? true:false;
    }
 
public:
 
    enum wxPaneState
    {
        optionFloating        = 1 << 0,
        optionHidden          = 1 << 1,
        optionLeftDockable    = 1 << 2,
        optionRightDockable   = 1 << 3,
        optionTopDockable     = 1 << 4,
        optionBottomDockable  = 1 << 5,
        optionFloatable       = 1 << 6,
        optionMovable         = 1 << 7,
        optionResizable       = 1 << 8,
        optionPaneBorder      = 1 << 9,
        optionCaption         = 1 << 10,
        optionGripper         = 1 << 11,
        optionDestroyOnClose  = 1 << 12,
        optionToolbar         = 1 << 13,
        optionActive          = 1 << 14,
 
        buttonClose           = 1 << 24,
        buttonMaximize        = 1 << 25,
        buttonMinimize        = 1 << 26,
        buttonPin             = 1 << 27,
        buttonCustom1         = 1 << 28,
        buttonCustom2         = 1 << 29,
        buttonCustom3         = 1 << 30,
        actionPane            = 1 << 31  // used internally
    };
 
public:
    wxString m_Name;        // name of the pane
    wxString m_Caption;     // caption displayed on the window
 
    wxWindow* m_Window;     // window that is in this pane
    wxWindow* m_Frame;      // floating frame window that holds the pane
    unsigned int m_State;   // a combination of wxPaneState values
 
    int m_DockDirection;   // dock direction (top, bottom, left, right, center)
    int m_DockLayer;       // layer number (0 = innermost layer)
    int m_DockRow;         // row number on the docking bar (0 = first row)
    int m_DockPos;         // position inside the row (0 = first position)
 
    wxSize m_BestSize;     // size that the layout engine will prefer
    wxSize m_MinSize;      // minimum size the pane window can tolerate
    wxSize m_MaxSize;      // maximum size the pane window can tolerate
 
    wxPoint m_FloatingPos; // position while floating
    wxSize m_FloatingSize; // size while floating
    int m_DockProportion;  // proportion while docked
 
    wxPaneButtonArray m_Buttons; // buttons on the pane
 
    wxRect m_Rect;              // current rectangle (populated by wxAUI)
};
 
 
 
 
class ALBA_EXPORT wxFrameManager : public wxEvtHandler
{
friend class wxFloatingPane;
 
public:
 
    wxFrameManager(wxFrame* frame = NULL,
                   unsigned int flags = wxAUI_MGR_DEFAULT);
    virtual ~wxFrameManager();
    void UnInit();
    
    void SetFlags(unsigned int flags);
    unsigned int GetFlags() const;
    
    void SetFrame(wxFrame* frame);
    wxFrame* GetFrame() const;
    
    void SetArtProvider(wxDockArt* art_provider);
    wxDockArt* GetArtProvider() const;
 
    wxPaneInfo& GetPane(wxWindow* window);
    wxPaneInfo& GetPane(const wxString& name);
    wxPaneInfoArray& GetAllPanes();
 
    virtual bool AddPane(wxWindow* window,
                 const wxPaneInfo& pane_info);
    
    virtual bool AddPane(wxWindow* window,
                 int direction = wxLEFT,
                 const wxString& caption = wxEmptyString);
    bool InsertPane(wxWindow* window,
                 const wxPaneInfo& pane_info,
                 int insert_level = wxAUI_INSERT_PANE);
              
    bool DetachPane(wxWindow* window);
 
    wxString SavePerspective();
    
    bool LoadPerspective(const wxString& perspective,
                 bool update = true);
    
    virtual void Update();
 
private:
    void DrawHintRect(wxWindow* pane_window,
                       const wxPoint& pt,
                       const wxPoint& offset);
    void DoFrameLayout();
 
    void LayoutAddPane(wxSizer* container,
                       wxDockInfo& dock,
                       wxPaneInfo& pane,
                       wxDockUIPartArray& uiparts,
                       bool spacer_only);
    void LayoutAddDock(wxSizer* container,
                       wxDockInfo& dock,
                       wxDockUIPartArray& uiparts,
                       bool spacer_only);
    wxSizer* LayoutAll(wxPaneInfoArray& panes,
                       wxDockInfoArray& docks,
                       wxDockUIPartArray& uiparts,
                       bool spacer_only = false);
    bool DoDrop(wxDockInfoArray& docks,
                wxPaneInfoArray& panes,
                wxPaneInfo& drop,
                const wxPoint& pt,
                const wxPoint& action_offset = wxPoint(0,0));
 
    wxPaneInfo& LookupPane(wxWindow* window);
    wxPaneInfo& LookupPane(const wxString& name);
    wxDockUIPart* HitTest(int x, int y);
    wxDockUIPart* GetPanePart(wxWindow* pane);
    int GetDockPixelOffset(wxPaneInfo& test);
    void OnFloatingPaneMoveStart(wxWindow* window);
    void OnFloatingPaneMoving(wxWindow* window);
    void OnFloatingPaneMoved(wxWindow* window);
    void OnFloatingPaneActivated(wxWindow* window);
    void OnFloatingPaneClosed(wxWindow* window);
    void OnFloatingPaneResized(wxWindow* window, const wxSize& size);
    void Render(wxDC* dc);
    void Repaint(wxDC* dc = NULL);
    void ProcessMgrEvent(wxFrameManagerEvent& event);
    void UpdateButtonOnScreen(wxDockUIPart* button_ui_part,
                              const wxMouseEvent& event);
    void GetPanePositionsAndSizes(wxDockInfo& dock,
                              wxArrayInt& positions,
                              wxArrayInt& sizes);
    void ShowHint(const wxRect& rect);
    void HideHint();
    void RemoveHint();
 
private:
 
    void OnPaint(wxPaintEvent& event);
    void OnEraseBackground(wxEraseEvent& event);
    void OnSize(wxSizeEvent& event);
    void OnSetCursor(wxSetCursorEvent& event);
    void OnLeftDown(wxMouseEvent& event);
    void OnLeftUp(wxMouseEvent& event);
    void OnMotion(wxMouseEvent& event);
    void OnLeaveWindow(wxMouseEvent& event);
    virtual void OnPaneButton(wxFrameManagerEvent& event);
    void OnChildFocus(wxChildFocusEvent& event);
    void OnHintFadeTimer(wxTimerEvent& event);
 
private:
 
    enum
    {
        actionNone = 0,
        actionResize,
        actionClickButton,
        actionClickCaption,
        actionDragToolbarPane,
        actionDragFloatingPane
    };
 
protected:
 
    wxFrame* m_Frame;            // the frame being managed
    wxDockArt* m_Art;            // dock art object which does all drawing
    unsigned int m_Flags;        // manager flags wxAUI_MGR_*
 
    wxPaneInfoArray m_PanesArray;     // array of panes structures
    wxDockInfoArray m_Docks;     // array of docks structures
    wxDockUIPartArray m_UIParts; // array of UI parts (captions, buttons, etc)
 
    int m_Action;                // current mouse action
    wxPoint m_ActionStart;      // position where the action click started
    wxPoint m_ActionOffset;     // offset from upper left of the item clicked
    wxDockUIPart* m_ActionPart; // ptr to the part the action happened to
    wxWindow* m_ActionWindow;   // action frame or window (NULL if none)
    wxRect m_ActionHintRect;    // hint rectangle for the action
    wxDockUIPart* m_HoverButton;// button ui part being hovered over
    wxRect m_LastHint;          // last hint rectangle
    wxPoint m_LastMouseMove;   // last mouse move position (see OnMotion)
 
    wxWindow* m_HintWnd;        // transparent hint window (for now, only msw)
    wxTimer m_HintFadeTimer;    // transparent fade timer (for now, only msw)
    int m_HintFadeAmount;          // transparent fade amount (for now, only msw)
    
    DECLARE_EVENT_TABLE()
};
 
 
class ALBA_EXPORT wxFrameManagerEvent : public wxEvent
{
public:
    wxFrameManagerEvent(wxEventType type) : wxEvent(0, type)
    {
        m_Pane = NULL;
        m_Button = 0;
    }
 
    wxFrameManagerEvent(const wxFrameManagerEvent& c) : wxEvent(c)
    {
        m_Pane = c.m_Pane;
        m_Button = c.m_Button;
    }
 
    wxEvent *Clone() const { return new wxFrameManagerEvent(*this); }
 
    void SetPane(wxPaneInfo* p) { m_Pane = p; }
    void SetButton(int b) { m_Button = b; }
    wxPaneInfo* GetPane() { return m_Pane; }
    int GetButton() { return m_Button; }
 
public:
    wxPaneInfo* m_Pane;
    int m_Button;
};
 
 
 
 
class ALBA_EXPORT wxDockArt
{
public:
    wxDockArt() { }
    virtual ~wxDockArt() { }
 
    virtual int GetMetric(int id) = 0;
    virtual void SetMetric(int id, int new_val) = 0;
    virtual void SetFont(int id, const wxFont& font) = 0;
    virtual wxFont GetFont(int id) = 0;
    virtual wxColour GetColour(int id) = 0;
    virtual void SetColour(int id, const wxColor& colour) = 0;
    wxColor GetColor(int id) { return GetColour(id); }
    void SetColor(int id, const wxColor& color) { SetColour(id, color); }
    
    virtual void DrawSash(wxDC& dc,
                          int orientation,
                          const wxRect& rect) = 0;
    virtual void DrawBackground(wxDC& dc,
                          int orientation,
                          const wxRect& rect) = 0;
    virtual void DrawCaption(wxDC& dc,
                          const wxString& text,
                          const wxRect& rect,
                          wxPaneInfo& pane) = 0;
    virtual void DrawGripper(wxDC& dc,
                          const wxRect& rect,
                          wxPaneInfo& pane) = 0;
    virtual void DrawBorder(wxDC& dc,
                          const wxRect& rect,
                          wxPaneInfo& pane) = 0;
 
    virtual void DrawPaneButton(wxDC& dc,
                          int button,
                          int button_state,
                          const wxRect& rect,
                          wxPaneInfo& pane) = 0;
};
 
 
class ALBA_EXPORT wxDefaultDockArt : public wxDockArt
{
public:
    wxDefaultDockArt();
 
    int GetMetric(int metric_id);
    void SetMetric(int metric_id, int new_val);
    wxColour GetColour(int id);
    void SetColour(int id, const wxColor& colour);
    void SetFont(int id, const wxFont& font);
    wxFont GetFont(int id);
 
    void DrawSash(wxDC& dc,
                  int orientation,
                  const wxRect& rect);
    void DrawBackground(wxDC& dc,
                  int orientation,
                  const wxRect& rect);
    void DrawCaption(wxDC& dc,
                  const wxString& text,
                  const wxRect& rect,
                  wxPaneInfo& pane);
    void DrawGripper(wxDC& dc,
                  const wxRect& rect,
                  wxPaneInfo& pane);
 
    void DrawBorder(wxDC& dc,
                  const wxRect& rect,
                  wxPaneInfo& pane);
    void DrawPaneButton(wxDC& dc,
                  int button,
                  int button_state,
                  const wxRect& rect,
                  wxPaneInfo& pane);
 
protected:
    void DrawCaptionBackground(wxDC& dc, const wxRect& rect, bool active);
 
protected:
 
    wxPen m_BorderPen;
    wxBrush m_SashBrush;
    wxBrush m_BackgroundBrush;
    wxBrush m_GripperBrush;
    wxFont m_CaptionFont;
    wxBitmap m_InactiveCloseBitmap;
    wxBitmap m_InactivePinBitmap;
    wxBitmap m_ActiveCloseBitmap;
    wxBitmap m_ActivePinBitmap;
    wxPen m_GripperPen1;
    wxPen m_GripperPen2;
    wxPen m_GripperPen3;
    wxColour m_ActiveCaptionColour;
    wxColour m_ActiveCaptionGradientColour;
    wxColour m_ActiveCaptionTextColour;
    wxColour m_InactiveCaptionColour;
    wxColour m_InactiveCaptionGradientColour;
    wxColour m_InactiveCaptionTextColour;
    int m_BorderSize;
    int m_CaptionSize;
    int m_SashSize;
    int m_ButtonSize;
    int m_GripperSize;
    int m_GradientType;
};
 
class ALBA_EXPORT wxDockInfo
{
public:
    wxDockInfo()
    {
        m_DockDirection = 0;
        m_DockLayer = 0;
        m_DockRow = 0;
        m_Size = 0;
        m_MinSize = 0;
        m_Resizable = true;
        m_Fixed = false;
        m_Toolbar = false;
    }
    wxDockInfo(const wxDockInfo& c)
    {
        m_DockDirection = c.m_DockDirection;
        m_DockLayer = c.m_DockLayer;
        m_DockRow = c.m_DockRow;
        m_Size = c.m_Size;
        m_MinSize = c.m_MinSize;
        m_Resizable = c.m_Resizable;
        m_Fixed = c.m_Fixed;
        m_Toolbar = c.m_Toolbar;
        m_Panes = c.m_Panes;
        m_Rect = c.m_Rect;
    }
    wxDockInfo& operator=(const wxDockInfo& c)
    {
        m_DockDirection = c.m_DockDirection;
        m_DockLayer = c.m_DockLayer;
        m_DockRow = c.m_DockRow;
        m_Size = c.m_Size;
        m_MinSize = c.m_MinSize;
        m_Resizable = c.m_Resizable;
        m_Fixed = c.m_Fixed;
        m_Toolbar = c.m_Toolbar;
        m_Panes = c.m_Panes;
        m_Rect = c.m_Rect;
        return *this;
    }
    bool IsOk() const { return (m_DockDirection != 0) ? true : false; }
    bool IsHorizontal() const { return (m_DockDirection == wxAUI_DOCK_TOP ||
                             m_DockDirection == wxAUI_DOCK_BOTTOM) ? true:false; }
    bool IsVertical() const { return (m_DockDirection == wxAUI_DOCK_LEFT ||
                             m_DockDirection == wxAUI_DOCK_RIGHT ||
                             m_DockDirection == wxAUI_DOCK_CENTER) ? true:false; }
public:
    wxPaneInfoPtrArray m_Panes; // array of panes
    wxRect m_Rect;              // current rectangle
    int m_DockDirection;       // dock direction (top, bottom, left, right, center)
    int m_DockLayer;           // layer number (0 = innermost layer)
    int m_DockRow;             // row number on the docking bar (0 = first row)
    int m_Size;                 // size of the dock
    int m_MinSize;             // minimum size of a dock (0 if there is no min)
    bool m_Resizable;           // flag indicating whether the dock is resizable
    bool m_Toolbar;             // flag indicating dock contains only toolbars
    bool m_Fixed;               // flag indicating that the dock operates on
                              // absolute coordinates as opposed to proportional
};
 
class ALBA_EXPORT wxDockUIPart
{
public:
    enum
    {
        typeCaption,
        typeGripper,
        typeDock,
        typeDockSizer,
        typePane,
        typePaneSizer,
        typeBackground,
        typePaneBorder,
        typePaneButton,
    };
 
    int m_Type;                // ui part type (see enum above)
    int m_Orientation;         // orientation (either wxHORIZONTAL or wxVERTICAL)
    wxDockInfo* m_Dock;        // which dock the item is associated with
    wxPaneInfo* m_Pane;        // which pane the item is associated with
    wxPaneButton* m_Button;    // which pane button the item is associated with
    wxSizer* m_ContSizer;     // the part's containing sizer
    wxSizerItem* m_SizerItem; // the sizer item of the part
    wxRect m_Rect;             // client coord rectangle of the part itself
};
 
class ALBA_EXPORT wxPaneButton
{
public:
    int m_ButtonId;        // id of the button (e.g. buttonClose)
};
 
 
 
 
// wx event machinery
 
 
// right now the only event that works is wxEVT_AUI_PANEBUTTON. A full
// spectrum of events will be implemented in the next incremental version
 
BEGIN_DECLARE_EVENT_TYPES()
    DECLARE_EXPORTED_EVENT_TYPE(ALBA_EXPORT,wxEVT_AUI_PANEBUTTON, 0)
END_DECLARE_EVENT_TYPES()
 
typedef void (wxEvtHandler::*wxFrameManagerEventFunction)(wxFrameManagerEvent&);
 
#define wxFrameManagerEventHandler(func) \
    (wxObjectEventFunction)(wxEventFunction)wxStaticCastEvent(wxFrameManagerEventFunction, &func)
 
#define EVT_AUI_PANEBUTTON(func) \
   wx__DECLARE_EVT0(wxEVT_AUI_PANEBUTTON, wxFrameManagerEventHandler(func))
 
 
 
 
 
class ALBA_EXPORT albaGUIDockManager : public wxFrameManager 
{
public:
  virtual bool AddPane(wxWindow* window,const wxPaneInfo& pane_info, const wxString &menu = _("&View"), const wxString &subMenu = wxEmptyString);
  virtual bool AddPane(wxWindow* window,int direction = wxLEFT,const wxString& caption = wxEmptyString); 
  virtual void Update();
protected:
   void AddMenuItem(wxWindow* window,const wxString& caption = wxEmptyString, const wxString &menu = _("&View"), const wxString &subMenu = wxEmptyString );
  void UpdateMenuItems();
};  
 
 
#endif  //__albaGUIDockManager__