--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: No names yet.
+// Purpose: Central header file for control-bar related classes
+//
+// Author: Aleksandras Gluchovas <mailto:alex@soften.ktu.lt>
+// Modified by:
+// Created: 06/09/98
+// RCS-ID: $Id$
+// Copyright: (c) Aleksandras Gluchovas
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef __CONTROLBAR_G__
+#define __CONTROLBAR_G__
+
+#ifdef __GNUG__
+#pragma interface "controlbar.h"
+#endif
+
+#include "wx/defs.h"
+#include "wx/string.h"
+#include "wx/window.h"
+#include "wx/dynarray.h"
+
+#define WXCONTROLBAR_VERSION 1.3
+
+// forward declarations
+
+class wxFrameLayout;
+
+class cbDockPane;
+class cbUpdatesManagerBase;
+class cbBarDimHandlerBase;
+class cbPluginBase;
+class cbPluginEvent;
+class cbPaneDrawPlugin;
+
+class cbBarInfo;
+class cbRowInfo;
+class cbDimInfo;
+class cbCommonPaneProperties;
+
+typedef cbBarInfo* BarInfoPtrT;
+typedef cbRowInfo* RowInfoPtrT;
+
+WX_DEFINE_ARRAY( BarInfoPtrT, BarArrayT );
+WX_DEFINE_ARRAY( RowInfoPtrT, RowArrayT );
+
+// control bar states
+
+#define wxCBAR_DOCKED_HORIZONTALLY 0
+#define wxCBAR_DOCKED_VERTICALLY 1
+#define wxCBAR_FLOATING 2
+#define wxCBAR_HIDDEN 3
+
+// the states are enumerated above
+#define MAX_BAR_STATES 4
+
+// control bar alignments
+
+#if !defined(wxTOP)
+
+#define wxTOP 0
+#define wxBOTTOM 1
+#define wxLEFT 2
+#define wxRIGHT 3
+
+#endif
+
+// one pane for each alignment
+#define MAX_PANES 4
+
+// masks for each pane
+
+#define wxTOP_PANE 0x0001
+#define wxBOTTOM_PANE 0x0002
+#define wxLEFT_PANE 0x0004
+#define wxRIGHT_PANE 0x0008
+
+#define wxALL_PANES 0x000F
+
+// enumeration of hittest results, see cbDockPane::HitTestPaneItems(..)
+
+enum CB_HITTEST_RESULT
+{
+ CB_NO_ITEMS_HITTED,
+
+ CB_UPPER_ROW_HANDLE_HITTED,
+ CB_LOWER_ROW_HANDLE_HITTED,
+ CB_LEFT_BAR_HANDLE_HITTED,
+ CB_RIGHT_BAR_HANDLE_HITTED,
+ CB_BAR_CONTENT_HITTED
+};
+
+// FIXME:: somehow in debug v. originall wxASSERT's are not compiled in...
+
+//#undef wxASSERT
+//#define wxASSERT(x) if ( !(x) ) throw;
+
+// helper class, used for spying for not-handled mouse events on control-bars
+// and forwarding them to the frame layout
+
+class cbBarSpy : public wxEvtHandler
+{
+public:
+ DECLARE_DYNAMIC_CLASS( cbBarSpy )
+
+ wxFrameLayout* mpLayout;
+ wxWindow* mpBarWnd;
+
+public:
+ cbBarSpy(void);
+
+ cbBarSpy( wxFrameLayout* pPanel );
+
+ void SetBarWindow( wxWindow* pWnd );
+
+ // overriden
+
+ virtual bool ProcessEvent(wxEvent& event);
+};
+
+/* wxFrameLayout manages containment and docking of control bars.
+ * which can be docked along top, bottom, righ, or left side of the
+ * parent frame
+ */
+
+class wxFrameLayout : public wxEvtHandler
+{
+public:
+ DECLARE_DYNAMIC_CLASS( wxFrameLayout )
+
+public: /* protected really, acessed only by plugins and serializers */
+
+ friend class cbDockPane;
+ friend class wxBarHandler;
+
+ wxWindow* mpFrame; // parent frame
+ wxWindow* mpFrameClient; // client window
+ cbDockPane* mPanes[MAX_PANES]; // panes in the panel
+
+ // misc. cursors
+ wxCursor* mpHorizCursor;
+ wxCursor* mpVertCursor;
+ wxCursor* mpNormalCursor;
+ wxCursor* mpDragCursor;
+ wxCursor* mpNECursor; // no-entry cursor
+
+ // pens for decoration and shades
+
+ wxPen mDarkPen; // default wxColour(128,128,128)
+ wxPen mLightPen; // default white
+ wxPen mGrayPen; // default wxColour(192,192,192)
+ wxPen mBlackPen; // default wxColour( 0, 0, 0)
+ wxPen mBorderPen; // default wxColour(128,192,192)
+
+ wxPen mNullPen; // transparent pen
+
+ // pane to which the all mouse input is currently directed (caputred)
+
+ cbDockPane* mpPaneInFocus;
+
+ // pane, from which mouse pointer had just leaft
+
+ cbDockPane* mpLRUPane;
+
+ // bounds of client window in parent frame's coordinates
+
+ wxRect mClntWndBounds;
+ wxRect mPrevClntWndBounds;
+
+ bool mFloatingOn;
+ wxPoint mNextFloatedWndPos;
+ wxSize mFloatingPosStep;
+
+ // current plugin (right-most) plugin which receives events first
+
+ cbPluginBase* mpTopPlugin;
+
+ // plugin, which currently has caputred all input events, otherwise NULL
+
+ cbPluginBase* mpCaputesInput;
+
+ // list of event handlers which are "pushed" onto each bar, to catch
+ // mouse events which are not handled by bars, and froward them to the ,
+ // frome-layout and further to plugins
+
+ wxList mBarSpyList;
+
+ // list of top-most frames which contain floated bars
+
+ wxList mFloatedFrames;
+
+ // linked list of references to all bars (docked/floated/hidden)
+
+ BarArrayT mAllBars;
+
+ // FOR NOW:: dirty stuff...
+ bool mClientWndRefreshPending;
+ bool mRecalcPending;
+ bool mCheckFocusWhenIdle;
+
+public: /* protected really (accessed only by plugins) */
+
+ // refrence to custom updates manager
+ cbUpdatesManagerBase* mpUpdatesMgr;
+
+ // called to set calculated layout to window objects
+ void PositionClientWindow();
+ void PositionPanes();
+ void CreateCursors();
+
+ void RepositionFloatedBar( cbBarInfo* pBar );
+ void DoSetBarState( cbBarInfo* pBar );
+
+ bool LocateBar( cbBarInfo* pBarInfo,
+ cbRowInfo** ppRow,
+ cbDockPane** ppPane );
+
+
+ bool HitTestPane( cbDockPane* pPane, int x, int y );
+ cbDockPane* HitTestPanes( const wxRect& rect, cbDockPane* pCurPane );
+
+ // returns panes, to which the given bar belongs
+
+ cbDockPane* GetBarPane( cbBarInfo* pBar );
+
+ // delegated from "bar-spy"
+ void ForwardMouseEvent( wxMouseEvent& event,
+ cbDockPane* pToPane,
+ int eventType );
+
+ void RouteMouseEvent( wxMouseEvent& event, int pluginEvtType );
+
+ void ShowFloatedWindows( bool show );
+
+ void UnhookFromFrame();
+ void HookUpToFrame();
+
+ // NOTE:: reparenting of windows may NOT work on all platforms
+ // (reparenting allows control-bars to be floated)
+
+ bool CanReparent();
+ void ReparentWindow( wxWindow* pChild, wxWindow* pNewParent );
+
+ wxRect& GetPrevClientRect() { return mPrevClntWndBounds; }
+
+ void OnPaint( wxPaintEvent& event );
+ void OnEraseBackground( wxEraseEvent& event );
+ void OnKillFocus( wxFocusEvent& event );
+ void OnSetFocus( wxFocusEvent& event );
+ void OnActivate( wxActivateEvent& event );
+ void OnIdle( wxIdleEvent& event );
+
+ // factory method
+ virtual cbUpdatesManagerBase* CreateUpdatesManager();
+
+public: /* public members */
+
+ wxFrameLayout(void); // used only while serializing
+
+ wxFrameLayout( wxWindow* pParentFrame,
+ wxWindow* pFrameClient = NULL,
+ bool activateNow = TRUE );
+
+ // (doesn't destory bar windows)
+ virtual ~wxFrameLayout();
+
+ // (by default floating of control-bars is ON)
+ virtual void EnableFloating( bool enable = TRUE );
+
+ // Can be called after some other layout has been deactivated,
+ // and this one must "take over" the current contents of frame window.
+ //
+ // Effectivelly hooks itself to the frame window, re-displays all not-hidden
+ // bar-windows and repaints decorations
+
+ virtual void Activate();
+
+ // unhooks itself from frame window, and hides all not-hidden windows
+ //
+ // NOTE:: two frame-layouts should not be active at the same time in the
+ // same frame window, it would cause messy overlapping of bar windows
+ // from both layouts
+
+ virtual void Deactivate();
+
+ // also hides the client window if presents
+
+ void HideBarWindows();
+
+ virtual void DestroyBarWindows();
+
+ // passes the client window (e.g. MDI-client frame) to be controled by
+ // frame layout, the size and position of which should be adjusted to be
+ // surrounded by controlbar panes, whenever frame is resized, or dimesnions
+ // of control panes change
+
+ void SetFrameClient( wxWindow* pFrameClient );
+
+ wxWindow* GetFrameClient();
+
+ wxWindow& GetParentFrame() { return *mpFrame; }
+
+ // used by updates-managers
+ cbDockPane** GetPanesArray() { return mPanes; }
+
+ // see pane alignment types
+ cbDockPane* GetPane( int alignment )
+
+ { return mPanes[alignment]; }
+
+ // Adds bar information to frame-layout, appearence of layout is not refreshed
+ // immediatelly, RefreshNow() can be called if necessary.
+ //
+ // NOTES:: argument pBarWnd can by NULL, resulting bar decorations to be drawn
+ // around the empty rectangle (filled with default background colour).
+ // Argument dimInfo, can be re-used for adding any number of bars, since
+ // it is not used directly, instead it's members are copied. If dimensions-
+ // handler is present, it's instance shared (reference counted). Dimension
+ // handler should always be allocated on the heap!)
+
+ virtual void AddBar( wxWindow* pBarWnd,
+ cbDimInfo& dimInfo,
+
+ // defaults:
+
+ int alignment = wxTOP,
+ int rowNo = 0, // vert. position - row in the pane (if docked state)
+ int columnPos = 0, // horiz. position in the row in pixels (if docked state)
+ const wxString& name="bar",// name, by which the bar could be referred
+ // in layout costumization dialogs
+
+ bool spyEvents = FALSE, // if TRUE - input events for the bar should
+ // be "spyed" in order to forward not-handled
+ // mouse clicks to frame layout (e.g. to enable
+ // easy-draggablity of toolbars just by clicking
+ // on their interior regions). For widgets like
+ // text/tree control this value should be FALSE
+ // (since there's _no_ certain way to detect
+ // whether the event was actually handled...)
+
+ int state = wxCBAR_DOCKED_HORIZONTALLY // e.g. wxCBAR_FLOATING
+ // or wxCBAR_HIDDEN
+ );
+
+ // can be used for repositioning already existing bars. The given bar is first removed
+ // from the pane it currently belongs to, and inserted into the pane, which "matches"
+ // the given recantular area. If pToPane is not NULL, bar is docked to this given pane
+
+ // to dock the bar which is floated, use wxFrameLayout::DockBar(..) method
+
+ virtual bool RedockBar( cbBarInfo* pBar, const wxRect& shapeInParent,
+ cbDockPane* pToPane = NULL, bool updateNow = TRUE );
+
+ // methods for access and modification of bars in frame layout
+
+ cbBarInfo* FindBarByName( const wxString& name );
+
+ BarArrayT& GetBars();
+
+ // changes bar's docking state (see possible control bar states)
+
+ void SetBarState( cbBarInfo* pBar, int newStatem, bool updateNow );
+
+ // reflects changes in bar information structure visually
+ // (e.g. moves bar, changes it's dimension info, pane to which it is docked)
+
+ void ApplyBarProperties( cbBarInfo* pBar );
+
+ // removes bar from layout permanently, hides it's corresponding window if present
+
+ void RemoveBar( cbBarInfo* pBar );
+
+ // recalcualtes layout of panes, and all bars/rows in each pane
+
+ virtual void RecalcLayout( bool repositionBarsNow = FALSE );
+
+ int GetClientHeight();
+ int GetClientWidth();
+ wxRect& GetClientRect() { return mClntWndBounds; }
+
+ // NOTE:: in future ubdates-manager will become a normal plugin
+
+ cbUpdatesManagerBase& GetUpdatesManager();
+
+ // destroys the previous manager if any, set the new one
+
+ void SetUpdatesManager( cbUpdatesManagerBase* pUMgr );
+
+ // NOTE:: changing properties of panes, does not result immediate on-screen update
+
+ virtual void GetPaneProperties( cbCommonPaneProperties& props, int alignment = wxTOP );
+
+ virtual void SetPaneProperties( const cbCommonPaneProperties& props,
+ int paneMask = wxALL_PANES );
+
+ // TODO:: margins should go into cbCommonPaneProperties in the future
+ //
+ // NOTE:: this method should be called before any custom plugins are attached
+
+ virtual void SetMargins( int top, int bottom, int left, int right,
+ int paneMask = wxALL_PANES );
+
+ virtual void SetPaneBackground( const wxColour& colour );
+
+ // recalculates layoute and performs on-screen update of all panes
+
+ void RefreshNow( bool recalcLayout = TRUE );
+
+ // event handlers
+
+ void OnSize ( wxSizeEvent& event );
+ void OnLButtonDown( wxMouseEvent& event );
+ void OnLDblClick ( wxMouseEvent& event );
+ void OnLButtonUp ( wxMouseEvent& event );
+ void OnRButtonDown( wxMouseEvent& event );
+ void OnRButtonUp ( wxMouseEvent& event );
+ void OnMouseMove ( wxMouseEvent& event );
+
+ /*** plugin-related methods ***/
+
+ // should be used, instead of passing the event to ProcessEvent(..) method
+ // of the top-plugin directly. This method checks if events are currently
+ // captured and ensures that plugin-event is routed correctly.
+
+ virtual void FirePluginEvent( cbPluginEvent& event );
+
+ // captures/releases user-input event's for the given plugin
+ // Input events are: mouse movement, mouse clicks, keyboard input
+
+ virtual void CaptureEventsForPlugin ( cbPluginBase* pPlugin );
+ virtual void ReleaseEventsFromPlugin( cbPluginBase* pPlugin );
+
+ // called by plugins ( also captures/releases mouse in parent frame)
+ void CaptureEventsForPane( cbDockPane* toPane );
+ void ReleaseEventsFromPane( cbDockPane* fromPane );
+
+ // returns current top-level plugin (the one which receives events first,
+ // with an exception if input-events are currently captured by some other plugin)
+
+ virtual cbPluginBase& GetTopPlugin();
+
+ // hooking custom plugins to frame layout
+ //
+ // NOTE:: when hooking one plugin on top of the other -
+ // use SetNextHandler(..) or similar methods
+ // of wxEvtHandler class to compose the chain of plugins,
+ // than pass the left-most handler in this chain to
+ // the above methods (assuming that events are delegated
+ // from left-most towards right-most handler)
+ //
+ // NOTE2:: this secenario is very inconvenient and "low-level",
+ // use Add/Push/PopPlugin methods instead
+
+ virtual void SetTopPlugin( cbPluginBase* pPlugin );
+
+ // similar to wxWindow's "push/pop-event-handler" methods, execept
+ // that plugin is *deleted* upon "popping"
+
+ virtual void PushPlugin( cbPluginBase* pPugin );
+ virtual void PopPlugin();
+
+ virtual void PopAllPlugins();
+
+ // default plugins are : cbPaneDrawPlugin, cbRowLayoutPlugin, cbBarDragPlugin,
+ // cbAntiflickerPlugin, cbSimpleCustomizePlugin
+ //
+ // this method is automatically invoked, if no plugins were found upon
+ // fireing of the first plugin-event, i.e. wxFrameLayout *CONFIGURES* itself
+
+ virtual void PushDefaultPlugins();
+
+ /* "Advanced" methods for plugin-configuration using their */
+ /* dynamic class information (e.g. CLASSINFO(pluginClass) ) */
+
+ // first checks if plugin of the given class is already "hooked up",
+ // if not, adds it to the top of plugins chain
+
+ virtual void AddPlugin( wxClassInfo* pPlInfo, int paneMask = wxALL_PANES );
+
+ // first checks if plugin of the givne class already hooked,
+ // if so, removes it, and then inserts it to the chain
+ // before plugin of the class given by "pNextPlInfo"
+ //
+ // NOTE:: this method is "handy" in some cases, where the order
+ // of plugin-chain could be important, e.g. one plugin overrides
+ // some functionallity of the other already hooked plugin,
+ // thefore the former should be hooked before the one
+ // who's functionality is being overriden
+
+ virtual void AddPluginBefore( wxClassInfo* pNextPlInfo, wxClassInfo* pPlInfo,
+ int paneMask = wxALL_PANES );
+
+ // checks if plugin of the given class is hooked, removes
+ // it if found
+ //
+ // @param pPlInfo class information structure for the plugin
+ // @note
+ // @see wxFrameLayout::Method
+
+
+ virtual void RemovePlugin( wxClassInfo* pPlInfo );
+
+ // returns NULL, if plugin of the given class is not hooked
+
+ virtual cbPluginBase* FindPlugin( wxClassInfo* pPlInfo );
+
+ bool HasTopPlugin();
+
+ DECLARE_EVENT_TABLE();
+};
+
+/* structure, which is present in each item of layout,
+ * it used by any specific updates-manager to store
+ * auxilary information to be used by it's specific
+ * updating algorithm
+ */
+
+class cbUpdateMgrData : public wxObject
+{
+ DECLARE_DYNAMIC_CLASS( cbUpdateMgrData )
+public:
+ wxRect mPrevBounds; // previous state of layout item (in parent frame's coordinates)
+
+ bool mIsDirty; // overrides result of current-against-previouse bounds comparison,
+ // i.e. requires item to be updated, regardless of it's current area
+
+ wxObject* mpCustomData; // any custom data stored by specific updates mgr.
+
+ cbUpdateMgrData(); // is-dirty flag is set TRUE initially
+
+ void StoreItemState( const wxRect& boundsInParent );
+
+ void SetDirty( bool isDirty = TRUE );
+
+ void SetCustomData( wxObject* pCustomData );
+
+ inline bool IsDirty() { return mIsDirty; }
+};
+
+/* Abstract inteface for bar-size handler classes.
+ * These objects receive notifications, whenever the docking
+ * state of the bar is changed, thus they have a possibility
+ * to adjust the values in cbDimInfo::mSizes accordingly.
+ * Specific handlers can be hooked to specific types of bars.
+ */
+
+class cbBarDimHandlerBase : public wxObject
+{
+ DECLARE_ABSTRACT_CLASS( cbBarDimHandlerBase )
+
+public:
+ int mRefCount; // since one dim-handler can be asigned
+ // to multiple bars, it's instance is
+ // refernce-counted
+public:
+
+ // inital refernce count is 0, since handler is not used, until the
+ // first invocation of AddRef()
+
+ cbBarDimHandlerBase();
+
+ void AddRef();
+ void RemoveRef();
+
+ // "bar-state-changes" notification
+ virtual void OnChangeBarState(cbBarInfo* pBar, int newState ) = 0;
+ virtual void OnResizeBar( cbBarInfo* pBar, const wxSize& given, wxSize& preferred ) = 0;
+};
+
+/* helper classes (used internally by wxFrameLayout class) */
+
+// holds and manages information about bar demensions
+
+class cbDimInfo : public wxObject
+{
+ DECLARE_DYNAMIC_CLASS( cbDimInfo )
+public:
+ wxSize mSizes[MAX_BAR_STATES]; // preferred sizes for each possible bar state
+
+ wxRect mBounds[MAX_BAR_STATES]; // saved positions and sizes for each
+ // possible state, values contain (-1)s if
+ // not initialized yet
+
+ int mLRUPane; // pane to which this bar was docked before it was floated
+ // (wxTOP,wxBOTTOM,..)
+
+ // top/bottom gap, separates decorations
+ // from the bar's actual window, filled
+ // with frame's beckground color, default: 0
+
+ int mVertGap;
+
+ // left/right gap, separates decorations
+ // from the bar's actual window, filled
+ // with frame's beckground colour, default: 0
+
+ int mHorizGap; // NOTE:: gaps are given in frame's coord. orientation
+
+ // TRUE, if vertical/horizotal dimensions cannot be mannualy adjusted
+ // by user using resizing handles. If FALSE, the frame-layout
+ // *automatically* places resizing handles among not-fixed bars
+
+ bool mIsFixed;
+
+ cbBarDimHandlerBase* mpHandler; // NULL, if no handler present
+
+public:
+
+ cbDimInfo(void);
+
+ cbDimInfo( cbBarDimHandlerBase* pDimHandler,
+ bool isFixed // (see comments on mIsFixed member)
+ );
+
+ cbDimInfo( int dh_x, int dh_y, // dims when docked horizontally
+ int dv_x, int dv_y, // dims when docked vertically
+ int f_x, int f_y, // dims when floating
+
+ bool isFixed = TRUE,// (see comments on mIsFixed member)
+ int horizGap = 6, // (see comments on mHorizGap member)
+ int vertGap = 6, // -/-
+
+ cbBarDimHandlerBase* pDimHandler = NULL
+ );
+
+ const cbDimInfo& operator=( cbDimInfo& other );
+
+ // destroys handler automatically, if present
+ ~cbDimInfo();
+
+ inline cbBarDimHandlerBase* GetDimHandler() { return mpHandler; }
+};
+
+WX_DEFINE_ARRAY(float, cbArrayFloat);
+
+class cbRowInfo : public wxObject
+{
+ DECLARE_DYNAMIC_CLASS( cbRowInfo )
+public:
+
+ BarArrayT mBars; // row content
+
+ // row flags (set up according to row-relations)
+
+ bool mHasUpperHandle;
+ bool mHasLowerHandle;
+ bool mHasOnlyFixedBars;
+ int mNotFixedBarsCnt;
+
+ int mRowWidth;
+ int mRowHeight;
+ int mRowY;
+
+ // stores precalculated row's bounds in parent frame's coordinates
+ wxRect mBoundsInParent;
+
+ // info stored for updates-manager
+ cbUpdateMgrData mUMgrData;
+
+ cbRowInfo* mpNext;
+ cbRowInfo* mpPrev;
+
+ cbBarInfo* mpExpandedBar; // NULL, if non of the bars is currently expanded
+
+ cbArrayFloat mSavedRatios; // length-ratios bofore some of the bars was expanded
+
+public:
+ cbRowInfo(void);
+
+ ~cbRowInfo();
+
+ // convenience method
+
+ inline cbBarInfo* GetFirstBar()
+
+ { return mBars.GetCount() ? mBars[0] : NULL; }
+};
+
+class cbBarInfo : public wxObject
+{
+ DECLARE_DYNAMIC_CLASS( cbBarInfo )
+public:
+ // textual name, by which this bar is refered in layout-costumization dialogs
+ wxString mName;
+
+ // stores bar's bounds in pane's coordinates
+ wxRect mBounds;
+
+ // stores precalculated bar's bounds in parent frame's coordinates
+ wxRect mBoundsInParent;
+
+ // back-ref to the row, which contains this bar
+ cbRowInfo* mpRow;
+
+ // are set up according to the types of the surrounding bars in the row
+ bool mHasLeftHandle;
+ bool mHasRightHandle;
+
+ cbDimInfo mDimInfo; // preferred sizes for each, control bar state
+
+ int mState; // (see definition of controlbar states)
+
+ int mAlignment; // alignment of the pane to which this
+ // bar is currently placed
+
+ int mRowNo; // row, into which this bar would be placed,
+ // when in the docking state
+
+ wxWindow* mpBarWnd; // the actual window object, NULL if no window
+ // is attached to the control bar (possible!)
+
+ double mLenRatio; // length ratio among not-fixed-size bars
+
+ wxPoint mPosIfFloated; // stored last position when bar was in "floated" state
+ // poistion is stored in parent-window's coordinates
+
+ cbUpdateMgrData mUMgrData; // info stored for updates-manager
+
+ cbBarInfo* mpNext; // next. bar in the row
+ cbBarInfo* mpPrev; // prev. bar in the row
+
+public:
+ cbBarInfo(void);
+
+ ~cbBarInfo();
+
+ inline bool IsFixed() const { return mDimInfo.mIsFixed; }
+
+ inline bool IsExpanded() const { return this == mpRow->mpExpandedBar; }
+};
+
+// used for storing original bar's postions in the row, when the "non-destructive-friction"
+// option is turned ON
+
+class cbBarShapeData : public wxObject
+{
+public:
+ wxRect mBounds;
+ double mLenRatio;
+};
+
+// used for traversing through all bars of all rows in the pane
+
+class wxBarIterator
+{
+ RowArrayT* mpRows;
+ cbRowInfo* mpRow;
+ cbBarInfo* mpBar;
+
+public:
+ wxBarIterator( RowArrayT& rows );
+
+ void Reset();
+ bool Next(); // TRUE, if next bar is available
+
+ cbBarInfo& BarInfo();
+
+ // returns reference to currently traversed row
+ cbRowInfo& RowInfo();
+};
+
+/* structure holds configuration options,
+ * which are usually the same for all panes in
+ * frame layout
+ */
+
+class cbCommonPaneProperties : public wxObject
+{
+ DECLARE_DYNAMIC_CLASS( cbCommonPaneProperties )
+
+ // look-and-feel configuration
+
+ bool mRealTimeUpdatesOn; // default: ON
+ bool mOutOfPaneDragOn; // default: ON
+ bool mExactDockPredictionOn; // default: OFF
+ bool mNonDestructFirctionOn; // default: OFF
+
+ bool mShow3DPaneBorderOn; // default: ON
+
+ // FOR NOW:: the below properties are reserved for the "future"
+
+ bool mBarFloatingOn; // default: OFF
+ bool mRowProportionsOn; // default: OFF
+ bool mColProportionsOn; // default: ON
+ bool mBarCollapseIconsOn; // default: OFF
+ bool mBarDragHintsOn; // default: OFF
+
+ // minimal dimensions for not-fixed bars in this pane (16x16 default)
+
+ wxSize mMinCBarDim;
+
+ // width/height of resizing sash
+
+ int mResizeHandleSize;
+
+ cbCommonPaneProperties(void);
+};
+
+/* class manages containment and control of control-bars
+ * along one of the four edges of the parent frame
+ */
+
+class cbDockPane : public wxObject
+{
+public:
+ DECLARE_DYNAMIC_CLASS( cbDockPane )
+
+ // look-and-feel configuration for this pane
+ cbCommonPaneProperties mProps;
+
+ // pane margins (in frame's coordinate-syst. orientation)
+
+ int mLeftMargin; // default: 2 pixels
+ int mRightMargin; // default: 2 pixels
+ int mTopMargin; // default: 2 pixels
+ int mBottomMargin; // default: 2 pixels
+
+public:
+ // position of the pane in frame's coordinates
+ wxRect mBoundsInParent;
+
+ // pane width and height in pane's coordinates
+ int mPaneWidth;
+ int mPaneHeight;
+
+ int mAlignment;
+
+ // info stored for updates-manager
+ cbUpdateMgrData mUMgrData;
+
+public: /* protected really */
+
+ RowArrayT mRows;
+ wxFrameLayout* mpLayout; // back-ref
+
+ // transient properties
+
+ wxList mRowShapeData; // shapes of bars of recently modified row,
+ // stored when in "non-destructive-firction" mode
+ cbRowInfo* mpStoredRow; // row-info for which the shapes are stored
+
+ friend class wxFrameLayout;
+
+public: /* protected really (accessed only by plugins) */
+
+ cbRowInfo* GetRow( int row );
+
+ int GetRowIndex( cbRowInfo* pRow );
+
+ // return -1, if row is not present at given vertical position
+ int GetRowAt( int paneY );
+ int GetRowAt( int upperY, int lowerY );
+
+ // re-setups flags in the row-information structure, so that
+ // the would match the changed state of row-items correctly
+ void SyncRowFlags( cbRowInfo* pRow );
+
+ // layout "AI" helpers:
+
+ bool IsFixedSize( cbBarInfo* pInfo );
+ int GetNotFixedBarsCount( cbRowInfo* pRow );
+
+ int GetRowWidth( wxList* pRow );
+
+ int GetRowY( cbRowInfo* pRow );
+
+ bool HasNotFixedRowsAbove( cbRowInfo* pRow );
+ bool HasNotFixedRowsBelow( cbRowInfo* pRow );
+ bool HasNotFixedBarsLeft ( cbBarInfo* pBar );
+ bool HasNotFixedBarsRight( cbBarInfo* pBar );
+
+ virtual void CalcLenghtRatios( cbRowInfo* pInRow );
+ virtual void RecalcRowLayout( cbRowInfo* pRow );
+
+ virtual void ExpandBar( cbBarInfo* pBar );
+ virtual void ContractBar( cbBarInfo* pBar );
+
+ void InitLinksForRow( cbRowInfo* pRow );
+ void InitLinksForRows();
+
+ // coordinate translation between parent's frame and this pane
+
+ void FrameToPane( long* x, long* y );
+ void PaneToFrame( long* x, long* y );
+ void FrameToPane( wxRect* pRect );
+ void PaneToFrame( wxRect* pRect );
+
+ inline bool HasPoint( const wxPoint& pos, int x, int y, int width, int height );
+
+ int GetMinimalRowHeight( cbRowInfo* pRow );
+
+ // given row height includes height of row handles, if present
+ void SetRowHeight( cbRowInfo* pRow, int newHeight );
+
+ void DoInsertBar( cbBarInfo* pBar, int rowNo );
+
+public: /* protected really (accessed only by plugins) */
+
+ // methods for incramental on-screen refreshing of the pane
+ // (simply, they are wrappers around corresponding plugin-events)
+
+ virtual void PaintBarDecorations( cbBarInfo* pBar, wxDC& dc );
+ virtual void PaintBarHandles( cbBarInfo* pBar, wxDC& dc );
+ virtual void PaintBar( cbBarInfo* pBar, wxDC& dc );
+ virtual void PaintRowHandles( cbRowInfo* pRow, wxDC& dc );
+ virtual void PaintRowBackground ( cbRowInfo* pRow, wxDC& dc );
+ virtual void PaintRowDecorations( cbRowInfo* pRow, wxDC& dc );
+ virtual void PaintRow( cbRowInfo* pRow, wxDC& dc );
+ virtual void PaintPaneBackground( wxDC& dc );
+ virtual void PaintPaneDecorations( wxDC& dc );
+ virtual void PaintPane( wxDC& dc );
+ virtual void SizeBar( cbBarInfo* pBar );
+ virtual void SizeRowObjects( cbRowInfo* pRow );
+ virtual void SizePaneObjects();
+
+ virtual wxDC* StartDrawInArea ( const wxRect& area );
+ virtual void FinishDrawInArea( const wxRect& area );
+
+public: /* public members */
+
+ cbDockPane(void);
+
+ cbDockPane( int alignment, wxFrameLayout* pPanel );
+
+ // sets pane's margins in frame's coordinate orientations
+ void SetMargins( int top, int bottom, int left, int right );
+
+ virtual ~cbDockPane();
+
+ // does not destroys the info bar , only removes it's reference
+ // from this pane
+
+ virtual void RemoveBar( cbBarInfo* pBar );
+
+ // rect given in the parent frame's coordinates
+
+ virtual void InsertBar( cbBarInfo* pBar, const wxRect& atRect );
+
+ // inserts bar into the given row, with dimensions and position
+ // stored in pBarInfo->mBounds. Returns the node of inserted bar
+
+ virtual void InsertBar( cbBarInfo* pBar, cbRowInfo* pIntoRow );
+
+ // inserts bar, sets its position according to the preferred settings
+ // given in (*pBarInfo) structure
+
+ virtual void InsertBar( cbBarInfo* pBarInfo );
+
+ // does not destroy the row object, only removes the corresponding
+ // node from this pane
+ virtual void RemoveRow( cbRowInfo* pRow );
+
+ // does not refresh the inserted row immediatelly,
+ // if pBeforeRowNode arg. is NULL, row is appended to the end of pane's row list
+ virtual void InsertRow( cbRowInfo* pRow, cbRowInfo* pBeforeRow );
+
+ // sets pane's width in pane's coordinates (including margins)
+ void SetPaneWidth(int width);
+
+ // set the position and dims. of the pane in parent frame's coordinates
+ void SetBoundsInParent( const wxRect& rect );
+
+ inline wxRect& GetRealRect() { return mBoundsInParent; }
+
+ // used by upadates-managers
+ inline RowArrayT& GetRowList() { return mRows; }
+
+ // convenience method
+
+ inline cbRowInfo* GetFirstRow()
+
+ { return mRows.GetCount() ? mRows[0] : NULL; }
+
+ // TRUE, if the given bar node presents in this pane
+
+ bool BarPresent( cbBarInfo* pBar );
+
+ // retuns height, in pane's coordinates
+ int GetPaneHeight();
+
+ int GetAlignment();
+
+ bool MatchesMask( int paneMask );
+
+ inline bool IsHorizontal()
+ {
+ return (mAlignment == wxTOP ||
+ mAlignment == wxBOTTOM );
+ }
+
+ virtual void RecalcLayout();
+
+ virtual int GetDockingState();
+
+ // returns result of hit-testing items in the pane,
+ // see CB_HITTEST_RESULTS enumeration
+
+ virtual int HitTestPaneItems( const wxPoint& pos, // position in pane's coorinates
+ cbRowInfo** ppRow,
+ cbBarInfo** ppBar
+ );
+
+ void GetBarResizeRange( cbBarInfo* pBar, int* from, int *till, bool forLeftHandle );
+ void GetRowResizeRange( cbRowInfo* pRow, int* from, int* till, bool forUpperHandle );
+
+ cbBarInfo* GetBarInfoByWindow( wxWindow* pBarWnd );
+
+public: /* protected really (accessed only by plugins) */
+
+ // row/bar resizing related helper-methods
+
+ void DrawVertHandle ( wxDC& dc, int x, int y, int height );
+ void DrawHorizHandle( wxDC& dc, int x, int y, int width );
+
+ void ResizeRow( cbRowInfo* pRow, int ofs, bool forUpperHandle );
+ void ResizeBar( cbBarInfo* pBar, int ofs, bool forLeftHandle );
+
+ // cbBarShapeData objects will be placed to given pLst (see comments on cbBarShapeData)
+
+ void GetRowShapeData( cbRowInfo* pRow, wxList* pLst );
+
+ // sets the shape to the given row, using the data provided in pLst
+ void SetRowShapeData( cbRowInfo* pRowNode, wxList* pLst );
+};
+
+/*
+ * class declares abstract interface for optimized logic, which should refresh
+ * areas of frame layout - that actually need to be updated. Should be extanded,
+ * to implemnet custom updating strategy
+ */
+
+class cbUpdatesManagerBase : public wxObject
+{
+ DECLARE_ABSTRACT_CLASS( cbUpdatesManagerBase )
+
+public: /* protected really, accessed by serializer (if any) */
+
+ wxFrameLayout* mpLayout;
+
+public:
+ cbUpdatesManagerBase(void)
+ : mpLayout( 0 ) {}
+
+ cbUpdatesManagerBase( wxFrameLayout* pPanel )
+ : mpLayout( pPanel ) {}
+
+ void SetLayout( wxFrameLayout* pLayout ) { mpLayout = pLayout; }
+
+ // notificiactions received from frame-layout (in the order, in which
+ // they usually would be invoked). Custom updates-managers may utilize
+ // these notifications to implement more "fine-grained" updating strategy
+
+ virtual void OnStartChanges() = 0;
+
+ virtual void OnRowWillChange( cbRowInfo* pRow, cbDockPane* pInPane ) {}
+ virtual void OnBarWillChange( cbBarInfo* pBar, cbRowInfo* pInRow, cbDockPane* pInPane ) {}
+ virtual void OnPaneMarginsWillChange( cbDockPane* pPane ) {}
+ virtual void OnPaneWillChange( cbDockPane* pPane ) {}
+
+ virtual void OnFinishChanges() {}
+
+ // refreshes parts of the frame layout, which need an update
+ virtual void UpdateNow() = 0;
+};
+
+/*------------------------------------------------------------
+ * "API" for developing custom plugins of Frame Layout Engine
+ * TODO:: documentation
+ *------------------------------------------------------------
+ */
+
+// base class for all control-bar plugin events
+
+class cbPluginEvent : public wxEvent
+{
+ // NOTE:: plugin-event does not need to be a dynamic class
+
+public:
+ cbDockPane* mpPane; // NULL, if event is not addressed to any specific pane
+
+ /* OLD STUFF::
+ // FOR NOW FOR NOW:: all-in-on plugin event structure
+ wxNode* mpObjNode;
+ wxNode* mpObjNodeAux;
+ wxPoint mPos;
+ wxSize mSize;
+ wxDC* mpDC;
+ bool mAuxBoolVal;
+ */
+
+ cbPluginEvent( int eventType, cbDockPane* pPane )
+ : mpPane( pPane )
+
+ { m_eventType = eventType; }
+};
+
+// event types handled by plugins
+
+#define cbEVT_PL_LEFT_DOWN 0
+#define cbEVT_PL_LEFT_UP 1
+#define cbEVT_PL_RIGHT_DOWN 2
+#define cbEVT_PL_RIGHT_UP 3
+#define cbEVT_PL_MOTION 4
+
+#define cbEVT_PL_LEFT_DCLICK 5
+
+#define cbEVT_PL_LAYOUT_ROW 6
+#define cbEVT_PL_RESIZE_ROW 7
+#define cbEVT_PL_LAYOUT_ROWS 8
+#define cbEVT_PL_INSERT_BAR 9
+#define cbEVT_PL_RESIZE_BAR 10
+#define cbEVT_PL_REMOVE_BAR 11
+#define cbEVT_PL_SIZE_BAR_WND 12
+
+#define cbEVT_PL_DRAW_BAR_DECOR 13
+#define cbEVT_PL_DRAW_ROW_DECOR 14
+#define cbEVT_PL_DRAW_PANE_DECOR 15
+#define cbEVT_PL_DRAW_BAR_HANDLES 16
+#define cbEVT_PL_DRAW_ROW_HANDLES 17
+#define cbEVT_PL_DRAW_ROW_BKGROUND 18
+#define cbEVT_PL_DRAW_PANE_BKGROUND 19
+
+#define cbEVT_PL_START_BAR_DRAGGING 20
+#define cbEVT_PL_DRAW_HINT_RECT 21
+
+#define cbEVT_PL_START_DRAW_IN_AREA 22
+#define cbEVT_PL_FINISH_DRAW_IN_AREA 23
+
+#define cbEVT_PL_CUSTOMIZE_BAR 24
+#define cbEVT_PL_CUSTOMIZE_LAYOUT 25
+
+#define wxCUSTOM_CB_PLUGIN_EVENTS_START_AT 100
+
+// forward decls, separated by categories
+
+class cbLeftDownEvent;
+class cbLeftUpEvent;
+class cbRightDownEvent;
+class cbRightUpEvent;
+class cbMotionEvent;
+class cbLeftDClickEvent;
+
+class cbLayoutRowEvent;
+class cbResizeRowEvent;
+class cbLayoutRowsEvent;
+class cbInsertBarEvent;
+class cbResizeBarEvent;
+class cbRemoveBarEvent;
+class cbSizeBarWndEvent;
+
+class cbDrawBarDecorEvent;
+class cbDrawRowDecorEvent;
+class cbDrawPaneDecorEvent;
+class cbDrawBarHandlesEvent;
+class cbDrawRowHandlesEvent;
+class cbDrawRowBkGroundEvent;
+class cbDrawPaneBkGroundEvent;
+
+class cbStartBarDraggingEvent;
+class cbDrawHintRectEvent;
+
+class cbStartDrawInAreaEvent;
+class cbFinishDrawInAreaEvent;
+
+class cbCustomizeBarEvent;
+class cbCustomizeLayoutEvent;
+
+// defs. for handler-methods
+
+typedef void (wxEvtHandler::*cbLeftDownHandler )(cbLeftDownEvent&);
+typedef void (wxEvtHandler::*cbLeftUpHandler )(cbLeftUpEvent&);
+typedef void (wxEvtHandler::*cbRightDownHandler )(cbRightDownEvent&);
+typedef void (wxEvtHandler::*cbRightUpHandler )(cbRightUpEvent&);
+typedef void (wxEvtHandler::*cbMotionHandler )(cbMotionEvent&);
+typedef void (wxEvtHandler::*cbLeftDClickHandler )(cbLeftDClickEvent&);
+
+typedef void (wxEvtHandler::*cbLayoutRowHandler )(cbLayoutRowEvent&);
+typedef void (wxEvtHandler::*cbResizeRowHandler )(cbResizeRowEvent&);
+typedef void (wxEvtHandler::*cbLayoutRowsHandler )(cbLayoutRowsEvent&);
+typedef void (wxEvtHandler::*cbInsertBarHandler )(cbInsertBarEvent&);
+typedef void (wxEvtHandler::*cbResizeBarHandler )(cbResizeBarEvent&);
+typedef void (wxEvtHandler::*cbRemoveBarHandler )(cbRemoveBarEvent&);
+typedef void (wxEvtHandler::*cbSizeBarWndHandler )(cbSizeBarWndEvent&);
+
+typedef void (wxEvtHandler::*cbDrawBarDecorHandler )(cbDrawBarDecorEvent&);
+typedef void (wxEvtHandler::*cbDrawRowDecorHandler )(cbDrawRowDecorEvent&);
+typedef void (wxEvtHandler::*cbDrawPaneDecorHandler )(cbDrawPaneDecorEvent&);
+typedef void (wxEvtHandler::*cbDrawBarHandlesHandler )(cbDrawBarHandlesEvent&);
+typedef void (wxEvtHandler::*cbDrawRowHandlesHandler )(cbDrawRowHandlesEvent&);
+typedef void (wxEvtHandler::*cbDrawRowBkGroundHandler )(cbDrawRowBkGroundEvent&);
+typedef void (wxEvtHandler::*cbDrawPaneBkGroundHandler)(cbDrawPaneBkGroundEvent&);
+
+typedef void (wxEvtHandler::*cbStartBarDraggingHandler )(cbStartBarDraggingEvent&);
+typedef void (wxEvtHandler::*cbDrawHintRectHandler )(cbDrawHintRectEvent&);
+
+typedef void (wxEvtHandler::*cbStartDrawInAreaHandler )(cbStartDrawInAreaEvent&);
+typedef void (wxEvtHandler::*cbFinishDrawInAreaHandler)(cbFinishDrawInAreaEvent&);
+
+typedef void (wxEvtHandler::*cbCustomizeBarHandler )(cbCustomizeBarEvent&);
+typedef void (wxEvtHandler::*cbCustomizeLayoutHandler )(cbCustomizeLayoutEvent&);
+
+// macros for creating event table entries for plugin-events
+
+#define EVT_PL_LEFT_DOWN(func) { cbEVT_PL_LEFT_DOWN, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLeftDownHandler ) & func },
+#define EVT_PL_LEFT_UP(func) { cbEVT_PL_LEFT_UP, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLeftUpHandler ) & func },
+#define EVT_PL_RIGHT_DOWN(func) { cbEVT_PL_RIGHT_DOWN, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbRightDownHandler ) & func },
+#define EVT_PL_RIGHT_UP(func) { cbEVT_PL_RIGHT_UP, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbRightUpHandler ) & func },
+#define EVT_PL_MOTION(func) { cbEVT_PL_MOTION, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbMotionHandler ) & func },
+#define EVT_PL_LEFT_DCLICK(func) { cbEVT_PL_LEFT_DCLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLeftDClickHandler ) & func },
+
+#define EVT_PL_LAYOUT_ROW(func) { cbEVT_PL_LAYOUT_ROW, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLayoutRowHandler ) & func },
+#define EVT_PL_RESIZE_ROW(func) { cbEVT_PL_RESIZE_ROW, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbResizeRowHandler ) & func },
+#define EVT_PL_LAYOUT_ROWS(func) { cbEVT_PL_LAYOUT_ROWS, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLayoutRowsHandler ) & func },
+#define EVT_PL_INSERT_BAR(func) { cbEVT_PL_INSERT_BAR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbInsertBarHandler ) & func },
+#define EVT_PL_RESIZE_BAR(func) { cbEVT_PL_RESIZE_BAR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbResizeBarHandler ) & func },
+#define EVT_PL_REMOVE_BAR(func) { cbEVT_PL_REMOVE_BAR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbRemoveBarHandler ) & func },
+#define EVT_PL_SIZE_BAR_WND(func) { cbEVT_PL_SIZE_BAR_WND, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbSizeBarWndHandler ) & func },
+
+#define EVT_PL_DRAW_BAR_DECOR(func) { cbEVT_PL_DRAW_BAR_DECOR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawBarDecorHandler ) & func },
+#define EVT_PL_DRAW_ROW_DECOR(func) { cbEVT_PL_DRAW_ROW_DECOR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawRowDecorHandler ) & func },
+#define EVT_PL_DRAW_PANE_DECOR(func) { cbEVT_PL_DRAW_PANE_DECOR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawPaneDecorHandler ) & func },
+#define EVT_PL_DRAW_BAR_HANDLES(func) { cbEVT_PL_DRAW_BAR_HANDLES, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawBarHandlesHandler ) & func },
+#define EVT_PL_DRAW_ROW_HANDLES(func) { cbEVT_PL_DRAW_ROW_HANDLES, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawRowHandlesHandler ) & func },
+#define EVT_PL_DRAW_ROW_BKGROUND(func) { cbEVT_PL_DRAW_ROW_BKGROUND, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawRowBkGroundHandler ) & func },
+#define EVT_PL_DRAW_PANE_BKGROUND(func) { cbEVT_PL_DRAW_PANE_BKGROUND, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawPaneBkGroundHandler) & func },
+
+#define EVT_PL_START_BAR_DRAGGING(func) { cbEVT_PL_START_BAR_DRAGGING, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbStartBarDraggingHandler) & func },
+#define EVT_PL_DRAW_HINT_RECT(func) { cbEVT_PL_DRAW_HINT_RECT, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawHintRectHandler ) & func },
+
+#define EVT_PL_START_DRAW_IN_AREA(func) { cbEVT_PL_START_DRAW_IN_AREA, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbStartDrawInAreaHandler) & func },
+#define EVT_PL_FINISH_DRAW_IN_AREA(func) { cbEVT_PL_FINISH_DRAW_IN_AREA, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbFinishDrawInAreaHandler) & func },
+
+#define EVT_PL_CUSTOMIZE_BAR(func) { cbEVT_PL_CUSTOMIZE_BAR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbCustomizeBarHandler) & func },
+#define EVT_PL_CUSTOMIZE_LAYOUT(func) { cbEVT_PL_CUSTOMIZE_LAYOUT, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbCustomizeLayoutHandler) & func },
+
+/*
+ * abstract base class for all control-bar related plugins
+ */
+
+class cbPluginBase : public wxEvtHandler
+{
+ DECLARE_ABSTRACT_CLASS( cbPluginBase )
+public:
+
+ wxFrameLayout* mpLayout; // back-reference to the frame layout
+
+ // specifies panes, for which this plugin receives events
+ // (see pane masks definitions)
+ int mPaneMask;
+
+ bool mIsReady; // is TRUE, when plugin is ready to handle events
+
+public:
+ cbPluginBase(void)
+
+ : mpLayout ( 0 ),
+ mPaneMask( wxALL_PANES ),
+ mIsReady ( FALSE )
+ {}
+
+ cbPluginBase( wxFrameLayout* pPanel, int paneMask = wxALL_PANES )
+
+ : mpLayout ( pPanel ),
+ mPaneMask( paneMask ),
+ mIsReady ( FALSE )
+ {}
+
+ inline int GetPaneMask() { return mPaneMask; }
+
+ // NOTE:: pointer positions of mouse-events sent to plugins
+ // are always in pane's coordinates (pane's to which
+ // this plugin is hooked)
+
+ // destroys the whole plugin chain of connected plagins
+ virtual ~cbPluginBase();
+
+ // override this method to do plugin-specific initialization
+ // (at this point plugin is already attached to the frame layout,
+ // and pane masks are set)
+ virtual void OnInitPlugin() { mIsReady = TRUE; }
+
+ bool IsReady() { return mIsReady; }
+
+ // overriden, to determine whether the target pane specified in the
+ // event, matches the pane mask of this plugin (specific plugins
+ // do not override this method)
+
+ virtual bool ProcessEvent(wxEvent& event);
+};
+
+/*** event classes, for each corresponding event type (24 currnetly...uhh) ***/
+
+// mouse-events category
+
+class cbLeftDownEvent : public cbPluginEvent
+{
+public:
+ wxPoint mPos;
+
+ cbLeftDownEvent( const wxPoint& pos, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_LEFT_DOWN, pPane ),
+ mPos( pos )
+ {}
+};
+
+class cbLeftUpEvent : public cbPluginEvent
+{
+public:
+ wxPoint mPos;
+
+ cbLeftUpEvent( const wxPoint& pos, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_LEFT_UP, pPane ),
+ mPos( pos )
+ {}
+};
+
+class cbRightDownEvent : public cbPluginEvent
+{
+public:
+ wxPoint mPos;
+
+ cbRightDownEvent( const wxPoint& pos, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_RIGHT_DOWN, pPane ),
+ mPos( pos )
+ {}
+};
+
+class cbRightUpEvent : public cbPluginEvent
+{
+public:
+ wxPoint mPos;
+
+ cbRightUpEvent( const wxPoint& pos, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_RIGHT_UP, pPane ),
+ mPos( pos )
+ {}
+};
+
+class cbMotionEvent : public cbPluginEvent
+{
+public:
+ wxPoint mPos;
+
+ cbMotionEvent( const wxPoint& pos, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_MOTION, pPane ),
+ mPos( pos )
+ {}
+};
+
+class cbLeftDClickEvent : public cbPluginEvent
+{
+public:
+ wxPoint mPos;
+
+ cbLeftDClickEvent( const wxPoint& pos, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_LEFT_DCLICK, pPane ),
+ mPos( pos )
+ {}
+};
+
+// bar/row events category
+
+class cbLayoutRowEvent : public cbPluginEvent
+{
+public:
+ cbRowInfo* mpRow;
+
+ cbLayoutRowEvent( cbRowInfo* pRow, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_LAYOUT_ROW, pPane ),
+ mpRow( pRow )
+ {}
+};
+
+class cbResizeRowEvent : public cbPluginEvent
+{
+public:
+ cbRowInfo* mpRow;
+ int mHandleOfs;
+ bool mForUpperHandle;
+
+ cbResizeRowEvent( cbRowInfo* pRow, int handleOfs, bool forUpperHandle, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_RESIZE_ROW, pPane ),
+ mpRow( pRow ),
+ mHandleOfs( handleOfs ),
+ mForUpperHandle( forUpperHandle )
+ {}
+};
+
+class cbLayoutRowsEvent : public cbPluginEvent
+{
+public:
+
+ cbLayoutRowsEvent( cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_LAYOUT_ROWS, pPane )
+ {}
+};
+
+class cbInsertBarEvent : public cbPluginEvent
+{
+public:
+ cbBarInfo* mpBar;
+ cbRowInfo* mpRow;
+
+ cbInsertBarEvent( cbBarInfo* pBar, cbRowInfo* pIntoRow, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_INSERT_BAR, pPane ),
+
+ mpBar( pBar ),
+ mpRow( pIntoRow )
+ {}
+};
+
+class cbResizeBarEvent : public cbPluginEvent
+{
+public:
+ cbBarInfo* mpBar;
+ cbRowInfo* mpRow;
+
+ cbResizeBarEvent( cbBarInfo* pBar, cbRowInfo* pRow, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_RESIZE_BAR, pPane ),
+ mpBar( pBar ),
+ mpRow( pRow )
+ {}
+};
+
+class cbRemoveBarEvent : public cbPluginEvent
+{
+public:
+ cbBarInfo* mpBar;
+
+ cbRemoveBarEvent( cbBarInfo* pBar, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_REMOVE_BAR, pPane ),
+ mpBar( pBar )
+ {}
+};
+
+class cbSizeBarWndEvent : public cbPluginEvent
+{
+public:
+ cbBarInfo* mpBar;
+ wxRect mBoundsInParent;
+
+ cbSizeBarWndEvent( cbBarInfo* pBar, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_SIZE_BAR_WND, pPane ),
+ mpBar( pBar ),
+ mBoundsInParent( pBar->mBoundsInParent )
+ {}
+};
+
+class cbDrawBarDecorEvent : public cbPluginEvent
+{
+public:
+ cbBarInfo* mpBar;
+ wxDC* mpDc;
+ wxRect mBoundsInParent;
+
+ cbDrawBarDecorEvent( cbBarInfo* pBar, wxDC& dc, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_DRAW_BAR_DECOR, pPane ),
+ mpBar( pBar ),
+ mpDc( &dc ),
+ mBoundsInParent( pBar->mBoundsInParent )
+ {}
+};
+
+class cbDrawRowDecorEvent : public cbPluginEvent
+{
+public:
+ cbRowInfo* mpRow;
+ wxDC* mpDc;
+
+ cbDrawRowDecorEvent( cbRowInfo* pRow, wxDC& dc, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_DRAW_ROW_DECOR, pPane ),
+ mpRow( pRow ),
+ mpDc( &dc )
+ {}
+};
+
+class cbDrawPaneDecorEvent : public cbPluginEvent
+{
+public:
+ wxDC* mpDc;
+
+ cbDrawPaneDecorEvent( wxDC& dc, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_DRAW_PANE_DECOR, pPane ),
+ mpDc( &dc )
+ {}
+};
+
+class cbDrawBarHandlesEvent : public cbPluginEvent
+{
+public:
+ cbBarInfo* mpBar;
+ wxDC* mpDc;
+
+ cbDrawBarHandlesEvent( cbBarInfo* pBar, wxDC& dc, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_DRAW_BAR_HANDLES, pPane ),
+ mpBar( pBar ),
+ mpDc( &dc )
+ {}
+};
+
+class cbDrawRowHandlesEvent : public cbPluginEvent
+{
+public:
+ cbRowInfo* mpRow;
+ wxDC* mpDc;
+
+ cbDrawRowHandlesEvent( cbRowInfo* pRow, wxDC& dc, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_DRAW_ROW_HANDLES, pPane ),
+ mpRow( pRow ),
+ mpDc( &dc )
+ {}
+};
+
+class cbDrawRowBkGroundEvent : public cbPluginEvent
+{
+public:
+ cbRowInfo* mpRow;
+ wxDC* mpDc;
+
+ cbDrawRowBkGroundEvent( cbRowInfo* pRow, wxDC& dc, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_DRAW_ROW_BKGROUND, pPane ),
+ mpRow( pRow ),
+ mpDc( &dc )
+ {}
+};
+
+class cbDrawPaneBkGroundEvent : public cbPluginEvent
+{
+public:
+ wxDC* mpDc;
+
+ cbDrawPaneBkGroundEvent( wxDC& dc, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_DRAW_PANE_BKGROUND, pPane ),
+ mpDc( &dc )
+ {}
+};
+
+class cbStartBarDraggingEvent : public cbPluginEvent
+{
+public:
+ cbBarInfo* mpBar;
+ wxPoint mPos; // is given in frame's coordinates
+
+ cbStartBarDraggingEvent( cbBarInfo* pBar, const wxPoint& pos, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_START_BAR_DRAGGING, pPane ),
+ mpBar( pBar ),
+ mPos( pos )
+ {}
+};
+
+class cbDrawHintRectEvent : public cbPluginEvent
+{
+public:
+ wxRect mRect; // is given in frame's coordinates
+
+
+ bool mLastTime; // indicates that this event finishes "session" of on-screen drawing,
+ // thus associated resources can be freed now
+ bool mEraseRect; // does not have any impact, if recangle is drawn using XOR-mask
+
+ bool mIsInClient;// in cleint area hint could be drawn differently,
+ // e.g. with fat/hatched border
+
+
+ cbDrawHintRectEvent( const wxRect& rect, bool isInClient, bool eraseRect, bool lastTime )
+
+ : cbPluginEvent( cbEVT_PL_DRAW_HINT_RECT, 0 ),
+ mRect ( rect ),
+ mLastTime ( lastTime ),
+ mEraseRect ( eraseRect ),
+ mIsInClient( isInClient )
+ {}
+};
+
+class cbStartDrawInAreaEvent : public cbPluginEvent
+{
+public:
+ wxRect mArea;
+ wxDC** mppDc; // points to pointer, where the reference
+ // to the obtained buffer-context should be placed
+
+ cbStartDrawInAreaEvent( const wxRect& area, wxDC** ppDCForArea, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_START_DRAW_IN_AREA, pPane ),
+ mArea( area ),
+ mppDc( ppDCForArea )
+ {}
+};
+
+class cbFinishDrawInAreaEvent : public cbPluginEvent
+{
+public:
+ wxRect mArea;
+
+ cbFinishDrawInAreaEvent( const wxRect& area, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_FINISH_DRAW_IN_AREA, pPane ),
+ mArea( area )
+ {}
+};
+
+class cbCustomizeBarEvent : public cbPluginEvent
+{
+public:
+ wxPoint mClickPos; // in parent frame's coordinates
+ cbBarInfo* mpBar;
+
+ cbCustomizeBarEvent( cbBarInfo* pBar, const wxPoint& clickPos, cbDockPane* pPane )
+
+ : cbPluginEvent( cbEVT_PL_CUSTOMIZE_BAR, pPane ),
+ mClickPos( clickPos ),
+ mpBar( pBar )
+ {}
+};
+
+class cbCustomizeLayoutEvent : public cbPluginEvent
+{
+public:
+ wxPoint mClickPos; // in parent frame's coordinates
+
+ cbCustomizeLayoutEvent( const wxPoint& clickPos )
+
+ : cbPluginEvent( cbEVT_PL_CUSTOMIZE_LAYOUT, 0 ),
+ mClickPos( clickPos )
+ {}
+};
+
+
+#endif
projects / wxWidgets.git / blobdiff