]>
Commit | Line | Data |
---|---|---|
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 | ||
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 |