home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / contrib / include / wx / fl / controlbar.h < prev    next >
C/C++ Source or Header  |  2002-09-08  |  72KB  |  2,266 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        controlbar.h
  3. // Purpose:     Central header file for control-bar related classes
  4. //
  5. // Author:      Aleksandras Gluchovas <mailto:alex@soften.ktu.lt>
  6. // Modified by:
  7. // Created:     06/09/98
  8. // RCS-ID:      $Id: controlbar.h,v 1.10 2002/09/07 12:10:19 GD Exp $
  9. // Copyright:   (c) Aleksandras Gluchovas
  10. // Licence:       wxWindows licence
  11. /////////////////////////////////////////////////////////////////////////////
  12.  
  13. #ifndef __CONTROLBAR_G__
  14. #define __CONTROLBAR_G__
  15.  
  16. #if defined(__GNUG__) && !defined(__APPLE__)
  17.     #pragma interface "controlbar.h"
  18. #endif
  19.  
  20. #include "wx/defs.h"
  21. #include "wx/string.h"
  22. #include "wx/window.h"
  23. #include "wx/dynarray.h"
  24.  
  25. #define WXCONTROLBAR_VERSION      1.3
  26.  
  27. // forward declarations
  28.  
  29. class  wxFrameLayout;
  30.  
  31. class  cbDockPane;
  32. class  cbUpdatesManagerBase;
  33. class  cbBarDimHandlerBase;
  34. class  cbPluginBase;
  35. class  cbPluginEvent;
  36. class  cbPaneDrawPlugin;
  37.  
  38. class cbBarInfo;
  39. class cbRowInfo;
  40. class cbDimInfo;
  41. class cbCommonPaneProperties;
  42.  
  43. typedef cbBarInfo* BarInfoPtrT;
  44. typedef cbRowInfo* RowInfoPtrT;
  45.  
  46. WX_DEFINE_ARRAY( BarInfoPtrT, BarArrayT );
  47. WX_DEFINE_ARRAY( RowInfoPtrT, RowArrayT );
  48.  
  49. // control bar states
  50.  
  51. #define wxCBAR_DOCKED_HORIZONTALLY 0
  52. #define wxCBAR_DOCKED_VERTICALLY   1
  53. #define wxCBAR_FLOATING            2
  54. #define wxCBAR_HIDDEN              3
  55.  
  56. // the states are enumerated above
  57. #define MAX_BAR_STATES             4
  58.  
  59. // control bar alignments
  60.  
  61. #if !defined(FL_ALIGN_TOP)
  62.  
  63. #define FL_ALIGN_TOP        0
  64. #define FL_ALIGN_BOTTOM     1
  65. #define FL_ALIGN_LEFT       2
  66. #define FL_ALIGN_RIGHT      3
  67.  
  68. #endif
  69.  
  70. // one pane for each alignment
  71. #define MAX_PANES      4
  72.  
  73. // masks for each pane
  74.  
  75. #define FL_ALIGN_TOP_PANE        0x0001
  76. #define FL_ALIGN_BOTTOM_PANE   0x0002
  77. #define FL_ALIGN_LEFT_PANE       0x0004
  78. #define FL_ALIGN_RIGHT_PANE   0x0008
  79.  
  80. #define wxALL_PANES    0x000F
  81.  
  82. // enumeration of hittest results, see cbDockPane::HitTestPaneItems(..)
  83.  
  84. enum CB_HITTEST_RESULT
  85. {
  86.     CB_NO_ITEMS_HITTED,
  87.  
  88.     CB_UPPER_ROW_HANDLE_HITTED,
  89.     CB_LOWER_ROW_HANDLE_HITTED,
  90.     CB_LEFT_BAR_HANDLE_HITTED,
  91.     CB_RIGHT_BAR_HANDLE_HITTED,
  92.     CB_BAR_CONTENT_HITTED
  93. };
  94.  
  95. /*
  96. Helper class, used for spying for unhandled mouse events on control bars
  97. and forwarding them to the frame layout.
  98. */
  99.  
  100. class cbBarSpy : public wxEvtHandler
  101. {
  102. public:
  103.     DECLARE_DYNAMIC_CLASS( cbBarSpy )
  104.  
  105.     wxFrameLayout* mpLayout;
  106.     wxWindow*      mpBarWnd;
  107.  
  108. public:
  109.         // Default constructor.
  110.  
  111.     cbBarSpy(void);
  112.  
  113.         // Constructor, taking a parent pane.
  114.  
  115.     cbBarSpy( wxFrameLayout* pPanel );
  116.  
  117.         // Sets the bar window.
  118.  
  119.     void SetBarWindow( wxWindow* pWnd );
  120.  
  121.         // Performs special event processing.
  122.  
  123.     virtual bool ProcessEvent(wxEvent& event);
  124. };
  125.  
  126. /*
  127. wxFrameLayout manages containment and docking of control bars,
  128. which can be docked along the top, bottom, right, or left side of the
  129. parent frame.
  130. */
  131.  
  132. class wxFrameLayout : public wxEvtHandler
  133. {
  134. public:
  135.         // Default constructor, used only for serialization.
  136.  
  137.     wxFrameLayout();
  138.  
  139.         // Constructor, taking parent window, the (MDI) client of the parent if there
  140.         // is one, and flag specifying whether to activate the layout.
  141.  
  142.     wxFrameLayout( wxWindow* pParentFrame,
  143.                    wxWindow* pFrameClient = NULL,
  144.                    bool      activateNow  = TRUE );
  145.  
  146.         // Destructor. It does not destroy the bar windows.
  147.  
  148.     virtual ~wxFrameLayout();
  149.  
  150.         // Enables floating behaviour. By default floating of control bars is on.
  151.  
  152.     virtual void EnableFloating( bool enable = TRUE );
  153.  
  154.         // Activate can be called after some other layout has been deactivated,
  155.         // and this one must take over the current contents of the frame window.
  156.         //
  157.         // Effectively hooks itself to the frame window, re-displays all non-hidden
  158.         // bar windows and repaints the decorations.
  159.  
  160.     virtual void Activate();
  161.  
  162.         // Deactivate unhooks itself from frame window, and hides all non-hidden windows.
  163.         //
  164.         // Note: two frame layouts should not be active at the same time in the
  165.         // same frame window, since it would cause messy overlapping of bar windows
  166.         // from both layouts.
  167.  
  168.     virtual void Deactivate();
  169.  
  170.         // Hides the bar windows, and also the client window if present.
  171.  
  172.     void HideBarWindows();
  173.  
  174.         // Destroys the bar windows.
  175.  
  176.     virtual void DestroyBarWindows();
  177.  
  178.         // Passes the client window (e.g. MDI client window) to be controlled by
  179.         // frame layout, the size and position of which should be adjusted to be
  180.         // surrounded by controlbar panes, whenever the frame is resized or the dimensions
  181.         // of control panes change.
  182.  
  183.     void SetFrameClient( wxWindow* pFrameClient );
  184.  
  185.         // Returns the frame client, or NULL if not present.
  186.  
  187.     wxWindow* GetFrameClient();
  188.  
  189.         // Returns the parent frame.
  190.  
  191.     wxWindow& GetParentFrame() { return *mpFrame; }
  192.  
  193.         // Returns an array of panes. Used by update managers.
  194.  
  195.     cbDockPane** GetPanesArray() { return mPanes; }
  196.  
  197.         // Returns a pane for the given alignment. See pane alignment types.
  198.  
  199.     cbDockPane* GetPane( int alignment )
  200.  
  201.         { return mPanes[alignment]; }
  202.  
  203.         // Adds bar information to the frame layout. The appearance of the layout is not refreshed
  204.         // immediately; RefreshNow() can be called if necessary.
  205.         //
  206.         // Notes: the argument pBarWnd can by NULL, resulting in bar decorations to be drawn
  207.         // around the empty rectangle (filled with default background colour).
  208.         // Argument dimInfo can be reused for adding any number of bars, since
  209.         // it is not used directly - instead its members are copied. If the dimensions
  210.         // handler is present, its instance is shared (reference counted). The dimension
  211.         // handler should always be allocated on the heap.
  212.  
  213.         // pBarWnd is the window to be managed.
  214.  
  215.         // dimInfo contains dimension information.
  216.  
  217.         // alignment is a value such as FL_ALIGN_TOP.
  218.  
  219.         // rowNo is the vertical position or row in the pane (if in docked state).
  220.  
  221.         // columnPos is the horizontal position within the row in pixels (if in docked state).
  222.  
  223.         // name is a name by which the bar can be referred in layout customization dialogs.
  224.  
  225.         // If spyEvents is TRUE, input events for the bar should be "spyed" in order
  226.         // to forward unhandled mouse clicks to the frame layout, for example to enable
  227.         // easy draggablity of toolbars just by clicking on their interior regions.
  228.         // For widgets like text/tree control this value should be FALSE,
  229.         // since there's no certain way to detect  whether the event was actually handled.
  230.  
  231.         // state is the initial state, such as wxCBAR_DOCKED_HORIZONTALLY,
  232.         // wxCBAR_FLOATING, wxCBAR_HIDDEN.
  233.  
  234.     virtual void AddBar( wxWindow*        pBarWnd,
  235.                          const cbDimInfo&       dimInfo,
  236.  
  237.                          // defaults:
  238.                          int alignment    = FL_ALIGN_TOP,
  239.                          int rowNo        = 0,
  240.                          int columnPos    = 0,
  241.                          const wxString& name="bar",
  242.                          bool spyEvents    = FALSE,
  243.                          int state        = wxCBAR_DOCKED_HORIZONTALLY
  244.                        );
  245.  
  246.         // ReddockBar can be used for repositioning existing bars. The given bar is first removed
  247.         // from the pane it currently belongs to, and inserted into the pane, which "matches"
  248.         // the given rectangular area. If pToPane is not NULL, the bar is docked to this given pane.
  249.         // To dock a bar which is floating, use the wxFrameLayout::DockBar method.
  250.  
  251.     virtual bool RedockBar( cbBarInfo* pBar, const wxRect& shapeInParent,
  252.                             cbDockPane* pToPane = NULL, bool updateNow = TRUE );
  253.  
  254.         // Finds the bar in the framelayout, by name.
  255.  
  256.     cbBarInfo* FindBarByName( const wxString& name );
  257.  
  258.         // Finds the bar in the framelayout, by window.
  259.  
  260.     cbBarInfo* FindBarByWindow( const wxWindow* pWnd );
  261.  
  262.         // Gets an array of bars.
  263.  
  264.     BarArrayT& GetBars();
  265.  
  266.         // Changes the bar's docking state (see possible control bar states).
  267.  
  268.     void SetBarState( cbBarInfo* pBar, int newStatem, bool updateNow );
  269.  
  270.         // Toggles the bar between visible and hidden.
  271.  
  272.     void InverseVisibility( cbBarInfo* pBar );
  273.  
  274.         // Reflects changes in bar information structure visually.
  275.         // For example, moves the bar, changes its dimension information,
  276.         // or changes the pane to which it is docked.
  277.  
  278.     void ApplyBarProperties( cbBarInfo* pBar );
  279.  
  280.         // Removes the bar from the layout permanently, and hides its corresponding window if present.
  281.  
  282.     void RemoveBar( cbBarInfo* pBar );
  283.  
  284.         // Recalculates the layout of panes, and all bars/rows in each pane.
  285.  
  286.     virtual void RecalcLayout( bool repositionBarsNow = FALSE );
  287.  
  288.         // Returns the client height.
  289.  
  290.     int     GetClientHeight();
  291.  
  292.         // Returns the client width.
  293.  
  294.     int     GetClientWidth();
  295.  
  296.         // Returns the client's rectangle.
  297.  
  298.     wxRect& GetClientRect()        { return mClntWndBounds;     }
  299.  
  300.         // Returns a reference to the updates manager.
  301.         // Note: in future, the updates manager will become a normal plugin.
  302.  
  303.     cbUpdatesManagerBase& GetUpdatesManager();
  304.  
  305.         // Destroys the previous manager if any, and sets the new one.
  306.  
  307.     void SetUpdatesManager( cbUpdatesManagerBase* pUMgr );
  308.  
  309.         // Gets the pane properties for the given alignment.
  310.  
  311.     virtual void GetPaneProperties( cbCommonPaneProperties& props, int alignment = FL_ALIGN_TOP );
  312.  
  313.         // Sets the pane properties for the given alignment.
  314.         // Note: changing properties of panes does not result immediate on-screen update.
  315.  
  316.     virtual void SetPaneProperties( const cbCommonPaneProperties& props,
  317.                                     int paneMask = wxALL_PANES );
  318.  
  319.         // Sets the margins for the given panes.
  320.         // The margins should go into cbCommonPaneProperties in the future.
  321.         //
  322.         // Note: this method should be called before any custom plugins are attached.
  323.  
  324.     virtual void SetMargins( int top, int bottom, int left, int right,
  325.                              int paneMask = wxALL_PANES );
  326.  
  327.         // Sets the pane background colour.
  328.  
  329.     virtual void SetPaneBackground( const wxColour& colour );
  330.  
  331.         // Recalculates layout and performs on-screen update of all panes.
  332.  
  333.     void RefreshNow( bool recalcLayout = TRUE );
  334.  
  335.         // Event handler for a size event.
  336.  
  337.     void OnSize       ( wxSizeEvent&  event );
  338.  
  339.         // Event handler for a left down button event.
  340.  
  341.     void OnLButtonDown( wxMouseEvent& event );
  342.  
  343.         // Event handler for a left doubleclick button event.
  344.  
  345.     void OnLDblClick  ( wxMouseEvent& event );
  346.  
  347.         // Event handler for a left button up event.
  348.  
  349.     void OnLButtonUp  ( wxMouseEvent& event );
  350.  
  351.         // Event handler for a right button down event.
  352.  
  353.     void OnRButtonDown( wxMouseEvent& event );
  354.  
  355.         // Event handler for a right button up event.
  356.  
  357.     void OnRButtonUp  ( wxMouseEvent& event );
  358.  
  359.         // Event handler for a mouse move event.
  360.  
  361.     void OnMouseMove  ( wxMouseEvent& event );
  362.  
  363.         // This function should be used instead of passing the event to the ProcessEvent method
  364.         // of the top-level plugin directly. This method checks if events are currently
  365.         // captured and ensures that plugin-event is routed correctly.
  366.  
  367.     virtual void FirePluginEvent( cbPluginEvent& event );
  368.  
  369.         // Captures user input events for the given plugin.
  370.         // Input events are: mouse movement, mouse clicks, keyboard input.
  371.  
  372.     virtual void CaptureEventsForPlugin ( cbPluginBase* pPlugin );
  373.  
  374.         // Releases user input events for the given plugin.
  375.         // Input events are: mouse movement, mouse clicks, keyboard input
  376.  
  377.     virtual void ReleaseEventsFromPlugin( cbPluginBase* pPlugin );
  378.  
  379.         // Called by plugins; also captures the mouse in the parent frame.
  380.  
  381.     void CaptureEventsForPane( cbDockPane* toPane );
  382.  
  383.         // Called by plugins; also releases mouse in the parent frame.
  384.  
  385.     void ReleaseEventsFromPane( cbDockPane* fromPane );
  386.  
  387.         // Returns the current top-level plugin (the one that receives events first,
  388.         // except if input events are currently captured by some other plugin).
  389.  
  390.     virtual cbPluginBase& GetTopPlugin();
  391.  
  392.         // Hooking custom plugins to frame layout.
  393.         //
  394.         // Note: when hooking one plugin on top of the other,
  395.         // use SetNextHandler or similar methods
  396.         // of wxEvtHandler class to compose the chain of plugins,
  397.         // than pass the left-most handler in this chain to
  398.         // the above methods (assuming that events are delegated
  399.         // from left-most towards right-most handler).
  400.         //
  401.         // This secenario is very inconvenient and "low-level",
  402.         // so use the Add/Push/PopPlugin methods instead.
  403.  
  404.     virtual void SetTopPlugin( cbPluginBase* pPlugin );
  405.  
  406.         // Similar to wxWindow's "push/pop-event-handler" methods, execept
  407.         // that the plugin is deleted upon "popping".
  408.  
  409.     virtual void PushPlugin( cbPluginBase* pPugin );
  410.  
  411.         // Similar to wxWindow's "push/pop-event-handler" methods, execept
  412.         // that the plugin is deleted upon "popping".
  413.  
  414.     virtual void PopPlugin();
  415.  
  416.         // Pop all plugins.
  417.     virtual void PopAllPlugins();
  418.  
  419.         // Adds the default plugins. These are cbPaneDrawPlugin, cbRowLayoutPlugin, cbBarDragPlugin,
  420.         // cbAntiflickerPlugin, cbSimpleCustomizePlugin.
  421.         //
  422.         // This method is automatically invoked if no plugins were found upon
  423.         // firing of the first plugin-event, i.e. when wxFrameLayout configures itself.
  424.  
  425.     virtual void PushDefaultPlugins();
  426.  
  427.         // An advanced methods for plugin configuration    using their
  428.         // dynamic class information, for example CLASSINFO(pluginClass).
  429.  
  430.         // First checks if the plugin of the given class is already "hooked up".
  431.         // If not, adds it to the top of the plugins chain.
  432.  
  433.     virtual void AddPlugin( wxClassInfo* pPlInfo, int paneMask = wxALL_PANES );
  434.  
  435.         // First checks if the plugin of the given class is already hooked.
  436.         // If so, removes it, and then inserts it into the chain
  437.         // before the plugin of the class given by pNextPlInfo.
  438.         //
  439.         // Note: this method is handy in some cases where the order
  440.         // of the plugin-chain could be important, for example when one plugin overrides
  441.         // some functionality of another already-hooked plugin,
  442.         // so that the former plugin should be hooked before the one
  443.         // whose functionality is being overridden.
  444.  
  445.     virtual void AddPluginBefore( wxClassInfo* pNextPlInfo, wxClassInfo* pPlInfo,
  446.                                   int paneMask = wxALL_PANES );
  447.  
  448.         // Checks if the plugin of the given class is hooked, and removes
  449.         // it if found.
  450.  
  451.     virtual void RemovePlugin( wxClassInfo* pPlInfo );
  452.  
  453.         // Finds a plugin with the given class, or returns NULL if a plugin of the given
  454.         // class is not hooked.
  455.  
  456.     virtual cbPluginBase* FindPlugin( wxClassInfo* pPlInfo );
  457.  
  458.         // Returns true if there is a top plugin.
  459.  
  460.     bool HasTopPlugin();
  461.  
  462.     DECLARE_EVENT_TABLE()
  463.     DECLARE_DYNAMIC_CLASS( wxFrameLayout )
  464.  
  465. public: /* protected really, acessed only by plugins and serializers */
  466.  
  467.     friend class cbDockPane;
  468.     friend class wxBarHandler;
  469.  
  470.     wxWindow*    mpFrame;           // parent frame
  471.     wxWindow*    mpFrameClient;        // client window
  472.     cbDockPane*  mPanes[MAX_PANES];    // panes in the panel
  473.  
  474.     // misc. cursors
  475.     wxCursor*    mpHorizCursor;
  476.     wxCursor*    mpVertCursor;
  477.     wxCursor*    mpNormalCursor;
  478.     wxCursor*    mpDragCursor;
  479.     wxCursor*    mpNECursor; // no-entry cursor
  480.  
  481.     // pens for decoration and shades
  482.  
  483.     wxPen        mDarkPen;     // default wxSYS_COLOUR_3DSHADOW
  484.     wxPen        mLightPen;  // default wxSYS_COLOUR_3DHILIGHT
  485.     wxPen        mGrayPen;     // default wxSYS_COLOUR_3DFACE
  486.     wxPen        mBlackPen;  // default wxColour(  0,  0,  0)
  487.     wxPen        mBorderPen; // default wxSYS_COLOUR_3DFACE
  488.  
  489.     wxPen        mNullPen;   // transparent pen
  490.  
  491.         // pane to which the all mouse input is currently directed (caputred)
  492.  
  493.     cbDockPane*  mpPaneInFocus;
  494.  
  495.         // pane, from which mouse pointer had just left
  496.  
  497.     cbDockPane*  mpLRUPane;
  498.  
  499.         // bounds of client window in parent frame's coordinates
  500.  
  501.     wxRect       mClntWndBounds;
  502.     wxRect       mPrevClntWndBounds;
  503.  
  504.     bool         mFloatingOn;
  505.     wxPoint      mNextFloatedWndPos;
  506.     wxSize       mFloatingPosStep;
  507.  
  508.         // current plugin (right-most) plugin which receives events first
  509.  
  510.     cbPluginBase* mpTopPlugin;
  511.  
  512.         // plugin, which currently has captured all input events, otherwise NULL
  513.  
  514.     cbPluginBase* mpCaputesInput;
  515.  
  516.         // list of event handlers which are "pushed" onto each bar, to catch
  517.         // mouse events which are not handled by bars, and froward them to the ,
  518.         // frome-layout and further to plugins
  519.  
  520.     wxList        mBarSpyList;
  521.  
  522.         // list of top-most frames which contain floated bars
  523.  
  524.     wxList        mFloatedFrames;
  525.  
  526.         // linked list of references to all bars (docked/floated/hidden)
  527.  
  528.     BarArrayT    mAllBars;
  529.  
  530.     // FOR NOW:: dirty stuff...
  531.     bool         mClientWndRefreshPending;
  532.     bool         mRecalcPending;
  533.     bool         mCheckFocusWhenIdle;
  534.  
  535. public: /* protected really (accessed only by plugins) */
  536.  
  537.         // refrence to custom updates manager
  538.     cbUpdatesManagerBase* mpUpdatesMgr;
  539.  
  540.         // Called to apply the calculated layout to window objects.
  541.  
  542.     void PositionClientWindow();
  543.  
  544.         // Called to apply the calculated layout to window objects.
  545.  
  546.     void PositionPanes();
  547.  
  548.         // Creates the cursors.
  549.  
  550.     void CreateCursors();
  551.  
  552.         // Applies the calculated layout to a floating bar.
  553.  
  554.     void RepositionFloatedBar( cbBarInfo* pBar );
  555.  
  556.         // Applies the state to the window objects.
  557.  
  558.     void DoSetBarState( cbBarInfo* pBar );
  559.  
  560.         // The purpose of this function is unknown.
  561.  
  562.     bool LocateBar( cbBarInfo* pBarInfo,
  563.                     cbRowInfo**  ppRow,
  564.                     cbDockPane** ppPane );
  565.  
  566.  
  567.         // Returns TRUE if the position is within the given pane.
  568.  
  569.     bool HitTestPane( cbDockPane* pPane, int x, int y );
  570.  
  571.         // Returns the pane for which the rectangle hit test succeeds, giving
  572.         // preference to the given pane if supplied.
  573.  
  574.     cbDockPane* HitTestPanes( const wxRect& rect, cbDockPane* pCurPane );
  575.  
  576.         // Returns the pane to which the given bar belongs.
  577.  
  578.     cbDockPane* GetBarPane( cbBarInfo* pBar );
  579.  
  580.         // Delegated from "bar-spy".
  581.     void ForwardMouseEvent( wxMouseEvent& event,
  582.                             cbDockPane*   pToPane,
  583.                             int           eventType );
  584.  
  585.         // Routes the mouse event to the appropriate pane.
  586.  
  587.     void RouteMouseEvent( wxMouseEvent& event, int pluginEvtType );
  588.  
  589.         // Shows all floated windows.
  590.  
  591.     void ShowFloatedWindows( bool show );
  592.  
  593.         // Unhooks the layout from the frame.
  594.  
  595.     void UnhookFromFrame();
  596.  
  597.         // Hooks the layout up to the frame (pushes the layout onto the
  598.         // frame's event handler stack).
  599.  
  600.     void HookUpToFrame();
  601.  
  602.         // Returns TRUE if the platform allows reparenting. This may not return TRUE
  603.         // for all platforms. Reparenting allows control bars to be floated.
  604.  
  605.     bool CanReparent();
  606.  
  607.         // Reparents pChild to have parent pNewParent.
  608.  
  609.     void ReparentWindow( wxWindow* pChild, wxWindow* pNewParent );
  610.  
  611.         // Returns the previous client window rectangle.
  612.  
  613.     wxRect& GetPrevClientRect() { return mPrevClntWndBounds; }
  614.  
  615.         // Handles paint events, calling PaintPane for each pane.
  616.  
  617.     void OnPaint( wxPaintEvent& event );
  618.  
  619.         // Handles background erase events. Currently does nothing.
  620.  
  621.     void OnEraseBackground( wxEraseEvent& event );
  622.  
  623.         // Handles focus kill events. Currently does nothing.
  624.  
  625.     void OnKillFocus( wxFocusEvent& event );
  626.  
  627.         // Handles focus set events. Currently does nothing.
  628.  
  629.     void OnSetFocus( wxFocusEvent& event );
  630.  
  631.         // Handles activation events. Currently does nothing.
  632.  
  633.     void OnActivate( wxActivateEvent& event );
  634.  
  635.         // Handles idle events.
  636.  
  637.     void OnIdle( wxIdleEvent& event );
  638.  
  639.         // Returns a new cbGCUpdatesMgr object.
  640.  
  641.     virtual cbUpdatesManagerBase* CreateUpdatesManager();
  642. };
  643.  
  644. /*
  645. A structure that is present in each item of layout,
  646. used by any particular updates-manager to store
  647. auxiliary information to be used by its updating algorithm.
  648. */
  649.  
  650. class cbUpdateMgrData : public wxObject
  651. {
  652.     DECLARE_DYNAMIC_CLASS( cbUpdateMgrData )
  653. public:
  654.     wxRect mPrevBounds;      // previous state of layout item (in parent frame's coordinates)
  655.  
  656.     bool   mIsDirty;         // overrides result of current-against-previous bounds comparison,
  657.                              // i.e. requires item to be updated, regardless of it's current area
  658.  
  659.     wxObject*  mpCustomData; // any custom data stored by specific updates mgr.
  660.  
  661.         // Default constructor. Is-dirty flag is set TRUE initially.
  662.  
  663.     cbUpdateMgrData();
  664.  
  665.         // Store the item state.
  666.  
  667.     void StoreItemState( const wxRect& boundsInParent );
  668.  
  669.         // Set the dirty flag.
  670.  
  671.     void SetDirty( bool isDirty = TRUE );
  672.  
  673.         // Set custom data.
  674.  
  675.     void SetCustomData( wxObject* pCustomData );
  676.  
  677.         // Returns the is-dirty flag.
  678.  
  679.     inline bool IsDirty() { return mIsDirty; }
  680. };
  681.  
  682. /*
  683. Abstract interface for bar-size handler classes.
  684. These objects receive notifications whenever the docking
  685. state of the bar is changed, thus they provide the possibility
  686. to adjust the values in cbDimInfo::mSizes accordingly.
  687. Specific handlers can be hooked up to specific types of bar.
  688. */
  689.  
  690. class cbBarDimHandlerBase : public wxObject
  691. {
  692.     DECLARE_ABSTRACT_CLASS( cbBarDimHandlerBase )
  693.  
  694. public:
  695.     int mRefCount; // since one dim-handler can be assigned
  696.                    // to multiple bars, it's instance is
  697.                    // reference-counted
  698. public:
  699.  
  700.         // Default constructor. The initial reference count is 0, since
  701.         // the handler is not used until the first invocation of AddRef().
  702.  
  703.     cbBarDimHandlerBase();
  704.  
  705.         // Increments the reference count.
  706.  
  707.     void AddRef();
  708.  
  709.         // Decrements the reference count, and if the count is at zero,
  710.         // delete 'this'.
  711.  
  712.     void RemoveRef();
  713.  
  714.         // Responds to "bar-state-changes" notifications.
  715.  
  716.     virtual void OnChangeBarState(cbBarInfo* pBar, int newState ) = 0;
  717.  
  718.         // Responds to bar resize notifications.
  719.  
  720.     virtual void OnResizeBar( cbBarInfo* pBar, const wxSize& given, wxSize& preferred ) = 0;
  721. };
  722.  
  723. /*
  724. Helper class used internally by the wxFrameLayout class.
  725. Holds and manages information about bar dimensions.
  726. */
  727.  
  728. class cbDimInfo : public wxObject
  729. {
  730.     DECLARE_DYNAMIC_CLASS( cbDimInfo )
  731. public:
  732.     wxSize mSizes[MAX_BAR_STATES];  // preferred sizes for each possible bar state
  733.  
  734.     wxRect mBounds[MAX_BAR_STATES]; // saved positions and sizes for each
  735.                                     // possible state, values contain (-1)s if
  736.                                     // not initialized yet
  737.  
  738.     int    mLRUPane; // pane to which this bar was docked before it was floated
  739.                      // (FL_ALIGN_TOP,FL_ALIGN_BOTTOM,..)
  740.  
  741.     // top/bottom gap, separates decorations
  742.     // from the bar's actual window, filled
  743.     // with frame's beckground color, default: 0
  744.  
  745.     int    mVertGap;
  746.  
  747.     // left/right gap, separates decorations
  748.     // from the bar's actual wndow, filled
  749.     // with frame's beckground colour, default: 0
  750.  
  751.     int    mHorizGap;    // NOTE:: gaps are given in frame's coord. orientation
  752.  
  753.     // TRUE, if vertical/horizontal dimensions cannot be mannualy adjusted
  754.     //       by user using resizing handles. If FALSE, the frame-layout
  755.     //       *automatically* places resizing handles among not-fixed bars
  756.  
  757.     bool   mIsFixed;
  758.  
  759.     cbBarDimHandlerBase* mpHandler; // NULL, if no handler present
  760.  
  761. public:
  762.  
  763.         // Default constructor.
  764.  
  765.     cbDimInfo(void);
  766.  
  767.         // Constructor.
  768.         // isFixed is TRUE if vertical/horizontal dimensions cannot be manually adjusted
  769.         // by the user using resizing handles. If FALSE, the frame-layout
  770.         // automatically places resizing handles among bars that do are not fixed.
  771.  
  772.     cbDimInfo( cbBarDimHandlerBase* pDimHandler,
  773.                bool                 isFixed         // (see comments on mIsFixed member)
  774.              );
  775.  
  776.         // Constructor taking dimenstion information.
  777.         //
  778.         // dh_x, dh_y are the dimensions when docked horizontally.
  779.         //
  780.         // dv_x, dv_y are the dimensions when docked vertically.
  781.         //
  782.         // f_x, f_y are the dimensions when floating.
  783.         //
  784.         // For information on isFixed, see comments above.
  785.         //
  786.         // horizGap is the left/right gap, separating decorations
  787.         // from the bar's actual wndow, filled with the frame's background colour.
  788.         // The dimension is given in the frame's coordinates.
  789.         //
  790.         // vertGap is the top/bottom gap, separating decorations
  791.         // from the bar's actual wndow, filled with the frame's background colour.
  792.         // The dimension is given in the frame's coordinates.
  793.  
  794.     cbDimInfo( int dh_x, int dh_y,
  795.                int dv_x, int dv_y,
  796.                int f_x,  int f_y,
  797.  
  798.                bool isFixed  = TRUE,
  799.                int  horizGap = 6,
  800.                int  vertGap  = 6,
  801.  
  802.                cbBarDimHandlerBase* pDimHandler = NULL
  803.              );
  804.  
  805.         // Constructor.
  806.  
  807.     cbDimInfo( int x, int y,
  808.                bool isFixed  = TRUE,
  809.                int  gap = 6,
  810.                cbBarDimHandlerBase* pDimHandler = NULL
  811.              );
  812.  
  813.         // Destructor. Destroys handler automatically, if present.
  814.  
  815.     ~cbDimInfo();
  816.  
  817.          // Assignment operator.
  818.  
  819.     const cbDimInfo& operator=( const cbDimInfo& other );
  820.  
  821.          // Returns the handler, if any.
  822.  
  823.     inline cbBarDimHandlerBase* GetDimHandler() { return mpHandler; }
  824. };
  825.  
  826. // FIXME: this array definition compiles but probably doesn't do what was intended (GD)
  827. WX_DEFINE_ARRAY_LONG(float, cbArrayFloat);
  828.  
  829. /*
  830. Helper class used internally by the wxFrameLayout class.
  831. Holds and manages information about bar rows.
  832. */
  833.  
  834. class cbRowInfo : public wxObject
  835. {
  836.     DECLARE_DYNAMIC_CLASS( cbRowInfo )
  837. public:
  838.  
  839.     BarArrayT  mBars;  // row content
  840.  
  841.     // row flags (set up according to row-relations)
  842.  
  843.     bool    mHasUpperHandle;
  844.     bool    mHasLowerHandle;
  845.     bool    mHasOnlyFixedBars;
  846.     int     mNotFixedBarsCnt;
  847.  
  848.     int        mRowWidth;
  849.     int        mRowHeight;
  850.     int        mRowY;
  851.  
  852.     // stores precalculated row's bounds in parent frame's coordinates
  853.     wxRect mBoundsInParent;
  854.  
  855.     // info stored for updates-manager
  856.     cbUpdateMgrData mUMgrData;
  857.  
  858.     cbRowInfo*    mpNext;
  859.     cbRowInfo*    mpPrev;
  860.  
  861.     cbBarInfo*    mpExpandedBar; // NULL, if non of the bars is currently expanded
  862.  
  863.     cbArrayFloat  mSavedRatios;  // length-ratios bofore some of the bars was expanded
  864.  
  865. public:
  866.         // Constructor.
  867.  
  868.     cbRowInfo(void);
  869.  
  870.         // Destructor.
  871.  
  872.     ~cbRowInfo();
  873.  
  874.         // Returns the first bar.
  875.  
  876.     inline cbBarInfo* GetFirstBar()
  877.  
  878.         { return mBars.GetCount() ? mBars[0] : NULL; }
  879. };
  880.  
  881. /*
  882. Helper class used internally by the wxFrameLayout class.
  883. Holds and manages bar information.
  884. */
  885.  
  886. class cbBarInfo : public wxObject
  887. {
  888.     DECLARE_DYNAMIC_CLASS( cbBarInfo )
  889. public:
  890.     // textual name, by which this bar is refered in layout-customization dialogs
  891.     wxString      mName;
  892.  
  893.     // stores bar's bounds in pane's coordinates
  894.     wxRect        mBounds;
  895.  
  896.     // stores precalculated bar's bounds in parent frame's coordinates
  897.     wxRect        mBoundsInParent;
  898.  
  899.     // back-ref to the row, which contains this bar
  900.     cbRowInfo*    mpRow;
  901.  
  902.     // are set up according to the types of the surrounding bars in the row
  903.     bool          mHasLeftHandle;
  904.     bool          mHasRightHandle;
  905.  
  906.     cbDimInfo     mDimInfo;       // preferred sizes for each, control bar state
  907.  
  908.     int           mState;         // (see definition of controlbar states)
  909.  
  910.     int           mAlignment;     // alignment of the pane to which this
  911.                                   // bar is currently placed
  912.  
  913.     int           mRowNo;         // row, into which this bar would be placed,
  914.                                   // when in the docking state
  915.  
  916.     wxWindow*     mpBarWnd;          // the actual window object, NULL if no window
  917.                                   // is attached to the control bar (possible!)
  918.  
  919.     double        mLenRatio;      // length ratio among not-fixed-size bars
  920.  
  921.     wxPoint       mPosIfFloated;  // stored last position when bar was in "floated" state
  922.                                   // poistion is stored in parent-window's coordinates
  923.  
  924.     cbUpdateMgrData mUMgrData;    // info stored for updates-manager
  925.  
  926.     cbBarInfo*    mpNext;         // next. bar in the row
  927.     cbBarInfo*    mpPrev;         // prev. bar in the row
  928.  
  929. public:
  930.         // Constructor.
  931.  
  932.     cbBarInfo(void);
  933.  
  934.         // Destructor.
  935.  
  936.     ~cbBarInfo();
  937.  
  938.         // Returns TRUE if this bar is fixed.
  939.  
  940.     inline bool IsFixed() const { return mDimInfo.mIsFixed; }
  941.  
  942.         // Returns TRUE if this bar is expanded.
  943.  
  944.     inline bool IsExpanded() const { return this == mpRow->mpExpandedBar; }
  945. };
  946.  
  947. /*
  948. Used for storing the original bar's positions in the row, when the 'non-destructive-friction'
  949. option is turned on.
  950. */
  951.  
  952. class cbBarShapeData : public wxObject
  953. {
  954. public:
  955.     wxRect mBounds;
  956.     double mLenRatio;
  957. };
  958.  
  959. /*
  960. Used for traversing through all bars of all rows in the pane.
  961. */
  962.  
  963. class wxBarIterator
  964. {
  965.     RowArrayT*  mpRows;
  966.     cbRowInfo*  mpRow;
  967.     cbBarInfo*  mpBar;
  968.  
  969. public:
  970.         // Constructor, taking row array.
  971.  
  972.     wxBarIterator( RowArrayT& rows );
  973.  
  974.         // Resets the iterator to the start of the first row.
  975.  
  976.     void Reset();
  977.  
  978.         // Advances the iterator and returns TRUE if a bar is available.
  979.  
  980.     bool Next();
  981.  
  982.         // Gets the current bar information.
  983.  
  984.     cbBarInfo& BarInfo();
  985.  
  986.         // Returns a reference to the currently traversed row.
  987.  
  988.     cbRowInfo& RowInfo();
  989. };
  990.  
  991. /*
  992. A structure holding configuration options,
  993. which are usually the same for all panes in
  994. a frame layout.
  995. */
  996.  
  997. class cbCommonPaneProperties : public wxObject
  998. {
  999.     DECLARE_DYNAMIC_CLASS( cbCommonPaneProperties )
  1000.  
  1001.     // look-and-feel configuration
  1002.  
  1003.     bool mRealTimeUpdatesOn;     // default: ON
  1004.     bool mOutOfPaneDragOn;       // default: ON
  1005.     bool mExactDockPredictionOn; // default: OFF
  1006.     bool mNonDestructFrictionOn; // default: OFF
  1007.  
  1008.     bool mShow3DPaneBorderOn;    // default: ON
  1009.  
  1010.     // FOR NOW:: the below properties are reserved for the "future"
  1011.  
  1012.     bool mBarFloatingOn;         // default: OFF
  1013.     bool mRowProportionsOn;      // default: OFF
  1014.     bool mColProportionsOn;      // default: ON
  1015.     bool mBarCollapseIconsOn;    // default: OFF
  1016.     bool mBarDragHintsOn;        // default: OFF
  1017.  
  1018.     // minimal dimensions for not-fixed bars in this pane (16x16 default)
  1019.  
  1020.     wxSize mMinCBarDim;
  1021.  
  1022.     // width/height of resizing sash
  1023.  
  1024.     int    mResizeHandleSize;
  1025.  
  1026.         // Default constructor.
  1027.  
  1028.     cbCommonPaneProperties(void);
  1029.  
  1030.         // Copy constructor
  1031.     
  1032.     cbCommonPaneProperties(const cbCommonPaneProperties&);
  1033.  
  1034.         // Assignment operator
  1035.     
  1036.     cbCommonPaneProperties& operator=(const cbCommonPaneProperties&);
  1037. };
  1038.  
  1039. /*
  1040. This class manages containment and control of control bars
  1041. along one of the four edges of the parent frame.
  1042. */
  1043.  
  1044. class cbDockPane : public wxObject
  1045. {
  1046. public:
  1047.     DECLARE_DYNAMIC_CLASS( cbDockPane )
  1048.  
  1049.     // look-and-feel configuration for this pane
  1050.     cbCommonPaneProperties mProps;
  1051.  
  1052.     // pane margins (in frame's coordinate-syst. orientation)
  1053.  
  1054.     int             mLeftMargin;     // default: 2 pixels
  1055.     int             mRightMargin;     // default: 2 pixels
  1056.     int             mTopMargin;         // default: 2 pixels
  1057.     int             mBottomMargin;   // default: 2 pixels
  1058.  
  1059. public:
  1060.     // position of the pane in frame's coordinates
  1061.     wxRect          mBoundsInParent;
  1062.  
  1063.     // pane width and height in pane's coordinates
  1064.     int             mPaneWidth;
  1065.     int             mPaneHeight;
  1066.  
  1067.     int                mAlignment;
  1068.  
  1069.     // info stored for updates-manager
  1070.     cbUpdateMgrData mUMgrData;
  1071.  
  1072. public: /* protected really */
  1073.  
  1074.     RowArrayT        mRows;
  1075.     wxFrameLayout*  mpLayout;         // back-ref
  1076.  
  1077.     // transient properties
  1078.  
  1079.     wxList          mRowShapeData;   // shapes of bars of recently modified row,
  1080.                                      // stored when in "non-destructive-friction" mode
  1081.     cbRowInfo*      mpStoredRow;     // row-info for which the shapes are stored
  1082.  
  1083.     friend class wxFrameLayout;
  1084.  
  1085. public: /* protected really (accessed only by plugins) */
  1086.  
  1087.         // Returns the row info for a row index. Internal function called by plugins.
  1088.  
  1089.     cbRowInfo* GetRow( int row );
  1090.  
  1091.         // Returns the row index for the given row info.  Internal function called by plugins.
  1092.  
  1093.     int GetRowIndex( cbRowInfo* pRow );
  1094.  
  1095.         // Returns the row at the given vertical position.
  1096.         // Returns -1 if the row is not present at given vertical position.
  1097.         // Internal function called by plugins.
  1098.  
  1099.     int     GetRowAt( int paneY );
  1100.  
  1101.         // Returns the row between the given vertical positions.
  1102.         // Returns -1 if the row is not present.
  1103.         // Internal function called by plugins.
  1104.  
  1105.     int     GetRowAt( int upperY, int lowerY );
  1106.  
  1107.         // Sets up flags in the row information structure, so that
  1108.         // they match the changed state of row items correctly.
  1109.         // Internal function called by plugins.
  1110.  
  1111.     void SyncRowFlags( cbRowInfo* pRow );
  1112.  
  1113.         // Returns TRUE if the bar's dimension information indicates a fixed size.
  1114.         // Internal function called by plugins.
  1115.  
  1116.     bool IsFixedSize( cbBarInfo* pInfo );
  1117.  
  1118.         // Returns the number of bars whose size is not fixed.
  1119.         // Internal function called by plugins.
  1120.  
  1121.     int  GetNotFixedBarsCount( cbRowInfo* pRow );
  1122.  
  1123.         // Gets the vertical position at the given row.
  1124.         // Internal function called by plugins.
  1125.  
  1126.     int GetRowY( cbRowInfo* pRow );
  1127.  
  1128.         // Returns TRUE if there are any variable-sized rows above this one.
  1129.         // Internal function called by plugins.
  1130.  
  1131.     bool HasNotFixedRowsAbove( cbRowInfo* pRow );
  1132.  
  1133.         // Returns TRUE if there are any variable-sized rows below this one.
  1134.         // Internal function called by plugins.
  1135.  
  1136.     bool HasNotFixedRowsBelow( cbRowInfo* pRow );
  1137.  
  1138.         // Returns TRUE if there are any variable-sized rows to the left of this one.
  1139.         // Internal function called by plugins.
  1140.  
  1141.     bool HasNotFixedBarsLeft ( cbBarInfo* pBar );
  1142.  
  1143.         // Returns TRUE if there are any variable-sized rows to the right of this one.
  1144.         // Internal function called by plugins.
  1145.  
  1146.     bool HasNotFixedBarsRight( cbBarInfo* pBar );
  1147.  
  1148.         // Calculate lengths.
  1149.         // Internal function called by plugins.
  1150.  
  1151.     virtual void CalcLengthRatios( cbRowInfo* pInRow );
  1152.  
  1153.         // Generates a cbLayoutRowEvent event to recalculate row layouts.
  1154.         // Internal function called by plugins.
  1155.  
  1156.     virtual void RecalcRowLayout( cbRowInfo* pRow );
  1157.  
  1158.         // Expands the bar.
  1159.         // Internal function called by plugins.
  1160.  
  1161.     virtual void ExpandBar( cbBarInfo* pBar );
  1162.  
  1163.         // Contracts the bar.
  1164.         // Internal function called by plugins.
  1165.  
  1166.     virtual void ContractBar( cbBarInfo* pBar );
  1167.  
  1168.         // Sets up links between bars.
  1169.         // Internal function called by plugins.
  1170.  
  1171.     void InitLinksForRow( cbRowInfo* pRow );
  1172.  
  1173.         // Sets up links between bars.
  1174.         // Internal function called by plugins.
  1175.  
  1176.     void InitLinksForRows();
  1177.  
  1178.         // Coordinate translation between parent's frame and this pane.
  1179.         // Internal function called by plugins.
  1180.  
  1181.     void FrameToPane( int* x, int* y );
  1182.  
  1183.         // Coordinate translation between parent's frame and this pane.
  1184.         // Internal function called by plugins.
  1185.  
  1186.     void PaneToFrame( int* x, int* y );
  1187.  
  1188.         // Coordinate translation between parent's frame and this pane.
  1189.         // Internal function called by plugins.
  1190.  
  1191.     void FrameToPane( wxRect* pRect );
  1192.  
  1193.         // Coordinate translation between parent's frame and this pane.
  1194.         // Internal function called by plugins.
  1195.  
  1196.     void PaneToFrame( wxRect* pRect );
  1197.  
  1198.         // Returns TRUE if pos is within the given rectangle.
  1199.         // Internal function called by plugins.
  1200.  
  1201.     inline bool HasPoint( const wxPoint& pos, int x, int y, int width, int height );
  1202.  
  1203.         // Returns the minimal row height for the given row.
  1204.         // Internal function called by plugins.
  1205.  
  1206.     int GetMinimalRowHeight( cbRowInfo* pRow );
  1207.  
  1208.         // Sets the row height for the given height. newHeight includes the height of row handles, if present.
  1209.         // Internal function called by plugins.
  1210.  
  1211.     void SetRowHeight( cbRowInfo* pRow, int newHeight );
  1212.  
  1213.         // Inserts the bar at the given row number.
  1214.         // Internal function called by plugins.
  1215.  
  1216.     void DoInsertBar( cbBarInfo* pBar, int rowNo );
  1217.  
  1218. public: /* protected really (accessed only by plugins) */
  1219.  
  1220.         // Generates a cbDrawBarDecorEvent and sends it to the layout to paint the bar decorations.
  1221.         // Internal function called by plugins.
  1222.  
  1223.     virtual void PaintBarDecorations( cbBarInfo* pBar, wxDC& dc );
  1224.  
  1225.         // Generates a cbDrawBarHandlesEvent and sends it to the layout to paint the bar handles.
  1226.         // Internal function called by plugins.
  1227.  
  1228.     virtual void PaintBarHandles( cbBarInfo* pBar, wxDC& dc );
  1229.  
  1230.         // Calls PaintBarDecorations and PaintBarHandles.
  1231.         // Internal function called by plugins.
  1232.  
  1233.     virtual void PaintBar( cbBarInfo* pBar, wxDC& dc );
  1234.  
  1235.         // Generates cbDrawRowHandlesEvent and cbDrawRowDecorEvent and sends them to the layout.
  1236.         // Internal function called by plugins.
  1237.  
  1238.     virtual void PaintRowHandles( cbRowInfo* pRow, wxDC& dc );
  1239.  
  1240.         // Generates cbDrawRowBkGroundEvent and sends it to the layout.
  1241.         // Internal function called by plugins.
  1242.  
  1243.     virtual void PaintRowBackground ( cbRowInfo* pRow, wxDC& dc );
  1244.  
  1245.         // Calls PaintBarDecorations for each row.
  1246.         // Internal function called by plugins.
  1247.  
  1248.     virtual void PaintRowDecorations( cbRowInfo* pRow, wxDC& dc );
  1249.  
  1250.         // Calls PaintRowBackground, PaintRowDecorations, PaintRowHandles.
  1251.         // Internal function called by plugins.
  1252.  
  1253.     virtual void PaintRow( cbRowInfo* pRow, wxDC& dc );
  1254.  
  1255.         // Generates cbDrawPaneBkGroundEvent and sends it to the layout.
  1256.         // Internal function called by plugins.
  1257.  
  1258.     virtual void PaintPaneBackground( wxDC& dc );
  1259.  
  1260.         // Generates cbDrawPaneDecorEvent and sends it to the layout.
  1261.         // Internal function called by plugins.
  1262.  
  1263.     virtual void PaintPaneDecorations( wxDC& dc );
  1264.  
  1265.         // Paints the pane background, the row background and decorations,
  1266.         // and finally the pane decorations.
  1267.         // Internal function called by plugins.
  1268.  
  1269.     virtual void PaintPane( wxDC& dc );
  1270.  
  1271.         // Generates a cbSizeBarWndEvent and sends it to the layout.
  1272.         // Internal function called by plugins.
  1273.  
  1274.     virtual void SizeBar( cbBarInfo* pBar );
  1275.  
  1276.         // Calls SizeBar for each bar in the row.
  1277.         // Internal function called by plugins.
  1278.  
  1279.     virtual void SizeRowObjects( cbRowInfo* pRow );
  1280.  
  1281.         // Calls SizeRowObjects for each row.
  1282.         // Internal function called by plugins.
  1283.  
  1284.     virtual void SizePaneObjects();
  1285.  
  1286.         // Generates cbStartDrawInAreaEvent and sends it to the layout.
  1287.         // Internal function called by plugins.
  1288.  
  1289.     virtual wxDC* StartDrawInArea ( const wxRect& area );
  1290.  
  1291.         // Generates cbFinishDrawInAreaEvent and sends it to the layout.
  1292.         // Internal function called by plugins.
  1293.  
  1294.     virtual void  FinishDrawInArea( const wxRect& area );
  1295.  
  1296. public: /* public members */
  1297.  
  1298.         // Default constructor.
  1299.  
  1300.     cbDockPane(void);
  1301.  
  1302.         // Constructor, taking alignment and layout panel.
  1303.  
  1304.     cbDockPane( int alignment, wxFrameLayout* pPanel );
  1305.  
  1306.         // Sets pane's margins in frame's coordinate orientations.
  1307.  
  1308.     void SetMargins( int top, int bottom, int left, int right );
  1309.  
  1310.         // Destructor.
  1311.  
  1312.     virtual ~cbDockPane();
  1313.  
  1314.         // Removes the bar from this pane. Does not destroy the bar.
  1315.  
  1316.     virtual void RemoveBar( cbBarInfo* pBar );
  1317.  
  1318.         // Inserts the bar into this pane. rect is given in the parent frame's coordinates.
  1319.  
  1320.     virtual void InsertBar( cbBarInfo* pBar, const wxRect& rect );
  1321.  
  1322.         // Inserts the bar into the given row, with dimensions and position
  1323.         // stored in pBarInfo->mBounds. Returns the node of inserted bar.
  1324.  
  1325.     virtual void InsertBar( cbBarInfo* pBar, cbRowInfo* pIntoRow );
  1326.  
  1327.         // Inserts bar and sets its position according to the preferred settings
  1328.         // given in pBarInfo.
  1329.  
  1330.     virtual void InsertBar( cbBarInfo* pBarInfo );
  1331.  
  1332.         // Removes the row from this pane. Does not destroy the row object.
  1333.  
  1334.     virtual void RemoveRow( cbRowInfo* pRow );
  1335.  
  1336.         // Inserts a row. Does not refresh the inserted row immediately.
  1337.         // If pBeforeRowNode is NULL, the row is appended to the end of pane's row list.
  1338.  
  1339.     virtual void InsertRow( cbRowInfo* pRow, cbRowInfo* pBeforeRow );
  1340.  
  1341.         // Sets pane's width in the pane's coordinates (including margins).
  1342.  
  1343.     void SetPaneWidth(int width);
  1344.  
  1345.         // Set the position and dimensions of the pane in the parent frame's coordinates.
  1346.  
  1347.     void SetBoundsInParent( const wxRect& rect );
  1348.  
  1349.         // Returns the bounds of the pane, in parent coordinates.
  1350.  
  1351.     inline wxRect& GetRealRect() { return mBoundsInParent; }
  1352.  
  1353.         // Returns an array of rows. Used by updates-managers.
  1354.  
  1355.     inline RowArrayT& GetRowList() { return mRows; }
  1356.  
  1357.         // Returns the first row.
  1358.  
  1359.     inline cbRowInfo* GetFirstRow()
  1360.  
  1361.         { return mRows.GetCount() ? mRows[0] : NULL; }
  1362.  
  1363.         // Returns TRUE if the given bar is present in this pane.
  1364.  
  1365.     bool BarPresent( cbBarInfo* pBar );
  1366.  
  1367.         // Returns the height in the pane's coordinates.
  1368.  
  1369.     int GetPaneHeight();
  1370.  
  1371.         // Returns the alignment for this pane. The value is one of
  1372.         // FL_ALIGN_TOP, FL_ALIGN_BOTTOM, FL_ALIGN_LEFT, FL_ALIGN_RIGHT.
  1373.  
  1374.     int GetAlignment();
  1375.  
  1376.         // Returns TRUE if the given mask matches the pane's mask.
  1377.  
  1378.     bool MatchesMask( int paneMask );
  1379.  
  1380.         // Returns TRUE if the pane is aligned to the top or bottom.
  1381.  
  1382.     inline bool IsHorizontal()
  1383.     {
  1384.         return (mAlignment == FL_ALIGN_TOP ||
  1385.                 mAlignment == FL_ALIGN_BOTTOM );
  1386.     }
  1387.  
  1388.         // Generates events to perform layout calculations.
  1389.  
  1390.     virtual void RecalcLayout();
  1391.  
  1392.         // Returns wxCBAR_DOCKED_HORIZONTALLY if the alignment is top or bottom,
  1393.         // or wxCBAR_DOCKED_VERTICALLY otherwise.
  1394.  
  1395.     virtual int GetDockingState();
  1396.  
  1397.         // Returns the result of hit-testing items in the pane.
  1398.         // See CB_HITTEST_RESULT enumerated type.
  1399.         // pos is the position in this pane's coordinates.
  1400.  
  1401.     virtual int HitTestPaneItems( const wxPoint& pos,
  1402.                                   cbRowInfo**    ppRow,
  1403.                                   cbBarInfo**    ppBar
  1404.                                 );
  1405.  
  1406.         // Returns the bar's resize range.
  1407.  
  1408.     void GetBarResizeRange( cbBarInfo* pBar, int* from, int *till, bool forLeftHandle );
  1409.  
  1410.         // Returns the row's resize range.
  1411.  
  1412.     void GetRowResizeRange( cbRowInfo* pRow, int* from, int* till, bool forUpperHandle );
  1413.  
  1414.         // Finds the bar information by corresponding window.
  1415.  
  1416.     cbBarInfo* GetBarInfoByWindow( wxWindow* pBarWnd );
  1417.  
  1418. public: /* protected really (accessed only by plugins) */
  1419.  
  1420.         // Row/bar resizing related helper-method.
  1421.  
  1422.     void DrawVertHandle ( wxDC& dc, int x, int y, int height );
  1423.  
  1424.         // Row/bar resizing related helper-method.
  1425.  
  1426.     void DrawHorizHandle( wxDC& dc, int x, int y, int width  );
  1427.  
  1428.         // Row/bar resizing related helper-method.
  1429.  
  1430.     void ResizeRow( cbRowInfo* pRow, int ofs, bool forUpperHandle );
  1431.  
  1432.         // Row/bar resizing related helper-method.
  1433.  
  1434.     void ResizeBar( cbBarInfo* pBar, int ofs, bool forLeftHandle );
  1435.  
  1436.         // Returns row shape data.
  1437.         // cbBarShapeData objects will be added to the given pLst.
  1438.         // cbBarShapeData is used for storing the original bar's positions in the row,
  1439.         // when the 'non-destructive-friction' option is turned on.
  1440.  
  1441.     void GetRowShapeData( cbRowInfo* pRow, wxList* pLst );
  1442.  
  1443.         // Sets the shape data for the given row, using the data provided in pLst.
  1444.         // cbBarShapeData is used for storing the original bar's positions in the row,
  1445.         // when the 'non-destructive-friction' option is turned on.
  1446.  
  1447.     void SetRowShapeData( cbRowInfo* pRowNode, wxList* pLst );
  1448. };
  1449.  
  1450. /*
  1451. This class declares an abstract interface for optimized logic that should refresh
  1452. areas of frame layout that actually need to be updated. This should be extended in future
  1453. to implement a custom updating strategy.
  1454. */
  1455.  
  1456. class cbUpdatesManagerBase : public wxObject
  1457. {
  1458.     DECLARE_ABSTRACT_CLASS( cbUpdatesManagerBase )
  1459.  
  1460. public: /* protected really, accessed by serializer (if any) */
  1461.  
  1462.     wxFrameLayout* mpLayout;
  1463.  
  1464. public:
  1465.         // Default constructor
  1466.  
  1467.     cbUpdatesManagerBase(void)
  1468.         : mpLayout( 0 ) {}
  1469.  
  1470.         // Constructor taking layout panel.
  1471.  
  1472.     cbUpdatesManagerBase( wxFrameLayout* pPanel )
  1473.         : mpLayout( pPanel ) {}
  1474.  
  1475.         // Destructor.
  1476.  
  1477.     virtual ~cbUpdatesManagerBase() {}
  1478.  
  1479.         // Sets the associated layout.
  1480.  
  1481.     void SetLayout( wxFrameLayout* pLayout ) { mpLayout = pLayout; }
  1482.  
  1483.         // This function receives a notification from the frame layout (in the order in which
  1484.         // they would usually be invoked). Custom updates-managers may utilize
  1485.         // these notifications to implement a more fine-grained updating strategy.
  1486.  
  1487.     virtual void OnStartChanges() = 0;
  1488.  
  1489.         // This function receives a notification from the frame layout (in the order in which
  1490.         // they would usually be invoked). Custom updates-managers may utilize
  1491.         // these notifications to implement a more fine-grained updating strategy.
  1492.  
  1493.     virtual void OnRowWillChange( cbRowInfo* pRow, cbDockPane* pInPane ) {}
  1494.  
  1495.         // This function receives a notification from the frame layout (in the order in which
  1496.         // they would usually be invoked). Custom updates-managers may utilize
  1497.         // these notifications to implement a more fine-grained updating strategy.
  1498.  
  1499.     virtual void OnBarWillChange( cbBarInfo* pBar, cbRowInfo* pInRow, cbDockPane* pInPane ) {}
  1500.  
  1501.         // This function receives a notification from the frame layout (in the order in which
  1502.         // they would usually be invoked). Custom updates-managers may utilize
  1503.         // these notifications to implement a more fine-grained updating strategy.
  1504.  
  1505.     virtual void OnPaneMarginsWillChange( cbDockPane* pPane ) {}
  1506.  
  1507.         // This function receives a notification from the frame layout (in the order in which
  1508.         // they would usually be invoked). Custom updates-managers may utilize
  1509.         // these notifications to implement a more fine-grained updating strategy.
  1510.  
  1511.     virtual void OnPaneWillChange( cbDockPane* pPane ) {}
  1512.  
  1513.         // This function receives a notification from the frame layout (in the order in which
  1514.         // they would usually be invoked). Custom updates-managers may utilize
  1515.         // these notifications to implement a more fine-grained updating strategy.
  1516.  
  1517.     virtual void OnFinishChanges() {}
  1518.  
  1519.         // Refreshes parts of the frame layout that need an update.
  1520.  
  1521.     virtual void UpdateNow() = 0;
  1522. };
  1523.  
  1524. /*
  1525. Base class for all control-bar plugin events.
  1526. This is not a dynamically-creatable class.
  1527. */
  1528.  
  1529. class cbPluginEvent : public wxEvent
  1530. {
  1531. public:
  1532.         // NULL if event is not addressed to any specific pane.
  1533.  
  1534.     cbDockPane* mpPane;
  1535.  
  1536.         // Not used, but required.
  1537.  
  1538.     virtual wxEvent* Clone() const { return NULL; }
  1539.  
  1540.         // Constructor, taking event type and pane.
  1541.  
  1542.     cbPluginEvent( wxEventType eventType, cbDockPane* pPane )
  1543.         : mpPane( pPane )
  1544.  
  1545.         { m_eventType = eventType; }
  1546. };
  1547.  
  1548. // event types handled by plugins
  1549.  
  1550. extern wxEventType cbEVT_PL_LEFT_DOWN;
  1551. extern wxEventType cbEVT_PL_LEFT_UP;
  1552. extern wxEventType cbEVT_PL_RIGHT_DOWN;
  1553. extern wxEventType cbEVT_PL_RIGHT_UP;
  1554. extern wxEventType cbEVT_PL_MOTION;
  1555.  
  1556. extern wxEventType cbEVT_PL_LEFT_DCLICK;
  1557.  
  1558. extern wxEventType cbEVT_PL_LAYOUT_ROW;
  1559. extern wxEventType cbEVT_PL_RESIZE_ROW;
  1560. extern wxEventType cbEVT_PL_LAYOUT_ROWS;
  1561. extern wxEventType cbEVT_PL_INSERT_BAR;
  1562. extern wxEventType cbEVT_PL_RESIZE_BAR;
  1563. extern wxEventType cbEVT_PL_REMOVE_BAR;
  1564. extern wxEventType cbEVT_PL_SIZE_BAR_WND;
  1565.  
  1566. extern wxEventType cbEVT_PL_DRAW_BAR_DECOR;
  1567. extern wxEventType cbEVT_PL_DRAW_ROW_DECOR;
  1568. extern wxEventType cbEVT_PL_DRAW_PANE_DECOR;
  1569. extern wxEventType cbEVT_PL_DRAW_BAR_HANDLES;
  1570. extern wxEventType cbEVT_PL_DRAW_ROW_HANDLES;
  1571. extern wxEventType cbEVT_PL_DRAW_ROW_BKGROUND;
  1572. extern wxEventType cbEVT_PL_DRAW_PANE_BKGROUND;
  1573.  
  1574. extern wxEventType cbEVT_PL_START_BAR_DRAGGING;
  1575. extern wxEventType cbEVT_PL_DRAW_HINT_RECT;
  1576.  
  1577. extern wxEventType cbEVT_PL_START_DRAW_IN_AREA;
  1578. extern wxEventType cbEVT_PL_FINISH_DRAW_IN_AREA;
  1579.  
  1580. extern wxEventType cbEVT_PL_CUSTOMIZE_BAR;
  1581. extern wxEventType cbEVT_PL_CUSTOMIZE_LAYOUT;
  1582.  
  1583. extern wxEventType wxCUSTOM_CB_PLUGIN_EVENTS_START_AT;
  1584.  
  1585. // Forward declarations, separated by categories.
  1586.  
  1587. class cbLeftDownEvent;
  1588. class cbLeftUpEvent;
  1589. class cbRightDownEvent;
  1590. class cbRightUpEvent;
  1591. class cbMotionEvent;
  1592. class cbLeftDClickEvent;
  1593.  
  1594. class cbLayoutRowEvent;
  1595. class cbResizeRowEvent;
  1596. class cbLayoutRowsEvent;
  1597. class cbInsertBarEvent;
  1598. class cbResizeBarEvent;
  1599. class cbRemoveBarEvent;
  1600. class cbSizeBarWndEvent;
  1601.  
  1602. class cbDrawBarDecorEvent;
  1603. class cbDrawRowDecorEvent;
  1604. class cbDrawPaneDecorEvent;
  1605. class cbDrawBarHandlesEvent;
  1606. class cbDrawRowHandlesEvent;
  1607. class cbDrawRowBkGroundEvent;
  1608. class cbDrawPaneBkGroundEvent;
  1609.  
  1610. class cbStartBarDraggingEvent;
  1611. class cbDrawHintRectEvent;
  1612.  
  1613. class cbStartDrawInAreaEvent;
  1614. class cbFinishDrawInAreaEvent;
  1615.  
  1616. class cbCustomizeBarEvent;
  1617. class cbCustomizeLayoutEvent;
  1618.  
  1619. // Definitions for for handler-methods.
  1620.  
  1621. typedef void (wxEvtHandler::*cbLeftDownHandler        )(cbLeftDownEvent&);
  1622. typedef void (wxEvtHandler::*cbLeftUpHandler          )(cbLeftUpEvent&);
  1623. typedef void (wxEvtHandler::*cbRightDownHandler       )(cbRightDownEvent&);
  1624. typedef void (wxEvtHandler::*cbRightUpHandler         )(cbRightUpEvent&);
  1625. typedef void (wxEvtHandler::*cbMotionHandler          )(cbMotionEvent&);
  1626. typedef void (wxEvtHandler::*cbLeftDClickHandler      )(cbLeftDClickEvent&);
  1627.  
  1628. typedef void (wxEvtHandler::*cbLayoutRowHandler       )(cbLayoutRowEvent&);
  1629. typedef void (wxEvtHandler::*cbResizeRowHandler       )(cbResizeRowEvent&);
  1630. typedef void (wxEvtHandler::*cbLayoutRowsHandler      )(cbLayoutRowsEvent&);
  1631. typedef void (wxEvtHandler::*cbInsertBarHandler       )(cbInsertBarEvent&);
  1632. typedef void (wxEvtHandler::*cbResizeBarHandler       )(cbResizeBarEvent&);
  1633. typedef void (wxEvtHandler::*cbRemoveBarHandler       )(cbRemoveBarEvent&);
  1634. typedef void (wxEvtHandler::*cbSizeBarWndHandler      )(cbSizeBarWndEvent&);
  1635.  
  1636. typedef void (wxEvtHandler::*cbDrawBarDecorHandler    )(cbDrawBarDecorEvent&);
  1637. typedef void (wxEvtHandler::*cbDrawRowDecorHandler    )(cbDrawRowDecorEvent&);
  1638. typedef void (wxEvtHandler::*cbDrawPaneDecorHandler   )(cbDrawPaneDecorEvent&);
  1639. typedef void (wxEvtHandler::*cbDrawBarHandlesHandler  )(cbDrawBarHandlesEvent&);
  1640. typedef void (wxEvtHandler::*cbDrawRowHandlesHandler  )(cbDrawRowHandlesEvent&);
  1641. typedef void (wxEvtHandler::*cbDrawRowBkGroundHandler )(cbDrawRowBkGroundEvent&);
  1642. typedef void (wxEvtHandler::*cbDrawPaneBkGroundHandler)(cbDrawPaneBkGroundEvent&);
  1643.  
  1644. typedef void (wxEvtHandler::*cbStartBarDraggingHandler )(cbStartBarDraggingEvent&);
  1645. typedef void (wxEvtHandler::*cbDrawHintRectHandler     )(cbDrawHintRectEvent&);
  1646.  
  1647. typedef void (wxEvtHandler::*cbStartDrawInAreaHandler )(cbStartDrawInAreaEvent&);
  1648. typedef void (wxEvtHandler::*cbFinishDrawInAreaHandler)(cbFinishDrawInAreaEvent&);
  1649.  
  1650. typedef void (wxEvtHandler::*cbCustomizeBarHandler    )(cbCustomizeBarEvent&);
  1651. typedef void (wxEvtHandler::*cbCustomizeLayoutHandler )(cbCustomizeLayoutEvent&);
  1652.  
  1653. // Macros for creating event table entries for plugin-events.
  1654.  
  1655. #define EVT_PL_LEFT_DOWN(func)             wxEventTableEntry( cbEVT_PL_LEFT_DOWN,             -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLeftDownHandler        ) & func, (wxObject *) NULL ),
  1656. #define EVT_PL_LEFT_UP(func)             wxEventTableEntry( cbEVT_PL_LEFT_UP,             -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLeftUpHandler          ) & func, (wxObject *) NULL ),
  1657. #define EVT_PL_RIGHT_DOWN(func)             wxEventTableEntry( cbEVT_PL_RIGHT_DOWN,             -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbRightDownHandler       ) & func, (wxObject *) NULL ),
  1658. #define EVT_PL_RIGHT_UP(func)             wxEventTableEntry( cbEVT_PL_RIGHT_UP,             -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbRightUpHandler         ) & func, (wxObject *) NULL ),
  1659. #define EVT_PL_MOTION(func)                 wxEventTableEntry( cbEVT_PL_MOTION,                 -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbMotionHandler          ) & func, (wxObject *) NULL ),
  1660. #define EVT_PL_LEFT_DCLICK(func)         wxEventTableEntry( cbEVT_PL_LEFT_DCLICK,         -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLeftDClickHandler      ) & func, (wxObject *) NULL ),
  1661.  
  1662. #define EVT_PL_LAYOUT_ROW(func)             wxEventTableEntry( cbEVT_PL_LAYOUT_ROW,             -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLayoutRowHandler       ) & func, (wxObject *) NULL ),
  1663. #define EVT_PL_RESIZE_ROW(func)             wxEventTableEntry( cbEVT_PL_RESIZE_ROW,             -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbResizeRowHandler       ) & func, (wxObject *) NULL ),
  1664. #define EVT_PL_LAYOUT_ROWS(func)         wxEventTableEntry( cbEVT_PL_LAYOUT_ROWS,         -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLayoutRowsHandler      ) & func, (wxObject *) NULL ),
  1665. #define EVT_PL_INSERT_BAR(func)             wxEventTableEntry( cbEVT_PL_INSERT_BAR,             -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbInsertBarHandler       ) & func, (wxObject *) NULL ),
  1666. #define EVT_PL_RESIZE_BAR(func)             wxEventTableEntry( cbEVT_PL_RESIZE_BAR,             -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbResizeBarHandler       ) & func, (wxObject *) NULL ),
  1667. #define EVT_PL_REMOVE_BAR(func)             wxEventTableEntry( cbEVT_PL_REMOVE_BAR,             -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbRemoveBarHandler       ) & func, (wxObject *) NULL ),
  1668. #define EVT_PL_SIZE_BAR_WND(func)         wxEventTableEntry( cbEVT_PL_SIZE_BAR_WND,         -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbSizeBarWndHandler      ) & func, (wxObject *) NULL ),
  1669.  
  1670. #define EVT_PL_DRAW_BAR_DECOR(func)      wxEventTableEntry( cbEVT_PL_DRAW_BAR_DECOR,      -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawBarDecorHandler    ) & func, (wxObject *) NULL ),
  1671. #define EVT_PL_DRAW_ROW_DECOR(func)      wxEventTableEntry( cbEVT_PL_DRAW_ROW_DECOR,      -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawRowDecorHandler    ) & func, (wxObject *) NULL ),
  1672. #define EVT_PL_DRAW_PANE_DECOR(func)     wxEventTableEntry( cbEVT_PL_DRAW_PANE_DECOR,     -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawPaneDecorHandler   ) & func, (wxObject *) NULL ),
  1673. #define EVT_PL_DRAW_BAR_HANDLES(func)    wxEventTableEntry( cbEVT_PL_DRAW_BAR_HANDLES,    -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawBarHandlesHandler  ) & func, (wxObject *) NULL ),
  1674. #define EVT_PL_DRAW_ROW_HANDLES(func)    wxEventTableEntry( cbEVT_PL_DRAW_ROW_HANDLES,    -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawRowHandlesHandler  ) & func, (wxObject *) NULL ),
  1675. #define EVT_PL_DRAW_ROW_BKGROUND(func)   wxEventTableEntry( cbEVT_PL_DRAW_ROW_BKGROUND,   -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawRowBkGroundHandler ) & func, (wxObject *) NULL ),
  1676. #define EVT_PL_DRAW_PANE_BKGROUND(func)  wxEventTableEntry( cbEVT_PL_DRAW_PANE_BKGROUND,  -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawPaneBkGroundHandler) & func, (wxObject *) NULL ),
  1677.  
  1678. #define EVT_PL_START_BAR_DRAGGING(func)  wxEventTableEntry( cbEVT_PL_START_BAR_DRAGGING,  -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbStartBarDraggingHandler) & func, (wxObject *) NULL ),
  1679. #define EVT_PL_DRAW_HINT_RECT(func)      wxEventTableEntry( cbEVT_PL_DRAW_HINT_RECT,      -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawHintRectHandler    ) & func, (wxObject *) NULL ),
  1680.  
  1681.  
  1682. #define EVT_PL_START_DRAW_IN_AREA(func)  wxEventTableEntry( cbEVT_PL_START_DRAW_IN_AREA,  -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbStartDrawInAreaHandler)  & func, (wxObject *) NULL ),
  1683. #define EVT_PL_FINISH_DRAW_IN_AREA(func) wxEventTableEntry( cbEVT_PL_FINISH_DRAW_IN_AREA, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbFinishDrawInAreaHandler) & func, (wxObject *) NULL ),
  1684.  
  1685. #define EVT_PL_CUSTOMIZE_BAR(func)       wxEventTableEntry( cbEVT_PL_CUSTOMIZE_BAR,       -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbCustomizeBarHandler)     & func, (wxObject *) NULL ),
  1686. #define EVT_PL_CUSTOMIZE_LAYOUT(func)    wxEventTableEntry( cbEVT_PL_CUSTOMIZE_LAYOUT,    -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbCustomizeLayoutHandler)  & func, (wxObject *) NULL ),
  1687.  
  1688. /*
  1689. Abstract base class for all control-bar related plugins.
  1690. Note: pointer positions of mouse events sent to plugins
  1691. are always in the pane's coordinates (the pane to which
  1692. this plugin is hooked).
  1693. */
  1694.  
  1695. class cbPluginBase : public wxEvtHandler
  1696. {
  1697.     DECLARE_ABSTRACT_CLASS( cbPluginBase )
  1698. public:
  1699.         // Back-reference to the frame layout.
  1700.  
  1701.     wxFrameLayout* mpLayout;
  1702.  
  1703.         // Specifies panes for which this plugin receives events
  1704.         // (see pane masks definitions).
  1705.  
  1706.     int            mPaneMask;
  1707.  
  1708.         // Is TRUE when plugin is ready to handle events.
  1709.  
  1710.     bool           mIsReady;
  1711.  
  1712. public:
  1713.         // Default constructor.
  1714.  
  1715.     cbPluginBase()
  1716.  
  1717.         : mpLayout  ( 0 ),
  1718.           mPaneMask( wxALL_PANES ),
  1719.           mIsReady ( FALSE )
  1720.     {}
  1721.  
  1722.         // Constructor taking layout panel and a mask.
  1723.  
  1724.     cbPluginBase( wxFrameLayout* pPanel, int paneMask = wxALL_PANES )
  1725.  
  1726.         : mpLayout  ( pPanel ),
  1727.           mPaneMask( paneMask ),
  1728.           mIsReady ( FALSE )
  1729.     {}
  1730.  
  1731.         // Returns the pane mask.
  1732.  
  1733.     inline int GetPaneMask() { return mPaneMask; }
  1734.  
  1735.         // Destructor. Destroys the whole plugin chain of connected plugins.
  1736.  
  1737.     virtual ~cbPluginBase();
  1738.  
  1739.         // Override this method to do plugin-specific initialization.
  1740.         // At this point plugin is already attached to the frame layout,
  1741.         // and pane masks are set.
  1742.  
  1743.     virtual void OnInitPlugin() { mIsReady = TRUE; }
  1744.  
  1745.         // Returns TRUE if the plugin is ready to receive events.
  1746.  
  1747.     bool IsReady() { return mIsReady; }
  1748.  
  1749.         // Overridden to determine whether the target pane specified in the
  1750.         // event matches the pane mask of this plugin (specific plugins
  1751.         // do not override this method).
  1752.  
  1753.     virtual bool ProcessEvent(wxEvent& event);
  1754. };
  1755.  
  1756. /*
  1757. Class for mouse left down events.
  1758. */
  1759.  
  1760. class cbLeftDownEvent : public cbPluginEvent
  1761. {
  1762. public:
  1763.     wxPoint mPos;
  1764.  
  1765.         // Constructor, taking mouse position and pane.
  1766.  
  1767.     cbLeftDownEvent( const wxPoint& pos, cbDockPane* pPane )
  1768.  
  1769.         : cbPluginEvent( cbEVT_PL_LEFT_DOWN, pPane ),
  1770.           mPos( pos )
  1771.     {}
  1772. };
  1773.  
  1774. /*
  1775. Class for mouse left up events.
  1776. */
  1777.  
  1778. class cbLeftUpEvent : public cbPluginEvent
  1779. {
  1780. public:
  1781.     wxPoint mPos;
  1782.  
  1783.         // Constructor, taking mouse position and pane.
  1784.  
  1785.     cbLeftUpEvent( const wxPoint& pos, cbDockPane* pPane )
  1786.  
  1787.         : cbPluginEvent( cbEVT_PL_LEFT_UP, pPane ),
  1788.           mPos( pos )
  1789.     {}
  1790. };
  1791.  
  1792. /*
  1793. Class for mouse right down events.
  1794. */
  1795.  
  1796. class cbRightDownEvent : public cbPluginEvent
  1797. {
  1798. public:
  1799.     wxPoint mPos;
  1800.  
  1801.         // Constructor, taking mouse position and pane.
  1802.  
  1803.     cbRightDownEvent( const wxPoint& pos, cbDockPane* pPane )
  1804.  
  1805.         : cbPluginEvent( cbEVT_PL_RIGHT_DOWN, pPane ),
  1806.           mPos( pos )
  1807.     {}
  1808. };
  1809.  
  1810. /*
  1811. Class for mouse right up events.
  1812. */
  1813.  
  1814. class cbRightUpEvent : public cbPluginEvent
  1815. {
  1816. public:
  1817.     wxPoint mPos;
  1818.  
  1819.         // Constructor, taking mouse position and pane.
  1820.  
  1821.     cbRightUpEvent( const wxPoint& pos, cbDockPane* pPane )
  1822.  
  1823.         : cbPluginEvent( cbEVT_PL_RIGHT_UP, pPane ),
  1824.           mPos( pos )
  1825.     {}
  1826. };
  1827.  
  1828. /*
  1829. Class for mouse motion events.
  1830. */
  1831.  
  1832. class cbMotionEvent : public cbPluginEvent
  1833. {
  1834. public:
  1835.     wxPoint mPos;
  1836.  
  1837.         // Constructor, taking mouse position and pane.
  1838.  
  1839.     cbMotionEvent( const wxPoint& pos, cbDockPane* pPane )
  1840.  
  1841.         : cbPluginEvent( cbEVT_PL_MOTION, pPane ),
  1842.           mPos( pos )
  1843.     {}
  1844. };
  1845.  
  1846. /*
  1847. Class for mouse left double click events.
  1848. */
  1849.  
  1850. class cbLeftDClickEvent : public cbPluginEvent
  1851. {
  1852. public:
  1853.     wxPoint mPos;
  1854.  
  1855.         // Constructor, taking mouse position and pane.
  1856.  
  1857.     cbLeftDClickEvent( const wxPoint& pos, cbDockPane* pPane )
  1858.  
  1859.         : cbPluginEvent( cbEVT_PL_LEFT_DCLICK, pPane ),
  1860.           mPos( pos )
  1861.     {}
  1862. };
  1863.  
  1864. /*
  1865. Class for single row layout events.
  1866. */
  1867.  
  1868. class cbLayoutRowEvent : public cbPluginEvent
  1869. {
  1870. public:
  1871.     cbRowInfo* mpRow;
  1872.  
  1873.         // Constructor, taking row information and pane.
  1874.  
  1875.     cbLayoutRowEvent( cbRowInfo* pRow, cbDockPane* pPane )
  1876.  
  1877.         : cbPluginEvent( cbEVT_PL_LAYOUT_ROW, pPane ),
  1878.           mpRow( pRow )
  1879.     {}
  1880. };
  1881.  
  1882. /*
  1883. Class for row resize events.
  1884. */
  1885.  
  1886. class cbResizeRowEvent : public cbPluginEvent
  1887. {
  1888. public:
  1889.     cbRowInfo* mpRow;
  1890.     int        mHandleOfs;
  1891.     bool       mForUpperHandle;
  1892.  
  1893.         // Constructor, taking row information, two parameters of currently unknown use, and pane.
  1894.  
  1895.     cbResizeRowEvent( cbRowInfo* pRow, int handleOfs, bool forUpperHandle, cbDockPane* pPane )
  1896.  
  1897.         : cbPluginEvent( cbEVT_PL_RESIZE_ROW, pPane ),
  1898.           mpRow( pRow ),
  1899.           mHandleOfs( handleOfs ),
  1900.           mForUpperHandle( forUpperHandle )
  1901.     {}
  1902. };
  1903.  
  1904. /*
  1905. Class for multiple rows layout events.
  1906. */
  1907.  
  1908. class cbLayoutRowsEvent : public cbPluginEvent
  1909. {
  1910. public:
  1911.  
  1912.         // Constructor, taking pane.
  1913.  
  1914.     cbLayoutRowsEvent( cbDockPane* pPane )
  1915.  
  1916.         : cbPluginEvent( cbEVT_PL_LAYOUT_ROWS, pPane )
  1917.     {}
  1918. };
  1919.  
  1920. /*
  1921. Class for bar insertion events.
  1922. */
  1923.  
  1924. class cbInsertBarEvent : public cbPluginEvent
  1925. {
  1926. public:
  1927.     cbBarInfo*  mpBar;
  1928.     cbRowInfo*  mpRow;
  1929.  
  1930.         // Constructor, taking bar information, row information, and pane.
  1931.  
  1932.     cbInsertBarEvent( cbBarInfo* pBar, cbRowInfo* pIntoRow, cbDockPane* pPane )
  1933.  
  1934.         : cbPluginEvent( cbEVT_PL_INSERT_BAR, pPane ),
  1935.  
  1936.           mpBar( pBar     ),
  1937.           mpRow( pIntoRow )
  1938.     {}
  1939. };
  1940.  
  1941. /*
  1942. Class for bar resize events.
  1943. */
  1944.  
  1945. class cbResizeBarEvent : public cbPluginEvent
  1946. {
  1947. public:
  1948.     cbBarInfo* mpBar;
  1949.     cbRowInfo* mpRow;
  1950.  
  1951.         // Constructor, taking bar information, row information, and pane.
  1952.  
  1953.     cbResizeBarEvent( cbBarInfo* pBar, cbRowInfo* pRow, cbDockPane* pPane )
  1954.  
  1955.         : cbPluginEvent( cbEVT_PL_RESIZE_BAR, pPane ),
  1956.           mpBar( pBar ),
  1957.           mpRow( pRow )
  1958.     {}
  1959. };
  1960.  
  1961. /*
  1962. Class for bar removal events.
  1963. */
  1964.  
  1965. class cbRemoveBarEvent : public cbPluginEvent
  1966. {
  1967. public:
  1968.     cbBarInfo* mpBar;
  1969.  
  1970.         // Constructor, taking bar information and pane.
  1971.  
  1972.     cbRemoveBarEvent( cbBarInfo* pBar, cbDockPane* pPane )
  1973.  
  1974.         : cbPluginEvent( cbEVT_PL_REMOVE_BAR, pPane ),
  1975.           mpBar( pBar )
  1976.     {}
  1977. };
  1978.  
  1979. /*
  1980. Class for bar window resize events.
  1981. */
  1982.  
  1983. class cbSizeBarWndEvent : public cbPluginEvent
  1984. {
  1985. public:
  1986.     cbBarInfo* mpBar;
  1987.     wxRect     mBoundsInParent;
  1988.  
  1989.         // Constructor, taking bar information and pane.
  1990.  
  1991.     cbSizeBarWndEvent( cbBarInfo* pBar, cbDockPane* pPane )
  1992.  
  1993.         : cbPluginEvent( cbEVT_PL_SIZE_BAR_WND, pPane ),
  1994.           mpBar( pBar ),
  1995.           mBoundsInParent( pBar->mBoundsInParent )
  1996.     {}
  1997. };
  1998.  
  1999. /*
  2000. Class for bar decoration drawing events.
  2001. */
  2002.  
  2003. class cbDrawBarDecorEvent : public cbPluginEvent
  2004. {
  2005. public:
  2006.     cbBarInfo* mpBar;
  2007.     wxDC*      mpDc;
  2008.     wxRect     mBoundsInParent;
  2009.  
  2010.         // Constructor, taking bar information, device context, and pane.
  2011.  
  2012.     cbDrawBarDecorEvent( cbBarInfo* pBar, wxDC& dc, cbDockPane* pPane )
  2013.  
  2014.         : cbPluginEvent( cbEVT_PL_DRAW_BAR_DECOR, pPane ),
  2015.           mpBar( pBar ),
  2016.           mpDc( &dc ),
  2017.           mBoundsInParent( pBar->mBoundsInParent )
  2018.     {}
  2019. };
  2020.  
  2021. /*
  2022. Class for row decoration drawing events.
  2023. */
  2024.  
  2025. class cbDrawRowDecorEvent : public cbPluginEvent
  2026. {
  2027. public:
  2028.     cbRowInfo* mpRow;
  2029.     wxDC*      mpDc;
  2030.  
  2031.         // Constructor, taking row information, device context, and pane.
  2032.  
  2033.     cbDrawRowDecorEvent( cbRowInfo* pRow, wxDC& dc, cbDockPane* pPane )
  2034.  
  2035.         : cbPluginEvent( cbEVT_PL_DRAW_ROW_DECOR, pPane ),
  2036.           mpRow( pRow ),
  2037.           mpDc( &dc )
  2038.     {}
  2039. };
  2040.  
  2041. /*
  2042. Class for pane decoration drawing events.
  2043. */
  2044.  
  2045. class cbDrawPaneDecorEvent : public cbPluginEvent
  2046. {
  2047. public:
  2048.     wxDC* mpDc;
  2049.  
  2050.         // Constructor, taking device context and pane.
  2051.  
  2052.     cbDrawPaneDecorEvent( wxDC& dc, cbDockPane* pPane )
  2053.  
  2054.         : cbPluginEvent( cbEVT_PL_DRAW_PANE_DECOR, pPane ),
  2055.           mpDc( &dc )
  2056.     {}
  2057. };
  2058.  
  2059. /*
  2060. Class for bar handles drawing events.
  2061. */
  2062.  
  2063. class cbDrawBarHandlesEvent : public cbPluginEvent
  2064. {
  2065. public:
  2066.     cbBarInfo* mpBar;
  2067.     wxDC*   mpDc;
  2068.  
  2069.         // Constructor, taking bar information, device context, and pane.
  2070.  
  2071.     cbDrawBarHandlesEvent( cbBarInfo* pBar, wxDC& dc, cbDockPane* pPane )
  2072.  
  2073.         : cbPluginEvent( cbEVT_PL_DRAW_BAR_HANDLES, pPane ),
  2074.           mpBar( pBar ),
  2075.           mpDc( &dc )
  2076.     {}
  2077. };
  2078.  
  2079. /*
  2080. Class for row handles drawing events.
  2081. */
  2082.  
  2083. class cbDrawRowHandlesEvent : public cbPluginEvent
  2084. {
  2085. public:
  2086.     cbRowInfo* mpRow;
  2087.     wxDC*      mpDc;
  2088.  
  2089.         // Constructor, taking row information, device context, and pane.
  2090.  
  2091.     cbDrawRowHandlesEvent( cbRowInfo* pRow, wxDC& dc, cbDockPane* pPane )
  2092.  
  2093.         : cbPluginEvent( cbEVT_PL_DRAW_ROW_HANDLES, pPane ),
  2094.           mpRow( pRow ),
  2095.           mpDc( &dc )
  2096.     {}
  2097. };
  2098.  
  2099. /*
  2100. Class for row background drawing events.
  2101. */
  2102.  
  2103. class cbDrawRowBkGroundEvent : public cbPluginEvent
  2104. {
  2105. public:
  2106.     cbRowInfo* mpRow;
  2107.     wxDC*   mpDc;
  2108.  
  2109.         // Constructor, taking row information, device context, and pane.
  2110.  
  2111.     cbDrawRowBkGroundEvent( cbRowInfo* pRow, wxDC& dc, cbDockPane* pPane )
  2112.  
  2113.         : cbPluginEvent( cbEVT_PL_DRAW_ROW_BKGROUND, pPane ),
  2114.           mpRow( pRow ),
  2115.           mpDc( &dc )
  2116.     {}
  2117. };
  2118.  
  2119. /*
  2120. Class for pane background drawing events.
  2121. */
  2122.  
  2123. class cbDrawPaneBkGroundEvent : public cbPluginEvent
  2124. {
  2125. public:
  2126.     wxDC* mpDc;
  2127.  
  2128.         // Constructor, taking device context and pane.
  2129.  
  2130.     cbDrawPaneBkGroundEvent( wxDC& dc, cbDockPane* pPane )
  2131.  
  2132.         : cbPluginEvent( cbEVT_PL_DRAW_PANE_BKGROUND, pPane ),
  2133.           mpDc( &dc )
  2134.     {}
  2135. };
  2136.  
  2137. /*
  2138. Class for start-bar-dragging events.
  2139. */
  2140.  
  2141. class cbStartBarDraggingEvent : public cbPluginEvent
  2142. {
  2143. public:
  2144.     cbBarInfo* mpBar;
  2145.     wxPoint    mPos;  // is given in frame's coordinates
  2146.  
  2147.         // Constructor, taking bar information, mouse position, and pane.
  2148.  
  2149.     cbStartBarDraggingEvent( cbBarInfo* pBar, const wxPoint& pos, cbDockPane* pPane )
  2150.  
  2151.         : cbPluginEvent( cbEVT_PL_START_BAR_DRAGGING, pPane ),
  2152.           mpBar( pBar ),
  2153.           mPos( pos )
  2154.     {}
  2155. };
  2156.  
  2157. /*
  2158. Class for hint-rectangle drawing events.
  2159. */
  2160.  
  2161. class cbDrawHintRectEvent : public cbPluginEvent
  2162. {
  2163. public:
  2164.     wxRect mRect;       // is given in frame's coordinates
  2165.  
  2166.  
  2167.     bool   mLastTime;  // indicates that this event finishes "session" of on-screen drawing,
  2168.                        // thus associated resources can be freed now
  2169.     bool   mEraseRect; // does not have any impact, if recangle is drawn using XOR-mask
  2170.  
  2171.     bool   mIsInClient;// in cleint area hint could be drawn differently,
  2172.                        // e.g. with fat/hatched border
  2173.  
  2174.  
  2175.         // Constructor, taking hint rectangle and three flags.
  2176.  
  2177.     cbDrawHintRectEvent( const wxRect& rect, bool isInClient, bool eraseRect, bool lastTime )
  2178.  
  2179.         : cbPluginEvent( cbEVT_PL_DRAW_HINT_RECT, 0 ),
  2180.           mRect      ( rect       ),
  2181.           mLastTime  ( lastTime   ),
  2182.           mEraseRect ( eraseRect  ),
  2183.           mIsInClient( isInClient )
  2184.     {}
  2185. };
  2186.  
  2187. /*
  2188. Class for start drawing in area events.
  2189. */
  2190.  
  2191. class cbStartDrawInAreaEvent : public cbPluginEvent
  2192. {
  2193. public:
  2194.     wxRect mArea;
  2195.     wxDC** mppDc; // points to pointer, where the reference
  2196.                   // to the obtained buffer-context should be placed
  2197.  
  2198.         // Constructor, taking rectangular area, device context pointer to a pointer, and pane.
  2199.  
  2200.     cbStartDrawInAreaEvent( const wxRect& area, wxDC** ppDCForArea, cbDockPane* pPane )
  2201.  
  2202.         : cbPluginEvent( cbEVT_PL_START_DRAW_IN_AREA, pPane ),
  2203.           mArea( area ),
  2204.           mppDc( ppDCForArea )
  2205.     {}
  2206. };
  2207.  
  2208. /*
  2209. Class for finish drawing in area events.
  2210. */
  2211.  
  2212. class cbFinishDrawInAreaEvent : public cbPluginEvent
  2213. {
  2214. public:
  2215.     wxRect mArea;
  2216.  
  2217.         // Constructor, taking rectangular area and pane.
  2218.  
  2219.     cbFinishDrawInAreaEvent( const wxRect& area, cbDockPane* pPane )
  2220.  
  2221.         : cbPluginEvent( cbEVT_PL_FINISH_DRAW_IN_AREA, pPane ),
  2222.           mArea( area )
  2223.     {}
  2224. };
  2225.  
  2226. /*
  2227. Class for bar customization events.
  2228. */
  2229.  
  2230. class cbCustomizeBarEvent : public cbPluginEvent
  2231. {
  2232. public:
  2233.     wxPoint    mClickPos; // in parent frame's coordinates
  2234.     cbBarInfo* mpBar;
  2235.  
  2236.         // Constructor, taking bar information, mouse position, and pane.
  2237.  
  2238.     cbCustomizeBarEvent( cbBarInfo* pBar, const wxPoint& clickPos, cbDockPane* pPane )
  2239.  
  2240.         : cbPluginEvent( cbEVT_PL_CUSTOMIZE_BAR, pPane ),
  2241.           mClickPos( clickPos ),
  2242.           mpBar( pBar )
  2243.     {}
  2244. };
  2245.  
  2246. /*
  2247. Class for layout customization events.
  2248. */
  2249.  
  2250. class cbCustomizeLayoutEvent : public cbPluginEvent
  2251. {
  2252. public:
  2253.     wxPoint mClickPos; // in parent frame's coordinates
  2254.  
  2255.         // Constructor, taking mouse position.
  2256.  
  2257.     cbCustomizeLayoutEvent( const wxPoint& clickPos )
  2258.  
  2259.         : cbPluginEvent( cbEVT_PL_CUSTOMIZE_LAYOUT, 0 ),
  2260.           mClickPos( clickPos )
  2261.     {}
  2262. };
  2263.  
  2264. #endif /* __CONTROLBAR_G__ */
  2265.  
  2266.