1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: interface of wxAuiManager
4 // Author: wxWidgets team
6 // Licence: wxWindows licence
7 /////////////////////////////////////////////////////////////////////////////
11 @todo wxAuiPaneInfo dock direction types used with wxAuiManager.
18 wxAUI_DOCK_BOTTOM
= 3,
20 wxAUI_DOCK_CENTER
= 5,
21 wxAUI_DOCK_CENTRE
= wxAUI_DOCK_CENTER
26 @todo wxAuiManager behavior style flags.
28 enum wxAuiManagerOption
30 wxAUI_MGR_ALLOW_FLOATING
= 1 << 0,
31 wxAUI_MGR_ALLOW_ACTIVE_PANE
= 1 << 1,
32 wxAUI_MGR_TRANSPARENT_DRAG
= 1 << 2,
33 wxAUI_MGR_TRANSPARENT_HINT
= 1 << 3,
34 wxAUI_MGR_VENETIAN_BLINDS_HINT
= 1 << 4,
35 wxAUI_MGR_RECTANGLE_HINT
= 1 << 5,
36 wxAUI_MGR_HINT_FADE
= 1 << 6,
37 wxAUI_MGR_NO_VENETIAN_BLINDS_FADE
= 1 << 7,
38 wxAUI_MGR_LIVE_RESIZE
= 1 << 8,
40 wxAUI_MGR_DEFAULT
= wxAUI_MGR_ALLOW_FLOATING
|
41 wxAUI_MGR_TRANSPARENT_HINT
|
43 wxAUI_MGR_NO_VENETIAN_BLINDS_FADE
49 wxAuiManager is the central class of the wxAUI class framework.
51 wxAuiManager manages the panes associated with it for a particular wxFrame,
52 using a pane's wxAuiPaneInfo information to determine each pane's docking
53 and floating behavior.
55 wxAuiManager uses wxWidgets' sizer mechanism to plan the layout of each
56 frame. It uses a replaceable dock art class to do all drawing, so all
57 drawing is localized in one area, and may be customized depending on an
58 application's specific needs.
60 wxAuiManager works as follows: the programmer adds panes to the class,
61 or makes changes to existing pane properties (dock position, floating
62 state, show state, etc.). To apply these changes, wxAuiManager's
63 Update() function is called. This batch processing can be used to avoid
64 flicker, by modifying more than one pane at a time, and then "committing"
65 all of the changes at once by calling Update().
67 Panes can be added quite easily:
70 wxTextCtrl* text1 = new wxTextCtrl(this, -1);
71 wxTextCtrl* text2 = new wxTextCtrl(this, -1);
72 m_mgr.AddPane(text1, wxLEFT, "Pane Caption");
73 m_mgr.AddPane(text2, wxBOTTOM, "Pane Caption");
77 Later on, the positions can be modified easily. The following will float
78 an existing pane in a tool window:
81 m_mgr.GetPane(text1).Float();
85 @section auimanager_layers Layers, Rows and Directions, Positions
87 Inside wxAUI, the docking layout is figured out by checking several pane
88 parameters. Four of these are important for determining where a pane will
91 @li Direction: Each docked pane has a direction, Top, Bottom, Left, Right,
92 or Center. This is fairly self-explanatory. The pane will be placed in
93 the location specified by this variable.
94 @li Position: More than one pane can be placed inside of a dock. Imagine
95 two panes being docked on the left side of a window. One pane can be
96 placed over another. In proportionally managed docks, the pane
97 position indicates its sequential position, starting with zero. So, in
98 our scenario with two panes docked on the left side, the top pane in
99 the dock would have position 0, and the second one would occupy
101 @li Row: A row can allow for two docks to be placed next to each other.
102 One of the most common places for this to happen is in the toolbar.
103 Multiple toolbar rows are allowed, the first row being row 0, and the
104 second row 1. Rows can also be used on vertically docked panes.
105 @li Layer: A layer is akin to an onion. Layer 0 is the very center of the
106 managed pane. Thus, if a pane is in layer 0, it will be closest to the
107 center window (also sometimes known as the "content window").
108 Increasing layers "swallow up" all layers of a lower value. This can
109 look very similar to multiple rows, but is different because all panes
110 in a lower level yield to panes in higher levels. The best way to
111 understand layers is by running the wxAUI sample.
114 @beginEventEmissionTable{wxAuiManagerEvent}
115 @event{EVT_AUI_PANE_BUTTON(func)}
116 Triggered when any button is pressed for any docked panes.
117 @event{EVT_AUI_PANE_CLOSE(func)}
118 Triggered when a docked or floating pane is closed.
119 @event{EVT_AUI_PANE_MAXIMIZE(func)}
120 Triggered when a pane is maximized.
121 @event{EVT_AUI_PANE_RESTORE(func)}
122 Triggered when a pane is restored.
123 @event{EVT_AUI_RENDER(func)}
124 This event can be caught to override the default renderer in order to
125 custom draw your wxAuiManager window (not recommended).
131 @see @ref overview_aui, wxAuiNotebook, wxAuiDockArt, wxAuiPaneInfo
133 class wxAuiManager
: public wxEvtHandler
137 Constructor. @a managed_wnd specifies the wxFrame which should be managed.
138 @a flags specifies options which allow the frame management behavior
141 wxAuiManager(wxWindow
* managed_wnd
= NULL
,
142 unsigned int flags
= wxAUI_MGR_DEFAULT
);
147 virtual ~wxAuiManager();
151 AddPane() tells the frame manager to start managing a child window.
152 There are several versions of this function. The first version allows
153 the full spectrum of pane parameter possibilities. The second version is
154 used for simpler user interfaces which do not require as much configuration.
155 The last version allows a drop position to be specified, which will determine
156 where the pane will be added.
158 bool AddPane(wxWindow
* window
, const wxAuiPaneInfo
& pane_info
);
159 bool AddPane(wxWindow
* window
, int direction
= wxLEFT
,
160 const wxString
& caption
= wxEmptyString
);
161 bool AddPane(wxWindow
* window
,
162 const wxAuiPaneInfo
& pane_info
,
163 const wxPoint
& drop_pos
);
167 Tells the wxAuiManager to stop managing the pane specified by window.
168 The window, if in a floated frame, is reparented to the frame managed
171 bool DetachPane(wxWindow
* window
);
174 Returns an array of all panes managed by the frame manager.
176 wxAuiPaneInfoArray
& GetAllPanes();
179 Returns the current art provider being used.
182 wxAuiDockArt
* GetArtProvider() const;
185 Returns the current dock constraint values.
186 See SetDockSizeConstraint() for more information.
188 void GetDockSizeConstraint(double* widthpct
, double* heightpct
) const;
191 Returns the current manager's flags.
193 unsigned int GetFlags() const;
196 Returns the frame currently being managed by wxAuiManager.
198 wxWindow
* GetManagedWindow() const;
201 Calling this method will return the wxAuiManager for a given window.
202 The @a window parameter should specify any child window or sub-child
203 window of the frame or window managed by wxAuiManager.
205 The @a window parameter need not be managed by the manager itself, nor does it
206 even need to be a child or sub-child of a managed window. It must however
207 be inside the window hierarchy underneath the managed window.
209 static wxAuiManager
* GetManager(wxWindow
* window
);
213 GetPane() is used to lookup a wxAuiPaneInfo object either by window pointer
214 or by pane name, which acts as a unique id for a window pane.
216 The returned wxAuiPaneInfo object may then be modified to change a pane's
217 look, state or position. After one or more modifications to wxAuiPaneInfo,
218 wxAuiManager::Update() should be called to commit the changes to the user
219 interface. If the lookup failed (meaning the pane could not be found in the
220 manager), a call to the returned wxAuiPaneInfo's IsOk() method will return @false.
222 wxAuiPaneInfo
& GetPane(wxWindow
* window
);
223 wxAuiPaneInfo
& GetPane(const wxString
& name
);
227 HideHint() hides any docking hint that may be visible.
229 virtual void HideHint();
232 This method is used to insert either a previously unmanaged pane window
233 into the frame manager, or to insert a currently managed pane somewhere
234 else. InsertPane() will push all panes, rows, or docks aside and
235 insert the window into the position specified by @a insert_location.
237 Because @a insert_location can specify either a pane, dock row, or dock
238 layer, the @a insert_level parameter is used to disambiguate this.
239 The parameter @a insert_level can take a value of wxAUI_INSERT_PANE,
240 wxAUI_INSERT_ROW or wxAUI_INSERT_DOCK.
242 bool InsertPane(wxWindow
* window
,
243 const wxAuiPaneInfo
& insert_location
,
244 int insert_level
= wxAUI_INSERT_PANE
);
247 LoadPaneInfo() is similar to to LoadPerspective, with the exception that it
248 only loads information about a single pane. It is used in combination with
251 void LoadPaneInfo(wxString pane_part
, wxAuiPaneInfo
& pane
);
254 Loads a saved perspective. If update is @true, wxAuiManager::Update()
255 is automatically invoked, thus realizing the saved perspective on screen.
257 bool LoadPerspective(const wxString
& perspective
,
261 SavePaneInfo() is similar to SavePerspective, with the exception that it only
262 saves information about a single pane. It is used in combination with
265 wxString
SavePaneInfo(wxAuiPaneInfo
& pane
);
268 Saves the entire user interface layout into an encoded wxString, which
269 can then be stored by the application (probably using wxConfig).
271 When a perspective is restored using LoadPerspective(), the entire user
272 interface will return to the state it was when the perspective was saved.
274 wxString
SavePerspective();
277 Instructs wxAuiManager to use art provider specified by parameter
278 @a art_provider for all drawing calls.
279 This allows plugable look-and-feel features. The previous art provider object,
280 if any, will be deleted by wxAuiManager.
284 void SetArtProvider(wxAuiDockArt
* art_provider
);
287 When a user creates a new dock by dragging a window into a docked position,
288 often times the large size of the window will create a dock that is unwieldly
289 large. wxAuiManager by default limits the size of any new dock to 1/3 of the
290 window size. For horizontal docks, this would be 1/3 of the window height.
291 For vertical docks, 1/3 of the width.
293 Calling this function will adjust this constraint value. The numbers must be
294 between 0.0 and 1.0. For instance, calling SetDockSizeContraint with
295 0.5, 0.5 will cause new docks to be limited to half of the size of the
296 entire managed window.
298 void SetDockSizeConstraint(double widthpct
, double heightpct
);
301 This method is used to specify wxAuiManager's settings flags. @a flags
302 specifies options which allow the frame management behavior to be modified.
304 void SetFlags(unsigned int flags
);
307 Called to specify the frame or window which is to be managed by wxAuiManager.
308 Frame management is not restricted to just frames. Child windows or custom
309 controls are also allowed.
311 void SetManagedWindow(wxWindow
* managed_wnd
);
314 This function is used by controls to explicitly show a hint window at the
315 specified rectangle. It is rarely called, and is mostly used by controls
316 implementing custom pane drag/drop behaviour.
317 The specified rectangle should be in screen coordinates.
319 virtual void ShowHint(const wxRect
& rect
);
322 Uninitializes the framework and should be called before a managed frame or
323 window is destroyed. UnInit() is usually called in the managed wxFrame's
324 destructor. It is necessary to call this function before the managed frame
325 or window is destroyed, otherwise the manager cannot remove its custom event
326 handlers from a window.
331 This method is called after any number of changes are
332 made to any of the managed panes. Update() must be invoked after
333 AddPane() or InsertPane() are called in order to "realize" or "commit"
334 the changes. In addition, any number of changes may be made to
335 wxAuiPaneInfo structures (retrieved with wxAuiManager::GetPane), but to
336 realize the changes, Update() must be called. This construction allows
337 pane flicker to be avoided by updating the whole layout at one time.
344 ProcessDockResult() is a protected member of the wxAUI layout manager.
345 It can be overridden by derived classes to provide custom docking calculations.
347 virtual bool ProcessDockResult(wxAuiPaneInfo
& target
,
348 const wxAuiPaneInfo
& new_pos
);
356 wxAuiPaneInfo is part of the wxAUI class framework.
357 See also @ref overview_aui.
359 wxAuiPaneInfo specifies all the parameters for a pane.
360 These parameters specify where the pane is on the screen, whether it is docked
361 or floating, or hidden.
362 In addition, these parameters specify the pane's docked position, floating
363 position, preferred size, minimum size, caption text among many other parameters.
368 @see wxAuiManager, wxAuiDockArt
378 wxAuiPaneInfo(const wxAuiPaneInfo
& c
);
382 BestSize() sets the ideal size for the pane. The docking manager will attempt
383 to use this size as much as possible when docking or floating the pane.
385 wxAuiPaneInfo
& BestSize(const wxSize
& size
);
386 wxAuiPaneInfo
& BestSize(int x
, int y
);
390 Bottom() sets the pane dock position to the bottom side of the frame. This is
391 the same thing as calling Direction(wxAUI_DOCK_BOTTOM).
393 wxAuiPaneInfo
& Bottom();
396 BottomDockable() indicates whether a pane can be docked at the bottom of the
399 wxAuiPaneInfo
& BottomDockable(bool b
= true);
402 Caption() sets the caption of the pane.
404 wxAuiPaneInfo
& Caption(const wxString
& c
);
407 CaptionVisible indicates that a pane caption should be visible. If @false, no
408 pane caption is drawn.
410 wxAuiPaneInfo
& CaptionVisible(bool visible
= true);
414 Center() sets the pane dock position to the left side of the frame.
415 The centre pane is the space in the middle after all border panes (left, top,
416 right, bottom) are subtracted from the layout.
417 This is the same thing as calling Direction(wxAUI_DOCK_CENTRE).
419 wxAuiPaneInfo
& Centre();
420 wxAuiPaneInfo
& Center();
425 CentrePane() specifies that the pane should adopt the default center pane
426 settings. Centre panes usually do not have caption bars.
427 This function provides an easy way of preparing a pane to be displayed in
428 the center dock position.
430 wxAuiPaneInfo
& CentrePane();
431 wxAuiPaneInfo
& CenterPane();
435 CloseButton() indicates that a close button should be drawn for the pane.
437 wxAuiPaneInfo
& CloseButton(bool visible
= true);
440 DefaultPane() specifies that the pane should adopt the default pane settings.
442 wxAuiPaneInfo
& DefaultPane();
445 DestroyOnClose() indicates whether a pane should be detroyed when it is closed.
446 Normally a pane is simply hidden when the close button is clicked.
447 Setting DestroyOnClose to @true will cause the window to be destroyed when
448 the user clicks the pane's close button.
450 wxAuiPaneInfo
& DestroyOnClose(bool b
= true);
453 Direction() determines the direction of the docked pane. It is functionally the
454 same as calling Left(), Right(), Top() or Bottom(), except that docking direction
455 may be specified programmatically via the parameter.
457 wxAuiPaneInfo
& Direction(int direction
);
460 Dock() indicates that a pane should be docked. It is the opposite of Float().
462 wxAuiPaneInfo
& Dock();
465 DockFixed() causes the containing dock to have no resize sash. This is useful
466 for creating panes that span the entire width or height of a dock, but should
467 not be resizable in the other direction.
469 wxAuiPaneInfo
& DockFixed(bool b
= true);
472 Dockable() specifies whether a frame can be docked or not. It is the same as
473 specifying TopDockable(b).BottomDockable(b).LeftDockable(b).RightDockable(b).
475 wxAuiPaneInfo
& Dockable(bool b
= true);
478 Fixed() forces a pane to be fixed size so that it cannot be resized. After
479 calling Fixed(), IsFixed() will return @true.
481 wxAuiPaneInfo
& Fixed();
484 Float() indicates that a pane should be floated. It is the opposite of Dock().
486 wxAuiPaneInfo
& Float();
489 Floatable() sets whether the user will be able to undock a pane and turn it
490 into a floating window.
492 wxAuiPaneInfo
& Floatable(bool b
= true);
496 FloatingPosition() sets the position of the floating pane.
498 wxAuiPaneInfo
& FloatingPosition(const wxPoint
& pos
);
499 wxAuiPaneInfo
& FloatingPosition(int x
, int y
);
504 FloatingSize() sets the size of the floating pane.
506 wxAuiPaneInfo
& FloatingSize(const wxSize
& size
);
507 wxAuiPaneInfo
& FloatingSize(int x
, int y
);
511 Gripper() indicates that a gripper should be drawn for the pane.
513 wxAuiPaneInfo
& Gripper(bool visible
= true);
516 GripperTop() indicates that a gripper should be drawn at the top of the pane.
518 wxAuiPaneInfo
& GripperTop(bool attop
= true);
521 HasBorder() returns @true if the pane displays a border.
523 bool HasBorder() const;
526 HasCaption() returns @true if the pane displays a caption.
528 bool HasCaption() const;
531 HasCloseButton() returns @true if the pane displays a button to close the pane.
533 bool HasCloseButton() const;
536 HasFlag() returns @true if the property specified by flag is active for
539 bool HasFlag(int flag
) const;
542 HasGripper() returns @true if the pane displays a gripper.
544 bool HasGripper() const;
547 HasGripper() returns @true if the pane displays a gripper at the top.
549 bool HasGripperTop() const;
552 HasMaximizeButton() returns @true if the pane displays a button to maximize the
555 bool HasMaximizeButton() const;
558 HasMinimizeButton() returns @true if the pane displays a button to minimize the
561 bool HasMinimizeButton() const;
564 HasPinButton() returns @true if the pane displays a button to float the pane.
566 bool HasPinButton() const;
569 Hide() indicates that a pane should be hidden.
571 wxAuiPaneInfo
& Hide();
574 Icon() sets the icon of the pane.
576 Notice that the height of the icon should be smaller than the value
577 returned by wxAuiDockArt::GetMetric(wxAUI_DOCKART_CAPTION_SIZE) to
578 ensure that it appears correctly.
582 wxAuiPaneInfo
& Icon(const wxBitmap
& b
);
585 IsBottomDockable() returns @true if the pane can be docked at the bottom of the
590 bool IsBottomDockable() const;
593 Returns @true if the pane can be docked at any side.
595 @see IsTopDockable(), IsBottomDockable(), IsLeftDockable(), IsRightDockable()
599 bool IsDockable() const;
602 IsDocked() returns @true if the pane is currently docked.
604 bool IsDocked() const;
607 IsFixed() returns @true if the pane cannot be resized.
609 bool IsFixed() const;
612 IsFloatable() returns @true if the pane can be undocked and displayed as a
615 bool IsFloatable() const;
618 IsFloating() returns @true if the pane is floating.
620 bool IsFloating() const;
623 IsLeftDockable() returns @true if the pane can be docked on the left of the
628 bool IsLeftDockable() const;
631 IsMoveable() returns @true if the docked frame can be undocked or moved to
632 another dock position.
634 bool IsMovable() const;
637 IsOk() returns @true if the wxAuiPaneInfo structure is valid. A pane structure
638 is valid if it has an associated window.
643 IsResizable() returns @true if the pane can be resized.
645 bool IsResizable() const;
648 IsRightDockable() returns @true if the pane can be docked on the right of the
653 bool IsRightDockable() const;
656 IsShown() returns @true if the pane is currently shown.
658 bool IsShown() const;
661 IsToolbar() returns @true if the pane contains a toolbar.
663 bool IsToolbar() const;
666 IsTopDockable() returns @true if the pane can be docked at the top of the
671 bool IsTopDockable() const;
674 Layer() determines the layer of the docked pane. The dock layer is similar to
675 an onion, the inner-most layer being layer 0. Each shell moving in the outward
676 direction has a higher layer number. This allows for more complex docking layout
679 wxAuiPaneInfo
& Layer(int layer
);
682 Left() sets the pane dock position to the left side of the frame. This is the
683 same thing as calling Direction(wxAUI_DOCK_LEFT).
685 wxAuiPaneInfo
& Left();
688 LeftDockable() indicates whether a pane can be docked on the left of the frame.
690 wxAuiPaneInfo
& LeftDockable(bool b
= true);
694 MaxSize() sets the maximum size of the pane.
696 wxAuiPaneInfo
& MaxSize(const wxSize
& size
);
697 wxAuiPaneInfo
& MaxSize(int x
, int y
);
701 MaximizeButton() indicates that a maximize button should be drawn for the pane.
703 wxAuiPaneInfo
& MaximizeButton(bool visible
= true);
707 MinSize() sets the minimum size of the pane. Please note that this is only
708 partially supported as of this writing.
710 wxAuiPaneInfo
& MinSize(const wxSize
& size
);
711 wxAuiPaneInfo
& MinSize(int x
, int y
);
715 MinimizeButton() indicates that a minimize button should be drawn for the pane.
717 wxAuiPaneInfo
& MinimizeButton(bool visible
= true);
720 Movable indicates whether a frame can be moved.
722 wxAuiPaneInfo
& Movable(bool b
= true);
725 Name() sets the name of the pane so it can be referenced in lookup functions.
726 If a name is not specified by the user, a random name is assigned to the pane
727 when it is added to the manager.
729 wxAuiPaneInfo
& Name(const wxString
& n
);
732 PaneBorder indicates that a border should be drawn for the pane.
734 wxAuiPaneInfo
& PaneBorder(bool visible
= true);
737 PinButton() indicates that a pin button should be drawn for the pane.
739 wxAuiPaneInfo
& PinButton(bool visible
= true);
742 Position() determines the position of the docked pane.
744 wxAuiPaneInfo
& Position(int pos
);
747 Resizable() allows a pane to be resized if the parameter is @true, and forces it
748 to be a fixed size if the parameter is @false. This is simply an antonym for Fixed().
750 wxAuiPaneInfo
& Resizable(bool resizable
= true);
753 Right() sets the pane dock position to the right side of the frame.
755 wxAuiPaneInfo
& Right();
758 RightDockable() indicates whether a pane can be docked on the right of the
761 wxAuiPaneInfo
& RightDockable(bool b
= true);
764 Row() determines the row of the docked pane.
766 wxAuiPaneInfo
& Row(int row
);
769 Write the safe parts of a newly loaded PaneInfo structure "source" into "this"
770 used on loading perspectives etc.
772 void SafeSet(wxAuiPaneInfo source
);
775 SetFlag() turns the property given by flag on or off with the option_state
778 wxAuiPaneInfo
& SetFlag(int flag
, bool option_state
);
781 Show() indicates that a pane should be shown.
783 wxAuiPaneInfo
& Show(bool show
= true);
786 ToolbarPane() specifies that the pane should adopt the default toolbar pane
789 wxAuiPaneInfo
& ToolbarPane();
792 Top() sets the pane dock position to the top of the frame.
794 wxAuiPaneInfo
& Top();
797 TopDockable() indicates whether a pane can be docked at the top of the frame.
799 wxAuiPaneInfo
& TopDockable(bool b
= true);
802 Window() assigns the window pointer that the wxAuiPaneInfo should use.
803 This normally does not need to be specified, as the window pointer is
804 automatically assigned to the wxAuiPaneInfo structure as soon as it is added
807 wxAuiPaneInfo
& Window(wxWindow
* w
);
810 Makes a copy of the wxAuiPaneInfo object.
812 wxAuiPaneInfo
& operator=(const wxAuiPaneInfo
& c
);
818 @class wxAuiManagerEvent
820 Event used to indicate various actions taken with wxAuiManager.
822 See wxAuiManager for available event types.
824 @beginEventTable{wxAuiManagerEvent}
825 @event{EVT_AUI_PANE_BUTTON(func)}
826 Triggered when any button is pressed for any docked panes.
827 @event{EVT_AUI_PANE_CLOSE(func)}
828 Triggered when a docked or floating pane is closed.
829 @event{EVT_AUI_PANE_MAXIMIZE(func)}
830 Triggered when a pane is maximized.
831 @event{EVT_AUI_PANE_RESTORE(func)}
832 Triggered when a pane is restored.
833 @event{EVT_AUI_RENDER(func)}
834 This event can be caught to override the default renderer in order to
835 custom draw your wxAuiManager window (not recommended).
839 @category{events,aui}
841 @see wxAuiManager, wxAuiPaneInfo
843 class wxAuiManagerEvent
: public wxEvent
849 wxAuiManagerEvent(wxEventType type
= wxEVT_NULL
);
852 @return @true if this event can be vetoed.
859 @return The ID of the button that was clicked.
869 @return @true if this event was vetoed.
876 @return The wxAuiManager this event is associated with.
878 wxAuiManager
* GetManager();
881 @return The pane this event is associated with.
883 wxAuiPaneInfo
* GetPane();
886 Sets the ID of the button clicked that triggered this event.
888 void SetButton(int button
);
891 Sets whether or not this event can be vetoed.
893 void SetCanVeto(bool can_veto
);
898 void SetDC(wxDC
* pdc
);
901 Sets the wxAuiManager this event is associated with.
903 void SetManager(wxAuiManager
* manager
);
906 Sets the pane this event is associated with.
908 void SetPane(wxAuiPaneInfo
* pane
);
911 Cancels the action indicated by this event if CanVeto() is @true.
913 void Veto(bool veto
= true);