]> git.saurik.com Git - wxWidgets.git/blame_incremental - contrib/include/wx/fl/controlbar.h
corrected assert even better
[wxWidgets.git] / contrib / include / wx / fl / controlbar.h
... / ...
CommitLineData
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$
9// Copyright: (c) Aleksandras Gluchovas
10// Licence: wxWindows licence
11/////////////////////////////////////////////////////////////////////////////
12
13#ifndef __CONTROLBAR_G__
14#define __CONTROLBAR_G__
15
16#ifdef __GNUG__
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
29class wxFrameLayout;
30
31class cbDockPane;
32class cbUpdatesManagerBase;
33class cbBarDimHandlerBase;
34class cbPluginBase;
35class cbPluginEvent;
36class cbPaneDrawPlugin;
37
38class cbBarInfo;
39class cbRowInfo;
40class cbDimInfo;
41class cbCommonPaneProperties;
42
43typedef cbBarInfo* BarInfoPtrT;
44typedef cbRowInfo* RowInfoPtrT;
45
46WX_DEFINE_ARRAY( BarInfoPtrT, BarArrayT );
47WX_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
84enum 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/*
96Helper class, used for spying for unhandled mouse events on control bars
97and forwarding them to the frame layout.
98*/
99
100class cbBarSpy : public wxEvtHandler
101{
102public:
103 DECLARE_DYNAMIC_CLASS( cbBarSpy )
104
105 wxFrameLayout* mpLayout;
106 wxWindow* mpBarWnd;
107
108public:
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/*
127wxFrameLayout manages containment and docking of control bars,
128which can be docked along the top, bottom, right, or left side of the
129parent frame.
130*/
131
132class wxFrameLayout : public wxEvtHandler
133{
134public:
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
465public: /* 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
535public: /* 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/*
645A structure that is present in each item of layout,
646used by any particular updates-manager to store
647auxiliary information to be used by its updating algorithm.
648*/
649
650class cbUpdateMgrData : public wxObject
651{
652 DECLARE_DYNAMIC_CLASS( cbUpdateMgrData )
653public:
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/*
683Abstract interface for bar-size handler classes.
684These objects receive notifications whenever the docking
685state of the bar is changed, thus they provide the possibility
686to adjust the values in cbDimInfo::mSizes accordingly.
687Specific handlers can be hooked up to specific types of bar.
688*/
689
690class cbBarDimHandlerBase : public wxObject
691{
692 DECLARE_ABSTRACT_CLASS( cbBarDimHandlerBase )
693
694public:
695 int mRefCount; // since one dim-handler can be assigned
696 // to multiple bars, it's instance is
697 // reference-counted
698public:
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/*
724Helper class used internally by the wxFrameLayout class.
725Holds and manages information about bar dimensions.
726*/
727
728class cbDimInfo : public wxObject
729{
730 DECLARE_DYNAMIC_CLASS( cbDimInfo )
731public:
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
761public:
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)
827WX_DEFINE_ARRAY_LONG(float, cbArrayFloat);
828
829/*
830Helper class used internally by the wxFrameLayout class.
831Holds and manages information about bar rows.
832*/
833
834class cbRowInfo : public wxObject
835{
836 DECLARE_DYNAMIC_CLASS( cbRowInfo )
837public:
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
865public:
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/*
882Helper class used internally by the wxFrameLayout class.
883Holds and manages bar information.
884*/
885
886class cbBarInfo : public wxObject
887{
888 DECLARE_DYNAMIC_CLASS( cbBarInfo )
889public:
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
929public:
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/*
948Used for storing the original bar's positions in the row, when the 'non-destructive-friction'
949option is turned on.
950*/
951
952class cbBarShapeData : public wxObject
953{
954public:
955 wxRect mBounds;
956 double mLenRatio;
957};
958
959/*
960Used for traversing through all bars of all rows in the pane.
961*/
962
963class wxBarIterator
964{
965 RowArrayT* mpRows;
966 cbRowInfo* mpRow;
967 cbBarInfo* mpBar;
968
969public:
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/*
992A structure holding configuration options,
993which are usually the same for all panes in
994a frame layout.
995*/
996
997class 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
1031/*
1032This class manages containment and control of control bars
1033along one of the four edges of the parent frame.
1034*/
1035
1036class cbDockPane : public wxObject
1037{
1038public:
1039 DECLARE_DYNAMIC_CLASS( cbDockPane )
1040
1041 // look-and-feel configuration for this pane
1042 cbCommonPaneProperties mProps;
1043
1044 // pane margins (in frame's coordinate-syst. orientation)
1045
1046 int mLeftMargin; // default: 2 pixels
1047 int mRightMargin; // default: 2 pixels
1048 int mTopMargin; // default: 2 pixels
1049 int mBottomMargin; // default: 2 pixels
1050
1051public:
1052 // position of the pane in frame's coordinates
1053 wxRect mBoundsInParent;
1054
1055 // pane width and height in pane's coordinates
1056 int mPaneWidth;
1057 int mPaneHeight;
1058
1059 int mAlignment;
1060
1061 // info stored for updates-manager
1062 cbUpdateMgrData mUMgrData;
1063
1064public: /* protected really */
1065
1066 RowArrayT mRows;
1067 wxFrameLayout* mpLayout; // back-ref
1068
1069 // transient properties
1070
1071 wxList mRowShapeData; // shapes of bars of recently modified row,
1072 // stored when in "non-destructive-friction" mode
1073 cbRowInfo* mpStoredRow; // row-info for which the shapes are stored
1074
1075 friend class wxFrameLayout;
1076
1077public: /* protected really (accessed only by plugins) */
1078
1079 // Returns the row info for a row index. Internal function called by plugins.
1080
1081 cbRowInfo* GetRow( int row );
1082
1083 // Returns the row index for the given row info. Internal function called by plugins.
1084
1085 int GetRowIndex( cbRowInfo* pRow );
1086
1087 // Returns the row at the given vertical position.
1088 // Returns -1 if the row is not present at given vertical position.
1089 // Internal function called by plugins.
1090
1091 int GetRowAt( int paneY );
1092
1093 // Returns the row between the given vertical positions.
1094 // Returns -1 if the row is not present.
1095 // Internal function called by plugins.
1096
1097 int GetRowAt( int upperY, int lowerY );
1098
1099 // Sets up flags in the row information structure, so that
1100 // they match the changed state of row items correctly.
1101 // Internal function called by plugins.
1102
1103 void SyncRowFlags( cbRowInfo* pRow );
1104
1105 // Returns TRUE if the bar's dimension information indicates a fixed size.
1106 // Internal function called by plugins.
1107
1108 bool IsFixedSize( cbBarInfo* pInfo );
1109
1110 // Returns the number of bars whose size is not fixed.
1111 // Internal function called by plugins.
1112
1113 int GetNotFixedBarsCount( cbRowInfo* pRow );
1114
1115 // Gets the vertical position at the given row.
1116 // Internal function called by plugins.
1117
1118 int GetRowY( cbRowInfo* pRow );
1119
1120 // Returns TRUE if there are any variable-sized rows above this one.
1121 // Internal function called by plugins.
1122
1123 bool HasNotFixedRowsAbove( cbRowInfo* pRow );
1124
1125 // Returns TRUE if there are any variable-sized rows below this one.
1126 // Internal function called by plugins.
1127
1128 bool HasNotFixedRowsBelow( cbRowInfo* pRow );
1129
1130 // Returns TRUE if there are any variable-sized rows to the left of this one.
1131 // Internal function called by plugins.
1132
1133 bool HasNotFixedBarsLeft ( cbBarInfo* pBar );
1134
1135 // Returns TRUE if there are any variable-sized rows to the right of this one.
1136 // Internal function called by plugins.
1137
1138 bool HasNotFixedBarsRight( cbBarInfo* pBar );
1139
1140 // Calculate lengths.
1141 // Internal function called by plugins.
1142
1143 virtual void CalcLengthRatios( cbRowInfo* pInRow );
1144
1145 // Generates a cbLayoutRowEvent event to recalculate row layouts.
1146 // Internal function called by plugins.
1147
1148 virtual void RecalcRowLayout( cbRowInfo* pRow );
1149
1150 // Expands the bar.
1151 // Internal function called by plugins.
1152
1153 virtual void ExpandBar( cbBarInfo* pBar );
1154
1155 // Contracts the bar.
1156 // Internal function called by plugins.
1157
1158 virtual void ContractBar( cbBarInfo* pBar );
1159
1160 // Sets up links between bars.
1161 // Internal function called by plugins.
1162
1163 void InitLinksForRow( cbRowInfo* pRow );
1164
1165 // Sets up links between bars.
1166 // Internal function called by plugins.
1167
1168 void InitLinksForRows();
1169
1170 // Coordinate translation between parent's frame and this pane.
1171 // Internal function called by plugins.
1172
1173 void FrameToPane( int* x, int* y );
1174
1175 // Coordinate translation between parent's frame and this pane.
1176 // Internal function called by plugins.
1177
1178 void PaneToFrame( int* x, int* y );
1179
1180 // Coordinate translation between parent's frame and this pane.
1181 // Internal function called by plugins.
1182
1183 void FrameToPane( wxRect* pRect );
1184
1185 // Coordinate translation between parent's frame and this pane.
1186 // Internal function called by plugins.
1187
1188 void PaneToFrame( wxRect* pRect );
1189
1190 // Returns TRUE if pos is within the given rectangle.
1191 // Internal function called by plugins.
1192
1193 inline bool HasPoint( const wxPoint& pos, int x, int y, int width, int height );
1194
1195 // Returns the minimal row height for the given row.
1196 // Internal function called by plugins.
1197
1198 int GetMinimalRowHeight( cbRowInfo* pRow );
1199
1200 // Sets the row height for the given height. newHeight includes the height of row handles, if present.
1201 // Internal function called by plugins.
1202
1203 void SetRowHeight( cbRowInfo* pRow, int newHeight );
1204
1205 // Inserts the bar at the given row number.
1206 // Internal function called by plugins.
1207
1208 void DoInsertBar( cbBarInfo* pBar, int rowNo );
1209
1210public: /* protected really (accessed only by plugins) */
1211
1212 // Generates a cbDrawBarDecorEvent and sends it to the layout to paint the bar decorations.
1213 // Internal function called by plugins.
1214
1215 virtual void PaintBarDecorations( cbBarInfo* pBar, wxDC& dc );
1216
1217 // Generates a cbDrawBarHandlesEvent and sends it to the layout to paint the bar handles.
1218 // Internal function called by plugins.
1219
1220 virtual void PaintBarHandles( cbBarInfo* pBar, wxDC& dc );
1221
1222 // Calls PaintBarDecorations and PaintBarHandles.
1223 // Internal function called by plugins.
1224
1225 virtual void PaintBar( cbBarInfo* pBar, wxDC& dc );
1226
1227 // Generates cbDrawRowHandlesEvent and cbDrawRowDecorEvent and sends them to the layout.
1228 // Internal function called by plugins.
1229
1230 virtual void PaintRowHandles( cbRowInfo* pRow, wxDC& dc );
1231
1232 // Generates cbDrawRowBkGroundEvent and sends it to the layout.
1233 // Internal function called by plugins.
1234
1235 virtual void PaintRowBackground ( cbRowInfo* pRow, wxDC& dc );
1236
1237 // Calls PaintBarDecorations for each row.
1238 // Internal function called by plugins.
1239
1240 virtual void PaintRowDecorations( cbRowInfo* pRow, wxDC& dc );
1241
1242 // Calls PaintRowBackground, PaintRowDecorations, PaintRowHandles.
1243 // Internal function called by plugins.
1244
1245 virtual void PaintRow( cbRowInfo* pRow, wxDC& dc );
1246
1247 // Generates cbDrawPaneBkGroundEvent and sends it to the layout.
1248 // Internal function called by plugins.
1249
1250 virtual void PaintPaneBackground( wxDC& dc );
1251
1252 // Generates cbDrawPaneDecorEvent and sends it to the layout.
1253 // Internal function called by plugins.
1254
1255 virtual void PaintPaneDecorations( wxDC& dc );
1256
1257 // Paints the pane background, the row background and decorations,
1258 // and finally the pane decorations.
1259 // Internal function called by plugins.
1260
1261 virtual void PaintPane( wxDC& dc );
1262
1263 // Generates a cbSizeBarWndEvent and sends it to the layout.
1264 // Internal function called by plugins.
1265
1266 virtual void SizeBar( cbBarInfo* pBar );
1267
1268 // Calls SizeBar for each bar in the row.
1269 // Internal function called by plugins.
1270
1271 virtual void SizeRowObjects( cbRowInfo* pRow );
1272
1273 // Calls SizeRowObjects for each row.
1274 // Internal function called by plugins.
1275
1276 virtual void SizePaneObjects();
1277
1278 // Generates cbStartDrawInAreaEvent and sends it to the layout.
1279 // Internal function called by plugins.
1280
1281 virtual wxDC* StartDrawInArea ( const wxRect& area );
1282
1283 // Generates cbFinishDrawInAreaEvent and sends it to the layout.
1284 // Internal function called by plugins.
1285
1286 virtual void FinishDrawInArea( const wxRect& area );
1287
1288public: /* public members */
1289
1290 // Default constructor.
1291
1292 cbDockPane(void);
1293
1294 // Constructor, taking alignment and layout panel.
1295
1296 cbDockPane( int alignment, wxFrameLayout* pPanel );
1297
1298 // Sets pane's margins in frame's coordinate orientations.
1299
1300 void SetMargins( int top, int bottom, int left, int right );
1301
1302 // Destructor.
1303
1304 virtual ~cbDockPane();
1305
1306 // Removes the bar from this pane. Does not destroy the bar.
1307
1308 virtual void RemoveBar( cbBarInfo* pBar );
1309
1310 // Inserts the bar into this pane. rect is given in the parent frame's coordinates.
1311
1312 virtual void InsertBar( cbBarInfo* pBar, const wxRect& rect );
1313
1314 // Inserts the bar into the given row, with dimensions and position
1315 // stored in pBarInfo->mBounds. Returns the node of inserted bar.
1316
1317 virtual void InsertBar( cbBarInfo* pBar, cbRowInfo* pIntoRow );
1318
1319 // Inserts bar and sets its position according to the preferred settings
1320 // given in pBarInfo.
1321
1322 virtual void InsertBar( cbBarInfo* pBarInfo );
1323
1324 // Removes the row from this pane. Does not destroy the row object.
1325
1326 virtual void RemoveRow( cbRowInfo* pRow );
1327
1328 // Inserts a row. Does not refresh the inserted row immediately.
1329 // If pBeforeRowNode is NULL, the row is appended to the end of pane's row list.
1330
1331 virtual void InsertRow( cbRowInfo* pRow, cbRowInfo* pBeforeRow );
1332
1333 // Sets pane's width in the pane's coordinates (including margins).
1334
1335 void SetPaneWidth(int width);
1336
1337 // Set the position and dimensions of the pane in the parent frame's coordinates.
1338
1339 void SetBoundsInParent( const wxRect& rect );
1340
1341 // Returns the bounds of the pane, in parent coordinates.
1342
1343 inline wxRect& GetRealRect() { return mBoundsInParent; }
1344
1345 // Returns an array of rows. Used by updates-managers.
1346
1347 inline RowArrayT& GetRowList() { return mRows; }
1348
1349 // Returns the first row.
1350
1351 inline cbRowInfo* GetFirstRow()
1352
1353 { return mRows.GetCount() ? mRows[0] : NULL; }
1354
1355 // Returns TRUE if the given bar is present in this pane.
1356
1357 bool BarPresent( cbBarInfo* pBar );
1358
1359 // Returns the height in the pane's coordinates.
1360
1361 int GetPaneHeight();
1362
1363 // Returns the alignment for this pane. The value is one of
1364 // FL_ALIGN_TOP, FL_ALIGN_BOTTOM, FL_ALIGN_LEFT, FL_ALIGN_RIGHT.
1365
1366 int GetAlignment();
1367
1368 // Returns TRUE if the given mask matches the pane's mask.
1369
1370 bool MatchesMask( int paneMask );
1371
1372 // Returns TRUE if the pane is aligned to the top or bottom.
1373
1374 inline bool IsHorizontal()
1375 {
1376 return (mAlignment == FL_ALIGN_TOP ||
1377 mAlignment == FL_ALIGN_BOTTOM );
1378 }
1379
1380 // Generates events to perform layout calculations.
1381
1382 virtual void RecalcLayout();
1383
1384 // Returns wxCBAR_DOCKED_HORIZONTALLY if the alignment is top or bottom,
1385 // or wxCBAR_DOCKED_VERTICALLY otherwise.
1386
1387 virtual int GetDockingState();
1388
1389 // Returns the result of hit-testing items in the pane.
1390 // See CB_HITTEST_RESULT enumerated type.
1391 // pos is the position in this pane's coordinates.
1392
1393 virtual int HitTestPaneItems( const wxPoint& pos,
1394 cbRowInfo** ppRow,
1395 cbBarInfo** ppBar
1396 );
1397
1398 // Returns the bar's resize range.
1399
1400 void GetBarResizeRange( cbBarInfo* pBar, int* from, int *till, bool forLeftHandle );
1401
1402 // Returns the row's resize range.
1403
1404 void GetRowResizeRange( cbRowInfo* pRow, int* from, int* till, bool forUpperHandle );
1405
1406 // Finds the bar information by corresponding window.
1407
1408 cbBarInfo* GetBarInfoByWindow( wxWindow* pBarWnd );
1409
1410public: /* protected really (accessed only by plugins) */
1411
1412 // Row/bar resizing related helper-method.
1413
1414 void DrawVertHandle ( wxDC& dc, int x, int y, int height );
1415
1416 // Row/bar resizing related helper-method.
1417
1418 void DrawHorizHandle( wxDC& dc, int x, int y, int width );
1419
1420 // Row/bar resizing related helper-method.
1421
1422 void ResizeRow( cbRowInfo* pRow, int ofs, bool forUpperHandle );
1423
1424 // Row/bar resizing related helper-method.
1425
1426 void ResizeBar( cbBarInfo* pBar, int ofs, bool forLeftHandle );
1427
1428 // Returns row shape data.
1429 // cbBarShapeData objects will be added to the given pLst.
1430 // cbBarShapeData is used for storing the original bar's positions in the row,
1431 // when the 'non-destructive-friction' option is turned on.
1432
1433 void GetRowShapeData( cbRowInfo* pRow, wxList* pLst );
1434
1435 // Sets the shape data for the given row, using the data provided in pLst.
1436 // cbBarShapeData is used for storing the original bar's positions in the row,
1437 // when the 'non-destructive-friction' option is turned on.
1438
1439 void SetRowShapeData( cbRowInfo* pRowNode, wxList* pLst );
1440};
1441
1442/*
1443This class declares an abstract interface for optimized logic that should refresh
1444areas of frame layout that actually need to be updated. This should be extended in future
1445to implement a custom updating strategy.
1446*/
1447
1448class cbUpdatesManagerBase : public wxObject
1449{
1450 DECLARE_ABSTRACT_CLASS( cbUpdatesManagerBase )
1451
1452public: /* protected really, accessed by serializer (if any) */
1453
1454 wxFrameLayout* mpLayout;
1455
1456public:
1457 // Default constructor
1458
1459 cbUpdatesManagerBase(void)
1460 : mpLayout( 0 ) {}
1461
1462 // Constructor taking layout panel.
1463
1464 cbUpdatesManagerBase( wxFrameLayout* pPanel )
1465 : mpLayout( pPanel ) {}
1466
1467 // Destructor.
1468
1469 virtual ~cbUpdatesManagerBase() {}
1470
1471 // Sets the associated layout.
1472
1473 void SetLayout( wxFrameLayout* pLayout ) { mpLayout = pLayout; }
1474
1475 // This function receives a notification from the frame layout (in the order in which
1476 // they would usually be invoked). Custom updates-managers may utilize
1477 // these notifications to implement a more fine-grained updating strategy.
1478
1479 virtual void OnStartChanges() = 0;
1480
1481 // This function receives a notification from the frame layout (in the order in which
1482 // they would usually be invoked). Custom updates-managers may utilize
1483 // these notifications to implement a more fine-grained updating strategy.
1484
1485 virtual void OnRowWillChange( cbRowInfo* pRow, cbDockPane* pInPane ) {}
1486
1487 // This function receives a notification from the frame layout (in the order in which
1488 // they would usually be invoked). Custom updates-managers may utilize
1489 // these notifications to implement a more fine-grained updating strategy.
1490
1491 virtual void OnBarWillChange( cbBarInfo* pBar, cbRowInfo* pInRow, cbDockPane* pInPane ) {}
1492
1493 // This function receives a notification from the frame layout (in the order in which
1494 // they would usually be invoked). Custom updates-managers may utilize
1495 // these notifications to implement a more fine-grained updating strategy.
1496
1497 virtual void OnPaneMarginsWillChange( cbDockPane* pPane ) {}
1498
1499 // This function receives a notification from the frame layout (in the order in which
1500 // they would usually be invoked). Custom updates-managers may utilize
1501 // these notifications to implement a more fine-grained updating strategy.
1502
1503 virtual void OnPaneWillChange( cbDockPane* pPane ) {}
1504
1505 // This function receives a notification from the frame layout (in the order in which
1506 // they would usually be invoked). Custom updates-managers may utilize
1507 // these notifications to implement a more fine-grained updating strategy.
1508
1509 virtual void OnFinishChanges() {}
1510
1511 // Refreshes parts of the frame layout that need an update.
1512
1513 virtual void UpdateNow() = 0;
1514};
1515
1516/*
1517Base class for all control-bar plugin events.
1518This is not a dynamically-creatable class.
1519*/
1520
1521class cbPluginEvent : public wxEvent
1522{
1523public:
1524 // NULL if event is not addressed to any specific pane.
1525
1526 cbDockPane* mpPane;
1527
1528 // Not used, but required.
1529
1530 virtual wxEvent* Clone() const { return NULL; }
1531
1532 // Constructor, taking event type and pane.
1533
1534 cbPluginEvent( wxEventType eventType, cbDockPane* pPane )
1535 : mpPane( pPane )
1536
1537 { m_eventType = eventType; }
1538};
1539
1540// event types handled by plugins
1541
1542extern wxEventType cbEVT_PL_LEFT_DOWN;
1543extern wxEventType cbEVT_PL_LEFT_UP;
1544extern wxEventType cbEVT_PL_RIGHT_DOWN;
1545extern wxEventType cbEVT_PL_RIGHT_UP;
1546extern wxEventType cbEVT_PL_MOTION;
1547
1548extern wxEventType cbEVT_PL_LEFT_DCLICK;
1549
1550extern wxEventType cbEVT_PL_LAYOUT_ROW;
1551extern wxEventType cbEVT_PL_RESIZE_ROW;
1552extern wxEventType cbEVT_PL_LAYOUT_ROWS;
1553extern wxEventType cbEVT_PL_INSERT_BAR;
1554extern wxEventType cbEVT_PL_RESIZE_BAR;
1555extern wxEventType cbEVT_PL_REMOVE_BAR;
1556extern wxEventType cbEVT_PL_SIZE_BAR_WND;
1557
1558extern wxEventType cbEVT_PL_DRAW_BAR_DECOR;
1559extern wxEventType cbEVT_PL_DRAW_ROW_DECOR;
1560extern wxEventType cbEVT_PL_DRAW_PANE_DECOR;
1561extern wxEventType cbEVT_PL_DRAW_BAR_HANDLES;
1562extern wxEventType cbEVT_PL_DRAW_ROW_HANDLES;
1563extern wxEventType cbEVT_PL_DRAW_ROW_BKGROUND;
1564extern wxEventType cbEVT_PL_DRAW_PANE_BKGROUND;
1565
1566extern wxEventType cbEVT_PL_START_BAR_DRAGGING;
1567extern wxEventType cbEVT_PL_DRAW_HINT_RECT;
1568
1569extern wxEventType cbEVT_PL_START_DRAW_IN_AREA;
1570extern wxEventType cbEVT_PL_FINISH_DRAW_IN_AREA;
1571
1572extern wxEventType cbEVT_PL_CUSTOMIZE_BAR;
1573extern wxEventType cbEVT_PL_CUSTOMIZE_LAYOUT;
1574
1575extern wxEventType wxCUSTOM_CB_PLUGIN_EVENTS_START_AT;
1576
1577// Forward declarations, separated by categories.
1578
1579class cbLeftDownEvent;
1580class cbLeftUpEvent;
1581class cbRightDownEvent;
1582class cbRightUpEvent;
1583class cbMotionEvent;
1584class cbLeftDClickEvent;
1585
1586class cbLayoutRowEvent;
1587class cbResizeRowEvent;
1588class cbLayoutRowsEvent;
1589class cbInsertBarEvent;
1590class cbResizeBarEvent;
1591class cbRemoveBarEvent;
1592class cbSizeBarWndEvent;
1593
1594class cbDrawBarDecorEvent;
1595class cbDrawRowDecorEvent;
1596class cbDrawPaneDecorEvent;
1597class cbDrawBarHandlesEvent;
1598class cbDrawRowHandlesEvent;
1599class cbDrawRowBkGroundEvent;
1600class cbDrawPaneBkGroundEvent;
1601
1602class cbStartBarDraggingEvent;
1603class cbDrawHintRectEvent;
1604
1605class cbStartDrawInAreaEvent;
1606class cbFinishDrawInAreaEvent;
1607
1608class cbCustomizeBarEvent;
1609class cbCustomizeLayoutEvent;
1610
1611// Definitions for for handler-methods.
1612
1613typedef void (wxEvtHandler::*cbLeftDownHandler )(cbLeftDownEvent&);
1614typedef void (wxEvtHandler::*cbLeftUpHandler )(cbLeftUpEvent&);
1615typedef void (wxEvtHandler::*cbRightDownHandler )(cbRightDownEvent&);
1616typedef void (wxEvtHandler::*cbRightUpHandler )(cbRightUpEvent&);
1617typedef void (wxEvtHandler::*cbMotionHandler )(cbMotionEvent&);
1618typedef void (wxEvtHandler::*cbLeftDClickHandler )(cbLeftDClickEvent&);
1619
1620typedef void (wxEvtHandler::*cbLayoutRowHandler )(cbLayoutRowEvent&);
1621typedef void (wxEvtHandler::*cbResizeRowHandler )(cbResizeRowEvent&);
1622typedef void (wxEvtHandler::*cbLayoutRowsHandler )(cbLayoutRowsEvent&);
1623typedef void (wxEvtHandler::*cbInsertBarHandler )(cbInsertBarEvent&);
1624typedef void (wxEvtHandler::*cbResizeBarHandler )(cbResizeBarEvent&);
1625typedef void (wxEvtHandler::*cbRemoveBarHandler )(cbRemoveBarEvent&);
1626typedef void (wxEvtHandler::*cbSizeBarWndHandler )(cbSizeBarWndEvent&);
1627
1628typedef void (wxEvtHandler::*cbDrawBarDecorHandler )(cbDrawBarDecorEvent&);
1629typedef void (wxEvtHandler::*cbDrawRowDecorHandler )(cbDrawRowDecorEvent&);
1630typedef void (wxEvtHandler::*cbDrawPaneDecorHandler )(cbDrawPaneDecorEvent&);
1631typedef void (wxEvtHandler::*cbDrawBarHandlesHandler )(cbDrawBarHandlesEvent&);
1632typedef void (wxEvtHandler::*cbDrawRowHandlesHandler )(cbDrawRowHandlesEvent&);
1633typedef void (wxEvtHandler::*cbDrawRowBkGroundHandler )(cbDrawRowBkGroundEvent&);
1634typedef void (wxEvtHandler::*cbDrawPaneBkGroundHandler)(cbDrawPaneBkGroundEvent&);
1635
1636typedef void (wxEvtHandler::*cbStartBarDraggingHandler )(cbStartBarDraggingEvent&);
1637typedef void (wxEvtHandler::*cbDrawHintRectHandler )(cbDrawHintRectEvent&);
1638
1639typedef void (wxEvtHandler::*cbStartDrawInAreaHandler )(cbStartDrawInAreaEvent&);
1640typedef void (wxEvtHandler::*cbFinishDrawInAreaHandler)(cbFinishDrawInAreaEvent&);
1641
1642typedef void (wxEvtHandler::*cbCustomizeBarHandler )(cbCustomizeBarEvent&);
1643typedef void (wxEvtHandler::*cbCustomizeLayoutHandler )(cbCustomizeLayoutEvent&);
1644
1645// Macros for creating event table entries for plugin-events.
1646
1647#define EVT_PL_LEFT_DOWN(func) wxEventTableEntry( cbEVT_PL_LEFT_DOWN, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLeftDownHandler ) & func, (wxObject *) NULL ),
1648#define EVT_PL_LEFT_UP(func) wxEventTableEntry( cbEVT_PL_LEFT_UP, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLeftUpHandler ) & func, (wxObject *) NULL ),
1649#define EVT_PL_RIGHT_DOWN(func) wxEventTableEntry( cbEVT_PL_RIGHT_DOWN, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbRightDownHandler ) & func, (wxObject *) NULL ),
1650#define EVT_PL_RIGHT_UP(func) wxEventTableEntry( cbEVT_PL_RIGHT_UP, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbRightUpHandler ) & func, (wxObject *) NULL ),
1651#define EVT_PL_MOTION(func) wxEventTableEntry( cbEVT_PL_MOTION, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbMotionHandler ) & func, (wxObject *) NULL ),
1652#define EVT_PL_LEFT_DCLICK(func) wxEventTableEntry( cbEVT_PL_LEFT_DCLICK, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLeftDClickHandler ) & func, (wxObject *) NULL ),
1653
1654#define EVT_PL_LAYOUT_ROW(func) wxEventTableEntry( cbEVT_PL_LAYOUT_ROW, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLayoutRowHandler ) & func, (wxObject *) NULL ),
1655#define EVT_PL_RESIZE_ROW(func) wxEventTableEntry( cbEVT_PL_RESIZE_ROW, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbResizeRowHandler ) & func, (wxObject *) NULL ),
1656#define EVT_PL_LAYOUT_ROWS(func) wxEventTableEntry( cbEVT_PL_LAYOUT_ROWS, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbLayoutRowsHandler ) & func, (wxObject *) NULL ),
1657#define EVT_PL_INSERT_BAR(func) wxEventTableEntry( cbEVT_PL_INSERT_BAR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbInsertBarHandler ) & func, (wxObject *) NULL ),
1658#define EVT_PL_RESIZE_BAR(func) wxEventTableEntry( cbEVT_PL_RESIZE_BAR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbResizeBarHandler ) & func, (wxObject *) NULL ),
1659#define EVT_PL_REMOVE_BAR(func) wxEventTableEntry( cbEVT_PL_REMOVE_BAR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbRemoveBarHandler ) & func, (wxObject *) NULL ),
1660#define EVT_PL_SIZE_BAR_WND(func) wxEventTableEntry( cbEVT_PL_SIZE_BAR_WND, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbSizeBarWndHandler ) & func, (wxObject *) NULL ),
1661
1662#define EVT_PL_DRAW_BAR_DECOR(func) wxEventTableEntry( cbEVT_PL_DRAW_BAR_DECOR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawBarDecorHandler ) & func, (wxObject *) NULL ),
1663#define EVT_PL_DRAW_ROW_DECOR(func) wxEventTableEntry( cbEVT_PL_DRAW_ROW_DECOR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawRowDecorHandler ) & func, (wxObject *) NULL ),
1664#define EVT_PL_DRAW_PANE_DECOR(func) wxEventTableEntry( cbEVT_PL_DRAW_PANE_DECOR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawPaneDecorHandler ) & func, (wxObject *) NULL ),
1665#define EVT_PL_DRAW_BAR_HANDLES(func) wxEventTableEntry( cbEVT_PL_DRAW_BAR_HANDLES, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawBarHandlesHandler ) & func, (wxObject *) NULL ),
1666#define EVT_PL_DRAW_ROW_HANDLES(func) wxEventTableEntry( cbEVT_PL_DRAW_ROW_HANDLES, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawRowHandlesHandler ) & func, (wxObject *) NULL ),
1667#define EVT_PL_DRAW_ROW_BKGROUND(func) wxEventTableEntry( cbEVT_PL_DRAW_ROW_BKGROUND, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawRowBkGroundHandler ) & func, (wxObject *) NULL ),
1668#define EVT_PL_DRAW_PANE_BKGROUND(func) wxEventTableEntry( cbEVT_PL_DRAW_PANE_BKGROUND, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawPaneBkGroundHandler) & func, (wxObject *) NULL ),
1669
1670#define EVT_PL_START_BAR_DRAGGING(func) wxEventTableEntry( cbEVT_PL_START_BAR_DRAGGING, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbStartBarDraggingHandler) & func, (wxObject *) NULL ),
1671#define EVT_PL_DRAW_HINT_RECT(func) wxEventTableEntry( cbEVT_PL_DRAW_HINT_RECT, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbDrawHintRectHandler ) & func, (wxObject *) NULL ),
1672
1673
1674#define EVT_PL_START_DRAW_IN_AREA(func) wxEventTableEntry( cbEVT_PL_START_DRAW_IN_AREA, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbStartDrawInAreaHandler) & func, (wxObject *) NULL ),
1675#define EVT_PL_FINISH_DRAW_IN_AREA(func) wxEventTableEntry( cbEVT_PL_FINISH_DRAW_IN_AREA, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbFinishDrawInAreaHandler) & func, (wxObject *) NULL ),
1676
1677#define EVT_PL_CUSTOMIZE_BAR(func) wxEventTableEntry( cbEVT_PL_CUSTOMIZE_BAR, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbCustomizeBarHandler) & func, (wxObject *) NULL ),
1678#define EVT_PL_CUSTOMIZE_LAYOUT(func) wxEventTableEntry( cbEVT_PL_CUSTOMIZE_LAYOUT, -1, -1, (wxObjectEventFunction) (wxEventFunction) (cbCustomizeLayoutHandler) & func, (wxObject *) NULL ),
1679
1680/*
1681Abstract base class for all control-bar related plugins.
1682Note: pointer positions of mouse events sent to plugins
1683are always in the pane's coordinates (the pane to which
1684this plugin is hooked).
1685*/
1686
1687class cbPluginBase : public wxEvtHandler
1688{
1689 DECLARE_ABSTRACT_CLASS( cbPluginBase )
1690public:
1691 // Back-reference to the frame layout.
1692
1693 wxFrameLayout* mpLayout;
1694
1695 // Specifies panes for which this plugin receives events
1696 // (see pane masks definitions).
1697
1698 int mPaneMask;
1699
1700 // Is TRUE when plugin is ready to handle events.
1701
1702 bool mIsReady;
1703
1704public:
1705 // Default constructor.
1706
1707 cbPluginBase()
1708
1709 : mpLayout ( 0 ),
1710 mPaneMask( wxALL_PANES ),
1711 mIsReady ( FALSE )
1712 {}
1713
1714 // Constructor taking layout panel and a mask.
1715
1716 cbPluginBase( wxFrameLayout* pPanel, int paneMask = wxALL_PANES )
1717
1718 : mpLayout ( pPanel ),
1719 mPaneMask( paneMask ),
1720 mIsReady ( FALSE )
1721 {}
1722
1723 // Returns the pane mask.
1724
1725 inline int GetPaneMask() { return mPaneMask; }
1726
1727 // Destructor. Destroys the whole plugin chain of connected plugins.
1728
1729 virtual ~cbPluginBase();
1730
1731 // Override this method to do plugin-specific initialization.
1732 // At this point plugin is already attached to the frame layout,
1733 // and pane masks are set.
1734
1735 virtual void OnInitPlugin() { mIsReady = TRUE; }
1736
1737 // Returns TRUE if the plugin is ready to receive events.
1738
1739 bool IsReady() { return mIsReady; }
1740
1741 // Overridden to determine whether the target pane specified in the
1742 // event matches the pane mask of this plugin (specific plugins
1743 // do not override this method).
1744
1745 virtual bool ProcessEvent(wxEvent& event);
1746};
1747
1748/*
1749Class for mouse left down events.
1750*/
1751
1752class cbLeftDownEvent : public cbPluginEvent
1753{
1754public:
1755 wxPoint mPos;
1756
1757 // Constructor, taking mouse position and pane.
1758
1759 cbLeftDownEvent( const wxPoint& pos, cbDockPane* pPane )
1760
1761 : cbPluginEvent( cbEVT_PL_LEFT_DOWN, pPane ),
1762 mPos( pos )
1763 {}
1764};
1765
1766/*
1767Class for mouse left up events.
1768*/
1769
1770class cbLeftUpEvent : public cbPluginEvent
1771{
1772public:
1773 wxPoint mPos;
1774
1775 // Constructor, taking mouse position and pane.
1776
1777 cbLeftUpEvent( const wxPoint& pos, cbDockPane* pPane )
1778
1779 : cbPluginEvent( cbEVT_PL_LEFT_UP, pPane ),
1780 mPos( pos )
1781 {}
1782};
1783
1784/*
1785Class for mouse right down events.
1786*/
1787
1788class cbRightDownEvent : public cbPluginEvent
1789{
1790public:
1791 wxPoint mPos;
1792
1793 // Constructor, taking mouse position and pane.
1794
1795 cbRightDownEvent( const wxPoint& pos, cbDockPane* pPane )
1796
1797 : cbPluginEvent( cbEVT_PL_RIGHT_DOWN, pPane ),
1798 mPos( pos )
1799 {}
1800};
1801
1802/*
1803Class for mouse right up events.
1804*/
1805
1806class cbRightUpEvent : public cbPluginEvent
1807{
1808public:
1809 wxPoint mPos;
1810
1811 // Constructor, taking mouse position and pane.
1812
1813 cbRightUpEvent( const wxPoint& pos, cbDockPane* pPane )
1814
1815 : cbPluginEvent( cbEVT_PL_RIGHT_UP, pPane ),
1816 mPos( pos )
1817 {}
1818};
1819
1820/*
1821Class for mouse motion events.
1822*/
1823
1824class cbMotionEvent : public cbPluginEvent
1825{
1826public:
1827 wxPoint mPos;
1828
1829 // Constructor, taking mouse position and pane.
1830
1831 cbMotionEvent( const wxPoint& pos, cbDockPane* pPane )
1832
1833 : cbPluginEvent( cbEVT_PL_MOTION, pPane ),
1834 mPos( pos )
1835 {}
1836};
1837
1838/*
1839Class for mouse left double click events.
1840*/
1841
1842class cbLeftDClickEvent : public cbPluginEvent
1843{
1844public:
1845 wxPoint mPos;
1846
1847 // Constructor, taking mouse position and pane.
1848
1849 cbLeftDClickEvent( const wxPoint& pos, cbDockPane* pPane )
1850
1851 : cbPluginEvent( cbEVT_PL_LEFT_DCLICK, pPane ),
1852 mPos( pos )
1853 {}
1854};
1855
1856/*
1857Class for single row layout events.
1858*/
1859
1860class cbLayoutRowEvent : public cbPluginEvent
1861{
1862public:
1863 cbRowInfo* mpRow;
1864
1865 // Constructor, taking row information and pane.
1866
1867 cbLayoutRowEvent( cbRowInfo* pRow, cbDockPane* pPane )
1868
1869 : cbPluginEvent( cbEVT_PL_LAYOUT_ROW, pPane ),
1870 mpRow( pRow )
1871 {}
1872};
1873
1874/*
1875Class for row resize events.
1876*/
1877
1878class cbResizeRowEvent : public cbPluginEvent
1879{
1880public:
1881 cbRowInfo* mpRow;
1882 int mHandleOfs;
1883 bool mForUpperHandle;
1884
1885 // Constructor, taking row information, two parameters of currently unknown use, and pane.
1886
1887 cbResizeRowEvent( cbRowInfo* pRow, int handleOfs, bool forUpperHandle, cbDockPane* pPane )
1888
1889 : cbPluginEvent( cbEVT_PL_RESIZE_ROW, pPane ),
1890 mpRow( pRow ),
1891 mHandleOfs( handleOfs ),
1892 mForUpperHandle( forUpperHandle )
1893 {}
1894};
1895
1896/*
1897Class for multiple rows layout events.
1898*/
1899
1900class cbLayoutRowsEvent : public cbPluginEvent
1901{
1902public:
1903
1904 // Constructor, taking pane.
1905
1906 cbLayoutRowsEvent( cbDockPane* pPane )
1907
1908 : cbPluginEvent( cbEVT_PL_LAYOUT_ROWS, pPane )
1909 {}
1910};
1911
1912/*
1913Class for bar insertion events.
1914*/
1915
1916class cbInsertBarEvent : public cbPluginEvent
1917{
1918public:
1919 cbBarInfo* mpBar;
1920 cbRowInfo* mpRow;
1921
1922 // Constructor, taking bar information, row information, and pane.
1923
1924 cbInsertBarEvent( cbBarInfo* pBar, cbRowInfo* pIntoRow, cbDockPane* pPane )
1925
1926 : cbPluginEvent( cbEVT_PL_INSERT_BAR, pPane ),
1927
1928 mpBar( pBar ),
1929 mpRow( pIntoRow )
1930 {}
1931};
1932
1933/*
1934Class for bar resize events.
1935*/
1936
1937class cbResizeBarEvent : public cbPluginEvent
1938{
1939public:
1940 cbBarInfo* mpBar;
1941 cbRowInfo* mpRow;
1942
1943 // Constructor, taking bar information, row information, and pane.
1944
1945 cbResizeBarEvent( cbBarInfo* pBar, cbRowInfo* pRow, cbDockPane* pPane )
1946
1947 : cbPluginEvent( cbEVT_PL_RESIZE_BAR, pPane ),
1948 mpBar( pBar ),
1949 mpRow( pRow )
1950 {}
1951};
1952
1953/*
1954Class for bar removal events.
1955*/
1956
1957class cbRemoveBarEvent : public cbPluginEvent
1958{
1959public:
1960 cbBarInfo* mpBar;
1961
1962 // Constructor, taking bar information and pane.
1963
1964 cbRemoveBarEvent( cbBarInfo* pBar, cbDockPane* pPane )
1965
1966 : cbPluginEvent( cbEVT_PL_REMOVE_BAR, pPane ),
1967 mpBar( pBar )
1968 {}
1969};
1970
1971/*
1972Class for bar window resize events.
1973*/
1974
1975class cbSizeBarWndEvent : public cbPluginEvent
1976{
1977public:
1978 cbBarInfo* mpBar;
1979 wxRect mBoundsInParent;
1980
1981 // Constructor, taking bar information and pane.
1982
1983 cbSizeBarWndEvent( cbBarInfo* pBar, cbDockPane* pPane )
1984
1985 : cbPluginEvent( cbEVT_PL_SIZE_BAR_WND, pPane ),
1986 mpBar( pBar ),
1987 mBoundsInParent( pBar->mBoundsInParent )
1988 {}
1989};
1990
1991/*
1992Class for bar decoration drawing events.
1993*/
1994
1995class cbDrawBarDecorEvent : public cbPluginEvent
1996{
1997public:
1998 cbBarInfo* mpBar;
1999 wxDC* mpDc;
2000 wxRect mBoundsInParent;
2001
2002 // Constructor, taking bar information, device context, and pane.
2003
2004 cbDrawBarDecorEvent( cbBarInfo* pBar, wxDC& dc, cbDockPane* pPane )
2005
2006 : cbPluginEvent( cbEVT_PL_DRAW_BAR_DECOR, pPane ),
2007 mpBar( pBar ),
2008 mpDc( &dc ),
2009 mBoundsInParent( pBar->mBoundsInParent )
2010 {}
2011};
2012
2013/*
2014Class for row decoration drawing events.
2015*/
2016
2017class cbDrawRowDecorEvent : public cbPluginEvent
2018{
2019public:
2020 cbRowInfo* mpRow;
2021 wxDC* mpDc;
2022
2023 // Constructor, taking row information, device context, and pane.
2024
2025 cbDrawRowDecorEvent( cbRowInfo* pRow, wxDC& dc, cbDockPane* pPane )
2026
2027 : cbPluginEvent( cbEVT_PL_DRAW_ROW_DECOR, pPane ),
2028 mpRow( pRow ),
2029 mpDc( &dc )
2030 {}
2031};
2032
2033/*
2034Class for pane decoration drawing events.
2035*/
2036
2037class cbDrawPaneDecorEvent : public cbPluginEvent
2038{
2039public:
2040 wxDC* mpDc;
2041
2042 // Constructor, taking device context and pane.
2043
2044 cbDrawPaneDecorEvent( wxDC& dc, cbDockPane* pPane )
2045
2046 : cbPluginEvent( cbEVT_PL_DRAW_PANE_DECOR, pPane ),
2047 mpDc( &dc )
2048 {}
2049};
2050
2051/*
2052Class for bar handles drawing events.
2053*/
2054
2055class cbDrawBarHandlesEvent : public cbPluginEvent
2056{
2057public:
2058 cbBarInfo* mpBar;
2059 wxDC* mpDc;
2060
2061 // Constructor, taking bar information, device context, and pane.
2062
2063 cbDrawBarHandlesEvent( cbBarInfo* pBar, wxDC& dc, cbDockPane* pPane )
2064
2065 : cbPluginEvent( cbEVT_PL_DRAW_BAR_HANDLES, pPane ),
2066 mpBar( pBar ),
2067 mpDc( &dc )
2068 {}
2069};
2070
2071/*
2072Class for row handles drawing events.
2073*/
2074
2075class cbDrawRowHandlesEvent : public cbPluginEvent
2076{
2077public:
2078 cbRowInfo* mpRow;
2079 wxDC* mpDc;
2080
2081 // Constructor, taking row information, device context, and pane.
2082
2083 cbDrawRowHandlesEvent( cbRowInfo* pRow, wxDC& dc, cbDockPane* pPane )
2084
2085 : cbPluginEvent( cbEVT_PL_DRAW_ROW_HANDLES, pPane ),
2086 mpRow( pRow ),
2087 mpDc( &dc )
2088 {}
2089};
2090
2091/*
2092Class for row background drawing events.
2093*/
2094
2095class cbDrawRowBkGroundEvent : public cbPluginEvent
2096{
2097public:
2098 cbRowInfo* mpRow;
2099 wxDC* mpDc;
2100
2101 // Constructor, taking row information, device context, and pane.
2102
2103 cbDrawRowBkGroundEvent( cbRowInfo* pRow, wxDC& dc, cbDockPane* pPane )
2104
2105 : cbPluginEvent( cbEVT_PL_DRAW_ROW_BKGROUND, pPane ),
2106 mpRow( pRow ),
2107 mpDc( &dc )
2108 {}
2109};
2110
2111/*
2112Class for pane background drawing events.
2113*/
2114
2115class cbDrawPaneBkGroundEvent : public cbPluginEvent
2116{
2117public:
2118 wxDC* mpDc;
2119
2120 // Constructor, taking device context and pane.
2121
2122 cbDrawPaneBkGroundEvent( wxDC& dc, cbDockPane* pPane )
2123
2124 : cbPluginEvent( cbEVT_PL_DRAW_PANE_BKGROUND, pPane ),
2125 mpDc( &dc )
2126 {}
2127};
2128
2129/*
2130Class for start-bar-dragging events.
2131*/
2132
2133class cbStartBarDraggingEvent : public cbPluginEvent
2134{
2135public:
2136 cbBarInfo* mpBar;
2137 wxPoint mPos; // is given in frame's coordinates
2138
2139 // Constructor, taking bar information, mouse position, and pane.
2140
2141 cbStartBarDraggingEvent( cbBarInfo* pBar, const wxPoint& pos, cbDockPane* pPane )
2142
2143 : cbPluginEvent( cbEVT_PL_START_BAR_DRAGGING, pPane ),
2144 mpBar( pBar ),
2145 mPos( pos )
2146 {}
2147};
2148
2149/*
2150Class for hint-rectangle drawing events.
2151*/
2152
2153class cbDrawHintRectEvent : public cbPluginEvent
2154{
2155public:
2156 wxRect mRect; // is given in frame's coordinates
2157
2158
2159 bool mLastTime; // indicates that this event finishes "session" of on-screen drawing,
2160 // thus associated resources can be freed now
2161 bool mEraseRect; // does not have any impact, if recangle is drawn using XOR-mask
2162
2163 bool mIsInClient;// in cleint area hint could be drawn differently,
2164 // e.g. with fat/hatched border
2165
2166
2167 // Constructor, taking hint rectangle and three flags.
2168
2169 cbDrawHintRectEvent( const wxRect& rect, bool isInClient, bool eraseRect, bool lastTime )
2170
2171 : cbPluginEvent( cbEVT_PL_DRAW_HINT_RECT, 0 ),
2172 mRect ( rect ),
2173 mLastTime ( lastTime ),
2174 mEraseRect ( eraseRect ),
2175 mIsInClient( isInClient )
2176 {}
2177};
2178
2179/*
2180Class for start drawing in area events.
2181*/
2182
2183class cbStartDrawInAreaEvent : public cbPluginEvent
2184{
2185public:
2186 wxRect mArea;
2187 wxDC** mppDc; // points to pointer, where the reference
2188 // to the obtained buffer-context should be placed
2189
2190 // Constructor, taking rectangular area, device context pointer to a pointer, and pane.
2191
2192 cbStartDrawInAreaEvent( const wxRect& area, wxDC** ppDCForArea, cbDockPane* pPane )
2193
2194 : cbPluginEvent( cbEVT_PL_START_DRAW_IN_AREA, pPane ),
2195 mArea( area ),
2196 mppDc( ppDCForArea )
2197 {}
2198};
2199
2200/*
2201Class for finish drawing in area events.
2202*/
2203
2204class cbFinishDrawInAreaEvent : public cbPluginEvent
2205{
2206public:
2207 wxRect mArea;
2208
2209 // Constructor, taking rectangular area and pane.
2210
2211 cbFinishDrawInAreaEvent( const wxRect& area, cbDockPane* pPane )
2212
2213 : cbPluginEvent( cbEVT_PL_FINISH_DRAW_IN_AREA, pPane ),
2214 mArea( area )
2215 {}
2216};
2217
2218/*
2219Class for bar customization events.
2220*/
2221
2222class cbCustomizeBarEvent : public cbPluginEvent
2223{
2224public:
2225 wxPoint mClickPos; // in parent frame's coordinates
2226 cbBarInfo* mpBar;
2227
2228 // Constructor, taking bar information, mouse position, and pane.
2229
2230 cbCustomizeBarEvent( cbBarInfo* pBar, const wxPoint& clickPos, cbDockPane* pPane )
2231
2232 : cbPluginEvent( cbEVT_PL_CUSTOMIZE_BAR, pPane ),
2233 mClickPos( clickPos ),
2234 mpBar( pBar )
2235 {}
2236};
2237
2238/*
2239Class for layout customization events.
2240*/
2241
2242class cbCustomizeLayoutEvent : public cbPluginEvent
2243{
2244public:
2245 wxPoint mClickPos; // in parent frame's coordinates
2246
2247 // Constructor, taking mouse position.
2248
2249 cbCustomizeLayoutEvent( const wxPoint& clickPos )
2250
2251 : cbPluginEvent( cbEVT_PL_CUSTOMIZE_LAYOUT, 0 ),
2252 mClickPos( clickPos )
2253 {}
2254};
2255
2256#endif /* __CONTROLBAR_G__ */
2257