SliceTool Class Reference

SliceTool is actually a misnomer. This tool is used for creating rollover buttons and bars for web pages. More...

#include <slicetool.h>

Inheritance diagram for SliceTool:

List of all members.

Public Member Functions
	SliceTool ()
	Default Constructor. Other initialisation is done in SliceTool::Init which is called by the Tool Manager.
virtual	~SliceTool ()
	Destructor (Virtual). Does nothing.
virtual BOOL	Init ()
	Used to check if the Tool was properly constructed.
virtual void	Describe (void *InfoPtr)
	Allows the tool manager to extract information about the tool.
virtual UINT32	GetID ()
void	ViewChanged (const DocViewMsg &msg)
	The SliceTool's view-changed message handler. This method is called directly from the message handler of SliceInfoBarOp, which lives further down in this file. Its sole purpose is to let us redraw our blobs correctly.
virtual void	RenderToolBlobs (Spread *pSpread, DocRect *pClipRect)
	Render the SliceTool's tool blob. This consists of a bounding rect identical to that used when dragging the selection (dotted, red line), around whatever is currently selected.
virtual BOOL	AreToolBlobsRenderedOnSelection ()
virtual void	SelectChange (BOOL isSelected)
	Starts up and closes down the Slice tool.
virtual void	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	To handle a Mouse Click event for the Slice Tool.
virtual BOOL	OnKeyPress (KeyPress *pKey)
	key-press event handler. Catch CTRL/ALT/SHIFT modifiers and change the status-line/cursor appropriately.
virtual void	OnMouseMove (DocCoord PointerPos, Spread *pSpread, ClickModifiers ClickMods)
	To handle a Mouse Move event for the Slice Tool.
virtual BOOL	GetStatusLineText (String_256 *ptext, Spread *pSpread, DocCoord DocPos, ClickModifiers ClickMods)
	Figure out what the status text for the SliceTool is at the given position on the given spread with the given click modifiers.
virtual void	SelectionHasChanged ()
	A public function, for other people to call whenever they need to let the Slice tool know that the selection has changed.
Static Public Member Functions
static SliceInfoBarOp *	GetSliceInfoBarOp ()
static BOOL	IsCurrentTool ()
Protected Types
enum	ClickActionCode {   CLICKACTION_NONE, CLICKACTION_SELNONE, CLICKACTION_SELNODE, CLICKACTION_SELUNDER,   CLICKACTION_SELUNDERCYCLE, CLICKACTION_SELUNDERFAIL, CLICKACTION_SELUNDERFAIL2, CLICKACTION_SELINSIDE,   CLICKACTION_SELINSIDECYCLE, CLICKACTION_SELINSIDEFAIL, CLICKACTION_SELINSIDEFAIL2, CLICKACTION_SELLEAF }
enum	SetSelectionState { NoSetsSelected, HalfSetsSelected, FullSetsSelected }
Protected Member Functions
virtual BOOL	UpdateSelectionInfo ()
	Updates the slice tool's record of the spread and bounding rectangle of the current selection.
virtual BOOL	PreProcessClick ()
	Allows a click to be handled before going through the main click-handling code. This function checks for a clicked Node, and allows it to respond to the click.
virtual BOOL	ProcessObjectClick ()
	In the selector tool, this function OnClick()'s each object in the tool's range if the Selector tool is using Object blobs. We don't, so we won't.
virtual void	PostProcessClick ()
	Provided a click wasn't eaten by a pre- or mid- processor, we deal with it here. This passes the event on to specific handler routines, depending on its type (TypeOfClick):.
virtual NodeRenderableInk *	FindPreProcessClickNode (Spread *pSpread, DocCoord ClickPos, BOOL Interruptible=FALSE)
virtual void	HandleSingleClick ()
	Single mouse-click event handler.
virtual void	HandleDoubleClick ()
	Double mouse-click event handler. Currently, passes the event to HandleSingleClick().
virtual void	HandleDragClick ()
	Mouse-drag event handler.
virtual void	HandleButtonUp ()
	Mouse button-up event handler.
virtual void	HandleTabKey (BOOL bIsShifted)
	Tab keypress event handler.
virtual void	SetKeyDownCursor (ClickModifiers cmMods)
	Decodes the bit-field fKeyStates, indicating which combination of modifier keys are down, and sets the cursor appropriately.
virtual void	FigureUserFeedback (Spread *pSpread, DocCoord dcPos, ClickModifiers cmods, BOOL DoSlowTests, String_256 *pStr, Cursor **ppPointerShape)
BOOL	Append (String_256 *pStr, UINT32 StringID)
BOOL	Append (String_256 *pStr, String_256 String)
BOOL	Append (String_256 *pStr, ClickModifiers cmods, UINT32 SelectID, UINT32 AddID, UINT32 RemoveID, NodeRenderableInk *pActionNode=NULL)
BOOL	Append (String_256 *pStr, ClickModifiers cmods, String_256 SelectTemplate, String_256 AddTemplate, String_256 RemoveTemplate, NodeRenderableInk *pActionNode=NULL)
BOOL	IsTranslateShortcut (ClickModifiers cmods) const
	Detects whether the current mouse click modifiers denote the translate drag operation shortcut.
BOOL	IsClickModified (ClickModifiers cmods) const
	Tests whether any of the modifiers, eg. Constrain, Adjust etc, apply to the current mouse click (as received by the OnClick function).
BOOL	IsSelectUnderClick (ClickModifiers cmods) const
	Decides whether the current click is modified to be an "under" click or not.
BOOL	IsSelectMemberClick (ClickModifiers cmods) const
	Reports whether the current mouse click meant the user wanted to "select- inside" or not.
BOOL	IsSelectLeafClick (ClickModifiers cmods) const
	Reports whether the current mouse click meant the user wanted to "select- leaf" or not.
void	DoTranslate ()
	Runs a translation tranformation drag on the selection.
void	DoDragBox ()
	Runs a selector-tool drag-box operation.
void	MakeSelectionValidForDrag ()
	Runs through the selected nodes, making sure they are all happy with being dragged. Checks are:- 1. Sub-Selected text characters are deselected, and their parent story (and all other nodes sharing its name) are selected instead.
NodeRenderableInk *	FindFrom (NodeRenderableInk *pSimpleNode) const
	Front-end short-hand for NodeRenderableInk::FindCompoundFromSimple.
ClickActionCode	DetermineClickAction (NodeRenderableInk **ppActionNode, NodeRenderableInk *pLastClickNode, NodeRenderableInk *pClickSimpleNode, NodeRenderableInk *pClickCompoundNode, Spread *pStartSpread, DocCoord ClickStart, ClickModifiers ClickMods)
	Determine what action needs to be taken in response to a click.
ClickActionCode	CycleClickAction (NodeRenderableInk **ppActionNode, NodeRenderableInk *pClickCompoundNode, ClickActionCode foundAction, ClickActionCode cycleAction)
	Determine what action needs to be taken in response to a click.
BOOL	ValidateLastClickUnder (NodeRenderableInk *pLastClickNode, Spread *pStartSpread, DocCoord ClickStart)
	Validate that the last click node is still under the pointer Note! This routine can be slow depending on how deep it has to look in the tree for the last selected object.
BOOL	ValidateLastClickInside (NodeRenderableInk *pLastClickNode, NodeRenderableInk *pClickSimpleNode)
	Validate that the simple node is inside the last clicked node.
virtual BOOL	DragFinished (DragEndType det)
	Called by TransOperation when a drag is finished. Allows the SliceTool to reset its cursors and update its current selection information.
Static Protected Member Functions
static void	SetStatusText (UINT32 nStringID)
	Sets the status bar text to the given string. Alternative to loading the string yourself and calling the other SetStatusText function.
static void	SetStatusText (String_256 *pStr)
	Sets the status bar text to the given string.
Protected Attributes
Cursor *	pcNormalSliceCursor
Cursor *	pcAdjustCursor
Cursor *	pcUnderCursor
Cursor *	pcInsideCursor
Cursor *	pcUnderAdjustCursor
Cursor *	pcInsideAdjustCursor
Cursor *	pcLeafCursor
Cursor *	pcLeafAdjustCursor
Cursor *	pcALLCursor
Cursor *	pcHorzGuideCursor
Cursor *	pcVertGuideCursor
DocCoord	ClickStart
Spread *	StartSpread
ClickModifiers	ClickMods
ClickType	TypeOfClick
Spread *	SelectionSpread
SelRange *	SelectRange
DocRect	SelectionRect
BOOL	m_bSliceToolSetSel
DocRect	m_drBlobRect
NodeRenderableInk *	pClickSimpleNode
NodeRenderableInk *	pClickCompoundNode
NodeRenderableInk *	pLastClickNode
NodeRenderableInk *	pPreProcClickNode
enum SetSelectionState	m_SetSelectionState
TransformBoundingData	BoundingData
Private Member Functions
	CC_DECLARE_MEMDUMP (SliceTool)
void	DisplayStatusBarHelp (DocCoord DocPos, Spread *pSpread, ClickModifiers ClickMods)
	Displays status help string for the given position in the status bar.
void	GetCurrentStatusText (String_256 *ptext, Spread *pSpread, DocCoord DocPos, ClickModifiers ClickMods)
	Selects a suitable string for the status line based on the current location (as input via the parameters).
BOOL	CreateCursors ()
	Creates all the Slice tool cursors.
void	DestroyCursors ()
	Destroys all the Slice tool cursors.
Private Attributes
Cursor *	pcCurrentCursor
INT32	CurrentCursorID
BOOL	m_fIgnoreSelChange
Static Private Attributes
static BOOL	CurrentTool = FALSE
static SliceInfoBarOp *	pSliceInfoBarOp = NULL
static char *	FamilyName = "Slice Tools"
static char *	ToolName = "Slice Tool"
static char *	Purpose = "Slice manipulation"
static char *	Author = "Simon K"
Friends
class	OpSliceDragBox
class	OpSliceTranslate

---

Detailed Description

SliceTool is actually a misnomer. This tool is used for creating rollover buttons and bars for web pages.

Author:

Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> / Simon Knight

Date:

September 1999

Definition at line 132 of file slicetool.h.

---

Member Enumeration Documentation

enum SliceTool::ClickActionCode [protected]

Enumerator: CLICKACTION_NONE  CLICKACTION_SELNONE  CLICKACTION_SELNODE  CLICKACTION_SELUNDER  CLICKACTION_SELUNDERCYCLE  CLICKACTION_SELUNDERFAIL  CLICKACTION_SELUNDERFAIL2  CLICKACTION_SELINSIDE  CLICKACTION_SELINSIDECYCLE  CLICKACTION_SELINSIDEFAIL  CLICKACTION_SELINSIDEFAIL2  CLICKACTION_SELLEAF  Definition at line 291 of file slicetool.h. { CLICKACTION_NONE, CLICKACTION_SELNONE, CLICKACTION_SELNODE, CLICKACTION_SELUNDER, CLICKACTION_SELUNDERCYCLE, CLICKACTION_SELUNDERFAIL, CLICKACTION_SELUNDERFAIL2, CLICKACTION_SELINSIDE, CLICKACTION_SELINSIDECYCLE, CLICKACTION_SELINSIDEFAIL, CLICKACTION_SELINSIDEFAIL2, CLICKACTION_SELLEAF };

enum SliceTool::SetSelectionState [protected]

Enumerator: NoSetsSelected  HalfSetsSelected  FullSetsSelected  Definition at line 307 of file slicetool.h. { NoSetsSelected, HalfSetsSelected, FullSetsSelected };

---

Constructor & Destructor Documentation

SliceTool::SliceTool (   )

Default Constructor. Other initialisation is done in SliceTool::Init which is called by the Tool Manager. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 See also: SliceTool::Init Definition at line 202 of file slicetool.cpp. { // initialise all our member pointers to NULL. pcNormalSliceCursor = NULL; pcAdjustCursor = NULL; pcUnderCursor = NULL; pcInsideCursor = NULL; pcUnderAdjustCursor = NULL; pcInsideAdjustCursor = NULL; pcLeafCursor = NULL; pcLeafAdjustCursor = NULL; pcCurrentCursor = NULL; pcALLCursor = NULL; pcHorzGuideCursor = NULL; pcVertGuideCursor = NULL; StartSpread = NULL; SelectionSpread = NULL; SelectRange = NULL; pClickSimpleNode = NULL; pClickCompoundNode = NULL; pLastClickNode = NULL; pPreProcClickNode = NULL; }

SliceTool::~SliceTool (   )  [virtual]

Destructor (Virtual). Does nothing. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 Definition at line 240 of file slicetool.cpp. { }

---

Member Function Documentation

BOOL SliceTool::Append (  String_256 *  pStr, ClickModifiers  cmods, String_256  SelectTemplate, String_256  AddTemplate, String_256  RemoveTemplate, NodeRenderableInk *  pActionNode = NULL )  [protected]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 01/06/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 2404 of file slicetool.cpp. { ERROR2IF(SelectTemplate.IsEmpty(), FALSE, "Asked to Append an empty message"); // Append a message to the string, preceding it with a separator if there was something // already in the string... if (!pStr->IsEmpty()) *pStr += String_256(_R(IDS_SLICE_SEPARATOR)); String_256 Message; String_256* pTemplate; Message.Empty(); if (!cmods.Adjust || pActionNode==NULL) pTemplate = &SelectTemplate; else { if (!pActionNode->IsSelected()) pTemplate = &AddTemplate; else pTemplate = &RemoveTemplate; } if (pTemplate->IsEmpty()) pTemplate = &SelectTemplate; if (pActionNode==NULL) *pStr += *pTemplate; else { Message._MakeMsg( (TCHAR*) *pTemplate, &pActionNode->Describe(FALSE) ); *pStr += Message; } return TRUE; }

BOOL SliceTool::Append (  String_256 *  pStr, ClickModifiers  cmods, UINT32  SelectID, UINT32  AddID, UINT32  RemoveID, NodeRenderableInk *  pActionNode = NULL )  [protected]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 2286 of file slicetool.cpp. { ERROR2IF(SelectID==0, FALSE, "Asked to append a string resource with a null ID"); // Append a message to the string, preceding it with a separator if there was something // already in the string... if (!pStr->IsEmpty()) *pStr += String_256(_R(IDS_SLICE_SEPARATOR)); String_256 Message; UINT32 TemplateID = 0; Message.Empty(); if (!cmods.Adjust || pActionNode==NULL) TemplateID = SelectID; else { if (!pActionNode->IsSelected()) TemplateID = AddID; else TemplateID = RemoveID; } if (TemplateID==0) TemplateID = SelectID; if (pActionNode==NULL) *pStr += String_256(TemplateID); else { Message._MakeMsg( (TCHAR*) String_256(TemplateID), &pActionNode->Describe(FALSE) ); *pStr += Message; } return TRUE; }

BOOL SliceTool::Append (  String_256 *  pStr, String_256  String )  [protected]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 2372 of file slicetool.cpp. { // Append a message to the string, preceding it with a separator if there was something // already in the string... if (!pStr->IsEmpty()) *pStr += String_256(_R(IDS_SLICE_SEPARATOR)); *pStr += String; return TRUE; }

BOOL SliceTool::Append (  String_256 *  pStr, UINT32  StringID )  [protected]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 2344 of file slicetool.cpp. { // Append a message to the string, preceding it with a separator if there was something // already in the string... if (!pStr->IsEmpty()) *pStr += String_256(_R(IDS_SLICE_SEPARATOR)); *pStr += String_256(StringID); return TRUE; }

virtual BOOL SliceTool::AreToolBlobsRenderedOnSelection (   )  [inline, virtual]

Reimplemented from Tool_v1. Definition at line 156 of file slicetool.h. { return TRUE; }

SliceTool::CC_DECLARE_MEMDUMP (  SliceTool   )  [private]

BOOL SliceTool::CreateCursors (   )  [private]

Creates all the Slice tool cursors. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if all the Slice tool cursors have been successfully created See also: - Definition at line 542 of file slicetool.cpp. { // This tool has just been selected. Create its cursors. pcNormalSliceCursor = new Cursor(this, _R(IDC_POINTER_SLICE)); pcAdjustCursor = new Cursor(this, _R(IDC_POINTER_SLICE_ADJUST)); pcUnderCursor = new Cursor(this, _R(IDC_POINTER_SLICE_UNDER)); pcInsideCursor = new Cursor(this, _R(IDC_POINTER_SLICE_INSIDE)); pcUnderAdjustCursor = new Cursor(this, _R(IDC_POINTER_SLICE_UNDERADJUST)); pcInsideAdjustCursor= new Cursor(this, _R(IDC_POINTER_SLICE_INSIDEADJUST)); pcALLCursor = new Cursor(this, _R(IDCSR_SEL_GRADPOINT)); pcLeafCursor = new Cursor(this, _R(IDC_POINTER_SLICE_LEAF)); pcLeafAdjustCursor = new Cursor(this, _R(IDC_POINTER_SLICE_LEAFADJUST)); pcHorzGuideCursor = new Cursor(this, _R(IDCSR_SEL_HGUIDE)); pcVertGuideCursor = new Cursor(this, _R(IDCSR_SEL_VGUIDE)); // now check them... BOOL ok = (pcNormalSliceCursor != NULL && pcNormalSliceCursor->IsValid()); if (ok) ok = (pcAdjustCursor != NULL && pcAdjustCursor->IsValid()); if (ok) ok = (pcUnderCursor != NULL && pcUnderCursor->IsValid()); if (ok) ok = (pcInsideCursor != NULL && pcInsideCursor->IsValid()); if (ok) ok = (pcUnderAdjustCursor != NULL && pcUnderAdjustCursor->IsValid()); if (ok) ok = (pcInsideAdjustCursor != NULL && pcInsideAdjustCursor->IsValid()); if (ok) ok = (pcALLCursor != NULL && pcALLCursor->IsValid()); if (ok) ok = (pcLeafCursor != NULL && pcLeafCursor->IsValid()); if (ok) ok = (pcLeafAdjustCursor != NULL && pcLeafAdjustCursor->IsValid()); if (ok) ok = (pcHorzGuideCursor != NULL && pcHorzGuideCursor->IsValid()); if (ok) ok = (pcVertGuideCursor != NULL && pcVertGuideCursor->IsValid()); if (!ok) DestroyCursors(); return ok; }

SliceTool::ClickActionCode SliceTool::CycleClickAction (  NodeRenderableInk **  ppActionNode, NodeRenderableInk *  pClickCompoundNode, ClickActionCode  foundAction, ClickActionCode  cycleAction )  [protected]

Determine what action needs to be taken in response to a click. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com>, from Phil's SelectorTool code Date: 11/10/1999 Parameters: -  [INPUTS] pNodeToSelect  Pointer to pointer to node to select or NULL [OUTPUTS] Returns: ActionCode describing what the click should do Errors: - See also: SliceTool::DetermineClickAction Definition at line 2055 of file slicetool.cpp. { // If we have found a node then return the specified action code... if (*ppActionNode) { return foundAction; } // Else no suitable node so see whether the click occurred over a compound node else { // If click occurred over a compound node then we can return that // along with the alternative action code... if (pClickCompoundNode) { *ppActionNode = pClickCompoundNode; return cycleAction; } else // Else if there wasn't even a compound node we must return the information that // the click occurred over white space... { *ppActionNode = NULL; return CLICKACTION_SELNONE; } } }

void SliceTool::Describe (  void *  InfoPtr  )  [virtual]

Allows the tool manager to extract information about the tool. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 Parameters: InfoPtr  - A pointer to a tool info block. It is passed cast to void* as [INPUTS] the version of the tool is unknown at this point. Later versions of the Tool class may have more items in this block, that this tool will not use InfoPtr  - The structure pointed to by InfoPtr will have had all the info [OUTPUTS] that this version of the Tool knows about Reimplemented from Tool_v1. Definition at line 318 of file slicetool.cpp. { // Cast structure into the latest one we understand. ToolInfo_v1 *Info = (ToolInfo_v1 *) InfoPtr; Info->InfoVersion = 1; Info->InterfaceVersion = GetToolInterfaceVersion(); // You should always have this line. // These are all arbitrary at present. Info->Version = 1; Info->ID = GetID(); Info->TextID = _R(IDS_SLICE_TOOL); Info->Family = FamilyName; Info->Name = ToolName; Info->Purpose = Purpose; Info->Author = Author; Info->BubbleID = _R(IDBBL_SLICE_TOOLBOX); }

void SliceTool::DestroyCursors (   )  [private]

Destroys all the Slice tool cursors. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 589 of file slicetool.cpp. { if (pcNormalSliceCursor != NULL) delete pcNormalSliceCursor; if (pcAdjustCursor != NULL) delete pcAdjustCursor; if (pcUnderCursor != NULL) delete pcUnderCursor; if (pcInsideCursor != NULL) delete pcInsideCursor; if (pcUnderAdjustCursor != NULL) delete pcUnderAdjustCursor; if (pcInsideAdjustCursor != NULL) delete pcInsideAdjustCursor; if (pcALLCursor != NULL) delete pcALLCursor; if (pcLeafCursor != NULL) delete pcLeafCursor; if (pcLeafAdjustCursor != NULL) delete pcLeafAdjustCursor; if (pcHorzGuideCursor != NULL) delete pcHorzGuideCursor; if (pcVertGuideCursor != NULL) delete pcVertGuideCursor; }

SliceTool::ClickActionCode SliceTool::DetermineClickAction (  NodeRenderableInk **  ppActionNode, NodeRenderableInk *  pLastClickNode, NodeRenderableInk *  pClickSimpleNode, NodeRenderableInk *  pClickCompoundNode, Spread *  pStartSpread, DocCoord  ClickStart, ClickModifiers  ClickMods )  [protected]

Determine what action needs to be taken in response to a click. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com>, from Phil's SelectorTool code Date: 11/10/1999 Parameters: -  [INPUTS] pNodeToSelect  Pointer to pointer to node to select or NULL [OUTPUTS] Returns: ActionCode describing what the click should do Errors: - See also: SliceTool::HandleButtonUp Definition at line 1870 of file slicetool.cpp. { *ppActionNode = NULL; //-------------------------------------- // Test "leaf" modifier... if (IsSelectLeafClick(ClickMods)) { // Go directly to leaf nodes! if (pClickSimpleNode != pClickCompoundNode) { *ppActionNode = pClickSimpleNode; // <<<<< Inclusion by Mike 11/01/96 // this stuff is to check whether any parent is responding to // AllowSelectInside() and returning FALSE. Selections will not go down // into these objects if so. Node* pParentNode = pClickSimpleNode->FindParent(); while (pParentNode) { if (pParentNode->IsKindOf(CC_RUNTIME_CLASS(Layer))) break; if (pParentNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk))) { if ( (!pParentNode->AllowSelectInside()) && ((NodeRenderableInk*)pParentNode)->CanSelectAsCompoundParent() ) { *ppActionNode = (NodeRenderableInk*)(pParentNode); } } if (pParentNode==pClickCompoundNode) break; pParentNode = pParentNode->FindParent(); } // <<<<< End of inclusion } // If we still haven't found what we're looking for // Cycle round to the top again... return CycleClickAction(ppActionNode,pClickCompoundNode,CLICKACTION_SELLEAF,CLICKACTION_SELNODE); } //-------------------------------------- // Test "under" modifier... if (IsSelectUnderClick(ClickMods)) { // Try to perform a select under // First check that the context node is still under the pointer // If not then all we can do is a normal click operation... if (!ValidateLastClickUnder(pLastClickNode,pStartSpread,ClickStart)) return CycleClickAction(ppActionNode,pClickCompoundNode,CLICKACTION_SELUNDERFAIL2,CLICKACTION_SELUNDERFAIL2); // Find the leaf node at the click position, but only search nodes // before the last clicked node. *ppActionNode = NodeRenderableInk::FindSimpleAtPoint(pStartSpread,ClickStart,pLastClickNode); // Then find a compound node containing the leaf, preferably a sibling // of the last clicked node. *ppActionNode = NodeRenderableInk::FindCompoundFromSimple(*ppActionNode,pLastClickNode); // If the "under" node turns out to be the node we started from // return a failure code but go ahead and re-select it... // (If we failed to find anything under the last node, and the last node is the top node) if (*ppActionNode==NULL && pLastClickNode == pClickCompoundNode) return CycleClickAction(ppActionNode,pClickCompoundNode,CLICKACTION_SELUNDERFAIL,CLICKACTION_SELUNDERFAIL); // If we still haven't found what we're looking for // Cycle round to the top again... return CycleClickAction(ppActionNode,pClickCompoundNode,CLICKACTION_SELUNDER,CLICKACTION_SELUNDERCYCLE); } //-------------------------------------- // Test "member" modifier... if (IsSelectMemberClick(ClickMods)) { // See if the clicked simple node is a descendent of the last clicked node if (!ValidateLastClickInside(pLastClickNode,pClickSimpleNode)) return CycleClickAction(ppActionNode,pClickCompoundNode,CLICKACTION_SELINSIDEFAIL2,CLICKACTION_SELINSIDEFAIL2); // If the node we're going to look inside is not compound and it's the top node // return a failure code but go ahead and re-select it... if (pLastClickNode && !pLastClickNode->IsCompound() && pLastClickNode == pClickCompoundNode) return CycleClickAction(ppActionNode,pClickCompoundNode,CLICKACTION_SELINSIDEFAIL,CLICKACTION_SELINSIDEFAIL); // Try to perform a select inside *ppActionNode = NodeRenderableInk::FindInnerCompound(pClickSimpleNode,pLastClickNode); // If we still haven't found what we're looking for // Cycle round to the top again... return CycleClickAction(ppActionNode,pClickCompoundNode,CLICKACTION_SELINSIDE,CLICKACTION_SELINSIDECYCLE); } //-------------------------------------- // OK, so no modifiers are currently down // Just try to do a normal click action... return CycleClickAction(ppActionNode,pClickCompoundNode,CLICKACTION_NONE,CLICKACTION_SELNODE); }

void SliceTool::DisplayStatusBarHelp (  DocCoord  DocPos, Spread *  pSpread, ClickModifiers  ClickMods )  [private]

Displays status help string for the given position in the status bar. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/94 Parameters: DocPos  - the document coordinate of the point to display help on [INPUTS] pSpread - pointer to the spread containing DocPos ClickMods - the current click modifiers -  [OUTPUTS] Returns: - See also: SliceTool::GetCurrentStatusText Definition at line 1485 of file slicetool.cpp. { String_256 StatusMsg(""); // Get a string from the underlying help function and display it. GetCurrentStatusText(&StatusMsg, pSpread, DocPos, ClickMods); GetApplication()->UpdateStatusBarText(&StatusMsg); }

void SliceTool::DoDragBox (   )  [protected]

Runs a selector-tool drag-box operation. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/1999 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 1454 of file slicetool.cpp. { OpSliceDragBox* pOpDragBox = new OpSliceDragBox(); if (pOpDragBox == NULL) { InformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); } else { pOpDragBox->StartDragBox(StartSpread, ClickStart, ClickMods); } }

void SliceTool::DoTranslate (   )  [protected]

Runs a translation tranformation drag on the selection. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/1999 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 1393 of file slicetool.cpp. { // set appropriate transform parameters... TransformData tdParams; tdParams.CentreOfTrans = ClickStart; tdParams.LeaveCopy = FALSE; tdParams.LockAspect = TRUE; tdParams.pRange = NULL; tdParams.ScaleLines = FALSE; tdParams.StartBlob = 0; tdParams.TransFills = TRUE; // set drag pointer shape. if (CurrentCursorID != CURSORID_UNSET) CursorStack::GSetTop(pcALLCursor, CurrentCursorID); // attempt to create a translate op. OpSliceTranslate* pSliceTransOp = new OpSliceTranslate(); if (pSliceTransOp == NULL) { InformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK)); return; } // Get the current DocView (there must be one or we wouldn't be here). DocView* pDocView = DocView::GetCurrent(); ERROR3IF(pDocView == NULL, "SliceTool::DoTranslate- Null current DocView"); DocCoord dcOffset(0, 0); // Default to offsets of 0 // Fill a Transform Bounding Data structure up here BoundingData.x = SelectionRect.lo.x; BoundingData.y = SelectionRect.lo.y; BoundingData.Width = SelectionRect.Width(); BoundingData.Height = SelectionRect.Height(); BoundingData.XScale = (FIXED16) 1; BoundingData.YScale = (FIXED16) 1; BoundingData.Rotation = (ANGLE) 0; BoundingData.Shear = (ANGLE) 0; // Run the transformation drag operation and return success code. pSliceTransOp->DragStarted(&tdParams, this, &BoundingData, ClickStart, StartSpread, ClickMods, dcOffset, NULL, DRAGTYPE_AUTOSCROLL); }

BOOL SliceTool::DragFinished (  DragEndType  det  )  [protected, virtual]

Called by TransOperation when a drag is finished. Allows the SliceTool to reset its cursors and update its current selection information. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com>, from JustinF's SelectorTool::DragFinished Date: 14/10/1999 Parameters: det  a code indicating how the drag was ended, [INPUTS] eg. did the user hit ESCAPE and cancel it? [OUTPUTS]  Returns: TRUE if the drag operation should be allowed to complete, FALSE to signal that the drag should be cancelled. Errors: See also: Reimplemented from Tool_v1. Definition at line 2614 of file slicetool.cpp. { // update the current cursor. SetKeyDownCursor(ClickModifiers::GetClickModifiers()); // we always leave cancelling the drag to a capricious user. return TRUE; }

void SliceTool::FigureUserFeedback (  Spread *  pSpread, DocCoord  dcPos, ClickModifiers  cmods, BOOL  DoSlowTests, String_256 *  pStr, Cursor **  ppPointerShape )  [protected, virtual]

Definition at line 1587 of file slicetool.cpp. { // Initialise the status text string and pointer shape to be "null". pStr->Empty(); *ppPointerShape = pcNormalSliceCursor; if (Tool::GetCurrentID() != TOOLID_SLICETOOL) return; BOOL DescribeDrag = TRUE; //------------------------------------------------------------------------- // Set the pointer shape, according to the key modifiers and/or the current state. if (!cmods.Adjust && !cmods.Constrain && !cmods.Alternative1) { *ppPointerShape = pcNormalSliceCursor; Append(pStr,_R(IDS_SLICE_MODE0)); // "Normal select mode:" } else if (cmods.Adjust && !cmods.Constrain && !cmods.Alternative1) { *ppPointerShape = pcAdjustCursor; Append(pStr,_R(IDS_SLICE_MODE1)); // "Adjust select:" } else if (!cmods.Adjust && IsSelectUnderClick(cmods)) { *ppPointerShape = pcUnderCursor; Append(pStr,_R(IDS_SLICE_MODE2)); // "Select under:" } else if (cmods.Adjust && IsSelectUnderClick(cmods)) { *ppPointerShape = pcUnderAdjustCursor; Append(pStr,_R(IDS_SLICE_MODE3)); // "Adjust select under:" } else if (!cmods.Adjust && IsSelectMemberClick(cmods)) { *ppPointerShape = pcInsideCursor; Append(pStr,_R(IDS_SLICE_MODE4)); // "Force drag/Select member:" } else if (cmods.Adjust && IsSelectMemberClick(cmods)) { *ppPointerShape = pcInsideAdjustCursor; Append(pStr,_R(IDS_SLICE_MODE5)); // "Force drag/Adjust select member:" } else if (!cmods.Adjust && IsSelectLeafClick(cmods)) { *ppPointerShape = pcLeafCursor; Append(pStr,_R(IDS_SLICE_MODE6)); // "Select inside:" } else if (cmods.Adjust && IsSelectLeafClick(cmods)) { *ppPointerShape = pcLeafAdjustCursor; Append(pStr,_R(IDS_SLICE_MODE7)); // "Adjust select inside:" } else { ERROR3("SliceTool::FigureUserFeedback- out of range ClickModifiers"); return; } // Check for direct drag mode and say something about it... if (IsTranslateShortcut(cmods)) { if (SelectRange->FindFirst()) { *ppPointerShape = pcALLCursor; Append(pStr,_R(IDS_SLICEINSIDE4)); // "Drag to move the selected objects" } DescribeDrag = FALSE; } // See if there's a non-selectable object (guideline) under the mouse NodeRenderableInk* pPreProNode = FindPreProcessClickNode(pSpread,dcPos,TRUE); if (pPreProNode) { if (IS_A(pPreProNode,NodeGuideline)) { NodeGuideline* pGuideline = (NodeGuideline*)pPreProNode; if (pGuideline->GetType()==GUIDELINE_HORZ) { *ppPointerShape = pcHorzGuideCursor; // "Drag up or down to move guideline; Drag onto top ruler to delete it" Append(pStr,_R(IDS_SLICEHORZGUIDE)); return; } if (pGuideline->GetType()==GUIDELINE_VERT) { *ppPointerShape = pcVertGuideCursor; // "Drag left or right to move guideline; Drag onto left ruler to delete it" Append(pStr,_R(IDS_SLICEVERTGUIDE)); return; } } } //------------------------------------------------------------------------- // If we've got time to do the slow tests then go ahead and do them... if (DoSlowTests) { // Perform a hit-test at the mouse position and set the status bar text // accordingly. // Allow the hit-test to be interrupted if the mouse moves! Node* pInterruptedNode = NULL; NodeRenderableInk* pSimple = NodeRenderableInk::FindSimpleAtPoint(pSpread, dcPos, NULL, &pInterruptedNode); // If hit-test was interrupted then don't say anything about what's under the pointer! if (pInterruptedNode!=NULL) return; NodeRenderableInk* pCompound = NodeRenderableInk::FindCompoundFromSimple(pSimple); // if we changed the selection last, or the SelRange cannot provide a usable // last-selection then use our own record. otherwise, ask the SelRange. Node* pLastSelNode = NULL; if (m_bSliceToolSetSel && pLastClickNode != NULL) { pLastSelNode = pLastClickNode; } else { pLastSelNode = SelectRange->GetLastSelectedNode(); if ( pLastSelNode==NULL || !(pLastSelNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableInk))) ) pLastSelNode = pLastClickNode; } // Find out what we should do with the click... ClickActionCode action = CLICKACTION_NONE; NodeRenderableInk* pActionNode = NULL; action = DetermineClickAction(&pActionNode,(NodeRenderableInk*)pLastSelNode, pSimple,pCompound,pSpread,dcPos,cmods); // Act upon the information... switch (action) { //-------------------------------------------------// // No action required... case CLICKACTION_NONE: break; //-------------------------------------------------// // Anything that's selected must be deselected... case CLICKACTION_SELNONE: if (!cmods.Adjust) { // If there are selected objects append message about clearing. if (SelectRange && SelectRange->FindFirst()) Append(pStr,_R(IDS_SLICENONE1)); // "Click to clear the selection" // Message about marquee drag if (DescribeDrag) Append(pStr,_R(IDS_SLICENONE4)); // "Drag to marquee select objects" Append(pStr,_R(IDS_SLICENONE2)); // "Move pointer over object to select" } else { // Adjust is held down so describe marquee add. if (DescribeDrag) // "Drag to marquee select objects to add to selection" Append(pStr,_R(IDS_SLICENONE5)); // "Move pointer over object to add/remove from selection" Append(pStr,_R(IDS_SLICENONE3)); } break; //-------------------------------------------------// // The action node must be selected... case CLICKACTION_SELNODE: Append(pStr,cmods, _R(IDS_SLICENODE3), // "Click to select this #1%S alone; Drag to move it" _R(IDS_SLICENODE4), // "Click to select this #1%S" _R(IDS_SLICENODE5), // "Click to deselect this #1%S" pActionNode); break; case CLICKACTION_SELUNDER: Append(pStr,cmods, _R(IDS_SLICEUNDER1), // "Click to select the #1%S under the last selected object alone" _R(IDS_SLICEUNDER2), // "Click to select the #1%S under the last selected object" _R(IDS_SLICEUNDER3), // "Click to deselect the #1%S under the last selected object" pActionNode); break; case CLICKACTION_SELUNDERCYCLE: Append(pStr,cmods, _R(IDS_SLICEUNDERCYCLE1), // "Click to select the top #1%S alone; (Reached the bottom)" _R(IDS_SLICEUNDERCYCLE2), // "Click to select the top #1%S; (Reached the bottom)" _R(IDS_SLICEUNDERCYCLE3), // "Click to deselect the top #1%S; (Reached the bottom)" pActionNode); break; case CLICKACTION_SELUNDERFAIL: Append(pStr,cmods, _R(IDS_SLICEUNDERFAIL1), // "Click to select the #1%S alone; (Nothing under the last selected object)" _R(IDS_SLICEUNDERFAIL2), // "Click to select the #1%S; (Nothing under the last selected object)" _R(IDS_SLICEUNDERFAIL3), // "Click to deselect the #1%S; (Nothing under the last selected object)" pActionNode); break; case CLICKACTION_SELUNDERFAIL2: Append(pStr,cmods, _R(IDS_SLICEUNDERFAIL21), // "Click to select the #1%S alone; (The last selected object is not under the pointer)" _R(IDS_SLICEUNDERFAIL22), // "Click to select the #1%S; (The last selected object is not under the pointer)" _R(IDS_SLICEUNDERFAIL23), // "Click to deselect the #1%S; (The last selected object is not under the pointer)" pActionNode); break; case CLICKACTION_SELINSIDE: Append(pStr,cmods, _R(IDS_SLICEINSIDE1), // "Click to select the #1%S member of the last selected object alone" _R(IDS_SLICEINSIDE2), // "Click to select the #1%S member of the last selected object" _R(IDS_SLICEINSIDE3), // "Click to deselect the #1%S member of the last selected object" pActionNode); break; case CLICKACTION_SELINSIDECYCLE: Append(pStr,cmods, _R(IDS_SLICEINSIDECYCLE1), // "Click to select the top #1%S alone; (Reached the simplest object)" _R(IDS_SLICEINSIDECYCLE2), // "Click to select the top #1%S; (Reached the simplest object)" _R(IDS_SLICEINSIDECYCLE3), // "Click to deselect the top #1%S; (Reached the simplest object)" pActionNode); break; case CLICKACTION_SELINSIDEFAIL: Append(pStr, _R(IDS_SLICEINSIDEFAIL1)); // "Nothing inside this object" break; case CLICKACTION_SELINSIDEFAIL2: Append(pStr,cmods, _R(IDS_SLICEINSIDEFAIL21), // "Click to select the #1%S alone; (The pointer is not over a member of the last selected object)" _R(IDS_SLICEINSIDEFAIL22), // "Click to select the #1%S; (The pointer is not over a member of the last selected object)" _R(IDS_SLICEINSIDEFAIL23), // "Click to deselect the #1%S; (The pointer is not over a member of the last selected object)" pActionNode); break; case CLICKACTION_SELLEAF: Append(pStr,cmods, _R(IDS_SLICELEAF1), // "Click to select this #1%S alone" _R(IDS_SLICELEAF2), // "Click to select this #1%S" _R(IDS_SLICELEAF3), // "Click to deselect this #1%S" pActionNode); break; //-------------------------------------------------// default: ERROR3("Unknown Click action code!"); break; }; // If we're in normal click mode (no modifiers down) then remind the user // that they can use the modifer keys... if (!cmods.Adjust && !cmods.Constrain && !cmods.Alternative1) Append(pStr,_R(IDS_SELOPTIONS)); } }

NodeRenderableInk * SliceTool::FindFrom (  NodeRenderableInk *  pSimpleNode  )  const [protected]

Front-end short-hand for NodeRenderableInk::FindCompoundFromSimple. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 11/1/95 Parameters: pSimpleNode  the simple node to begin searching from [INPUTS] -  [OUTPUTS] Returns: The compound object the simple node is part of, if any, or pSimpleNode if it isn't. Errors: - See also: NodeRenderableInk::FindCompoundFromSimple Definition at line 2265 of file slicetool.cpp. { return NodeRenderableInk::FindCompoundFromSimple(pSimpleNode); }

NodeRenderableInk * SliceTool::FindPreProcessClickNode (  Spread *  pSpread, DocCoord  ClickPos, BOOL  bInterruptible = FALSE )  [protected, virtual]

Currently, only looks for NodeGuidelines. Returns: Errors: See also: SliceTool::PreProcessClick() Definition at line 720 of file slicetool.cpp. { ERROR2IF(pSpread == NULL, NULL, "SliceTool::FindPreProcessClickNode- pSpread is NULL"); // initialise vars. NodeRenderableInk* pFoundNode = NULL; BOOL bFound = FALSE; // look for a visible, editable guides layer. Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL && !bFound) { if (pLayer->IsGuide() && !pLayer->IsLocked() && pLayer->IsVisible()) { // We have a layer that's also a guide layer // Now look for the guidelines in this layer Node* pNodeInLayer = pLayer->FindFirstChild(CC_RUNTIME_CLASS(NodeGuideline)); while (pNodeInLayer != NULL && !bFound) { pFoundNode = (NodeGuideline*)pNodeInLayer; // found a node - now hit-test its bounds. DocRect Rect = pFoundNode->GetBoundingRect(FALSE,TRUE); bFound = (Rect.ContainsCoord(ClickPos)); pNodeInLayer = pNodeInLayer->FindNext(CC_RUNTIME_CLASS(NodeGuideline)); } } pLayer = pLayer->FindNextLayer(); } if (bFound) { // OK, we have found a node interested in a preprocess click // We now have to ensure that it's not being obscured visually by another node NodeRenderableInk* pNode = NULL; if (bInterruptible) { // Allow the hit-test to be interrupted if the mouse moves! Node* pInterruptedNode = NULL; pNode = NodeRenderableInk::FindSimpleAtPoint( pSpread, ClickPos, NULL, &pInterruptedNode); // If hit-test was interrupted then don't say anything about what's under the pointer! if (pInterruptedNode!=NULL) return NULL; } else { // Can't be interrupted by mouse movement so just go for it... pNode = NodeRenderableInk::FindSimpleAtPoint(pSpread,ClickPos); } if (pNode) { // Find out whether the hit node is in front of the guideline or not. // If it is, then clear the Found flag. Layer* pLowerLayer = (Layer*) pFoundNode->FindParent(CC_RUNTIME_CLASS(Layer)); // The guideline layer Layer* pNodeLayer = (Layer*) pNode->FindParent(CC_RUNTIME_CLASS(Layer)); // The layer containing the node // Make sure GuideLayer comes after NodeLayer do { pLowerLayer = pLowerLayer->FindNextLayer(); // Find the layer above the last one tested } while (pLowerLayer && pLowerLayer!=pNodeLayer); // Keep going while there is a layer // and that layer isn't the one we're looking for // Get here when either we've run out of layers or we've found the layer we want if (pLowerLayer && pLowerLayer==pNodeLayer) // If found layer above guide layer bFound=FALSE; // Then flag that the guideline is obscured } } if (!bFound) pFoundNode = NULL; return pFoundNode; }

void SliceTool::GetCurrentStatusText (  String_256 *  ptext, Spread *  pSpread, DocCoord  DocPos, ClickModifiers  ClickMods )  [private]

Selects a suitable string for the status line based on the current location (as input via the parameters). Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/94 Parameters: pSpread  points to a spread [INPUTS] DocPos points to a point in a document ClickMods are the current click modifiers Updates  the string in ptext [OUTPUTS] Returns: - See also: SliceTool::GetStatusLineText, SliceTool::DisplayStatusBarHelp Definition at line 1548 of file slicetool.cpp. { // You must use the Spread, DocCoord and ClickModifiers to select a suitable string to be // displaied in the status bar. This is usually done via some sort of switch statement. // Having selected a suitable string you should do a statement like // ptext->Load(<#Insert your string ID here #>); // Delete this line when you display useful strings! ptext->Empty(); }

virtual UINT32 SliceTool::GetID (  void   )  [inline, virtual]

Reimplemented from Tool_v1. Definition at line 147 of file slicetool.h. { return TOOLID_SLICETOOL; };

static SliceInfoBarOp* SliceTool::GetSliceInfoBarOp (   )  [inline, static]

Definition at line 170 of file slicetool.h. { return pSliceInfoBarOp; }

BOOL SliceTool::GetStatusLineText (  String_256 *  ptext, Spread *  pSpread, DocCoord  DocPos, ClickModifiers  ClickMods )  [virtual]

Figure out what the status text for the SliceTool is at the given position on the given spread with the given click modifiers. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com>, from Phil's code for SelectorTool. Date: 11/10/1999 Parameters: ptext  Pointer to text string to fill in [INPUTS] pSpread Pointer to spread containing mouse position DocPos Mouse position within spread ClickMods Click modifiers -  [OUTPUTS] Returns: TRUE always, indicating that the string was updated. Errors: ERROR2 if pText is NULL. See also: Reimplemented from Tool_v1. Definition at line 1515 of file slicetool.cpp. { ERROR2IF(ptext==NULL,FALSE,"ptext is NULL!"); Cursor* pcDummy; // Dummy to hold unused pointer shape computed by FigureUserFeedback FigureUserFeedback(pSpread, DocPos, ClickMods, TRUE, ptext, &pcDummy); if (CurrentCursorID != CURSORID_UNSET) CursorStack::GSetTop(pcDummy,CurrentCursorID); return TRUE; }

void SliceTool::HandleButtonUp (   )  [protected, virtual]

Mouse button-up event handler. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com>, from JustinF's SelectorTool::HandleButtonUp code Date: 08/10/1999 Returns: Errors: See also: Definition at line 1039 of file slicetool.cpp. { // if we changed the selection last, or the SelRange cannot provide a usable // last-selection then use our own record. otherwise, ask the SelRange. Node* pLastSelNode = NULL; if (m_bSliceToolSetSel && pLastClickNode != NULL) { pLastSelNode = pLastClickNode; } else { pLastSelNode = SelectRange->GetLastSelectedNode(); if ( pLastSelNode == NULL || !pLastSelNode->IsAnObject() ) pLastSelNode = pLastClickNode; } // Find out what we should do with the click... ClickActionCode action = CLICKACTION_NONE; NodeRenderableInk* pActionNode = NULL; action = DetermineClickAction( &pActionNode, (NodeRenderableInk*)pLastSelNode, pClickSimpleNode, pClickCompoundNode, StartSpread, ClickStart, ClickMods ); // Act upon the information... switch (action) { //-------------------------------------------------// // No action required... case CLICKACTION_NONE: break; //-------------------------------------------------// // Anything that's selected must be deselected... case CLICKACTION_SELNONE: { // Don't clear selection if was an adjust click // (Change requested by Charles and Alan Burns) if (!ClickMods.Adjust) { // Markn 29/9/95: We ignore this if the click happened on a guideline. // If another type of node needs to behave like this, then a virt func in node // will be required instead of the hideous IS_A() clause in the 'if' statement if (pPreProcClickNode == NULL || !IS_A(pPreProcClickNode,NodeGuideline)) { NodeRenderableInk::DeselectAll(TRUE, TRUE); pLastClickNode = NULL; } } break; } //-------------------------------------------------// // The action node must be selected or toggled... case CLICKACTION_SELNODE: case CLICKACTION_SELUNDER: case CLICKACTION_SELUNDERCYCLE: case CLICKACTION_SELUNDERFAIL: case CLICKACTION_SELUNDERFAIL2: case CLICKACTION_SELINSIDE: case CLICKACTION_SELINSIDECYCLE: case CLICKACTION_SELINSIDEFAIL: case CLICKACTION_SELINSIDEFAIL2: case CLICKACTION_SELLEAF: { ERROR3IF(pActionNode == NULL, "Action and ActionNode don't agree!"); // if we aren't Adjust'ing, ensure no previous selection. if (!ClickMods.Adjust) NodeRenderableInk::DeselectAll(TRUE, FALSE); // try to select all nodes sharing the same name as the clicked node. String_256 SetName; SetName.Empty(); SliceHelper::SelectAllSetsOfThisNode(pActionNode, SetName, ClickMods.Adjust); // if the clicked node has no name then the above code will do nothing, // so we need to do a normal select, accounting for Adjust. if (SetName.IsEmpty()) { if (ClickMods.Adjust) { // If Adjust is applied, toggle the state of the action node. if (pActionNode->IsSelected()) pActionNode->DeSelect(TRUE); else pActionNode->Select(TRUE); } else { pActionNode->Select(TRUE); } // force a broadcast of the changed selection state, so our info-bar updates. SelectRange->Update(TRUE); } // update our record of the last clicked node. pLastClickNode = pActionNode; // make a note that we changed the selection. m_bSliceToolSetSel = TRUE; break; } //-------------------------------------------------// default: ERROR3("Unknown Click action code!"); break; }; // switch (action) // Make sure the cursor reflects which keys are down, now that the mouse button has // been released. SetKeyDownCursor(ClickModifiers::GetClickModifiers()); }

void SliceTool::HandleDoubleClick (   )  [protected, virtual]

Double mouse-click event handler. Currently, passes the event to HandleSingleClick(). Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08/10/1999 Returns: Errors: See also: Definition at line 912 of file slicetool.cpp. { HandleSingleClick(); }

void SliceTool::HandleDragClick (   )  [protected, virtual]

Mouse-drag event handler. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08/10/1999 Returns: Errors: See also: Definition at line 930 of file slicetool.cpp. { // check for a forced translate, and perform a translate // operation if appropriate. if (IsTranslateShortcut(ClickMods)) { if (SelectionSpread != NULL) { // There is a selection, so start a translate drag... DoTranslate(); } return; } // Right, we clicked on either an object (possibly already selected) or // blank paper. First, check if there is an object at the click position. if (pClickCompoundNode == NULL) { // There is only blank paper at the click point, so assume the user is // trying to start a marquee selection drag. Run the drag-box operation. DoDragBox(); return; } // Is the clicked object already selected? Note that the user may be trying to click on // a simple object selected inside a group that itself is not selected, so we must be // careful to check the state of the right nodes here. // // The logic here is: // If the clicked simple node or any of it's parents are selected // Then DON'T alter the selection to reflect the clicked object! // BOOL SimpleInSelected = FALSE; // So far haven't encountered any selected nodes Node* pNode = pClickSimpleNode; // Make a working pointer and initialise it do { if (pNode->IsSelected()) // If the working node is selected { SimpleInSelected = TRUE; // Then the simple node or one of its parents are break; // selected so we don't need to change the selection! } pNode = pNode->FindParent(); // Else check the working node's parent } while (pNode != pClickCompoundNode->FindParent());// until we've reached the compound node's parent // (Allows the compound node itself to be checked) if (!SimpleInSelected) { // No. If the click was with the left button we must deselect all other objects. // If the clicked object isn't selected, we can't run a transform on it. Hence we must // select it, but we prevent it being redrawn as selected (with its little blobs). if (!ClickMods.Adjust) { // Normal click, so deselect everything before we select the clicked node... NodeRenderableInk::DeselectAll(TRUE, FALSE); } else { // We clicked with the right button, but if the click was in a different spread to // the selection we have to deselect everything anyway. Node* pNode = SelectRange->FindFirst(); if (pNode != NULL && pNode->FindParentSpread() != SelectionSpread) { // Clicked node in a different spread from previous selection, so clear selection NodeRenderableInk::DeselectAll(TRUE, FALSE); } } // Now that the selection state of all other objects is dealt with, make sure the // clicked object, as well as objects sharing its name, is selected. // // Currently, SelectAllSetsOfThisNode indirectly does a SelectRange->Update(TRUE). String_256 SetName; SetName.Empty(); SliceHelper::SelectAllSetsOfThisNode(pClickCompoundNode, SetName, FALSE); if (SetName.IsEmpty()) { pClickCompoundNode->Select(TRUE); // force a broadcast of the changed selection, so that our info-bar is informed. SelectRange->Update(TRUE); } } // Finally, run a transform on the selected object(s). Of course, the user may not be // trying to drag the selection - if so the button will come up before a significant // drag has occurred and we can take it from there. MakeSelectionValidForDrag(); // do the drag. DoTranslate(); // remember that _we_ changed the selection. m_bSliceToolSetSel = TRUE; }

void SliceTool::HandleSingleClick (   )  [protected, virtual]

Single mouse-click event handler. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08/10/1999 Returns: Errors: See also: Definition at line 887 of file slicetool.cpp. { // work out what modifiers apply to this click. SetKeyDownCursor(ClickMods); // Find out which object, if any, was clicked on. We hit-detect both the simple node // that was clicked and any top-level compound object it may be part of. pClickSimpleNode = NodeRenderableInk::FindSimpleAtPoint(StartSpread, ClickStart); pClickCompoundNode = NodeRenderableInk::FindCompoundFromSimple(pClickSimpleNode); }

void SliceTool::HandleTabKey (  BOOL  bIsShifted  )  [protected, virtual]

Tab keypress event handler. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08/10/1999 Returns: Errors: See also: Definition at line 1232 of file slicetool.cpp. { }

BOOL SliceTool::Init (  void   )  [virtual]

Used to check if the Tool was properly constructed. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 Returns: FALSE if it does not want to be created, TRUE otherwise See also: SliceTool::SliceTool Reimplemented from Tool_v1. Definition at line 257 of file slicetool.cpp. { // declare all ops used by SliceTool. BOOL ok = OpSliceDragBox::Declare(); if (ok) ok = OpSliceTranslate::Declare(); ERROR2IF(!ok, FALSE, "Couldn't Declare all Ops in SliceTool::Init."); // This section reads in the infobar definition and creates an instance of // SliceInfoBarOp. Also pSliceInfoBarOp, the ptr to the tool's infobar, is set up // after the infobar is successfully read and created. if (ok) { CCResTextFile file; // Resource File SliceInfoBarOpCreate BarCreate; // Object that creates SliceInfoBarOp objects ok = file.open(_R(IDM_SLICE_BAR), _R(IDT_INFO_BAR_RES)); // Open resource if (ok) ok = DialogBarOp::ReadBarsFromFile(file,BarCreate); // Read and create info bar if (ok) file.close(); // Close resource ENSURE(ok,"Unable to load Slicebar.ini from resource\n"); if (ok) { // Info bar now exists. Now get a pointer to it String_32 str = String_32(_R(IDS_SLICETOOL_INFOBARNAME)); DialogBarOp* pDialogBarOp = DialogBarOp::FindDialogBarOp(str); ok = (pDialogBarOp != NULL); if (ok) ok = pDialogBarOp->IsKindOf(CC_RUNTIME_CLASS(SliceInfoBarOp)); if (ok) pSliceInfoBarOp = (SliceInfoBarOp*)pDialogBarOp; ENSURE(ok,"Error finding the Slice tool info bar"); } } // Get a permanent pointer to the application's SelRange object. SelectRange = GetApplication()->FindSelection(); // init the global var with the first bar name to create - ie Bar1 g_BarName.MakeMsg(_R(IDS_BARNAME), 1); return (ok); }

BOOL SliceTool::IsClickModified (  ClickModifiers  cmods  )  const [protected]

Tests whether any of the modifiers, eg. Constrain, Adjust etc, apply to the current mouse click (as received by the OnClick function). Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 29/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the current click is "modified". Errors: - See also: SliceTool::HandleSingleClick Definition at line 2171 of file slicetool.cpp. { return cmods.Adjust || cmods.Constrain || cmods.Alternative1 || cmods.Menu; }

static BOOL SliceTool::IsCurrentTool (   )  [inline, static]

Definition at line 171 of file slicetool.h. { return CurrentTool; }

BOOL SliceTool::IsSelectLeafClick (  ClickModifiers  cmods  )  const [protected]

Reports whether the current mouse click meant the user wanted to "select- leaf" or not. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the last click indicated "select-leaf". Errors: - See also: SliceTool::HandleButtonUp Definition at line 2242 of file slicetool.cpp. { return (cmods.Constrain && !cmods.Alternative1); }

BOOL SliceTool::IsSelectMemberClick (  ClickModifiers  cmods  )  const [protected]

Reports whether the current mouse click meant the user wanted to "select- inside" or not. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the last click indicated "select-inside". Errors: - See also: SliceTool::HandleButtonUp Definition at line 2219 of file slicetool.cpp. { return (cmods.Constrain && cmods.Alternative1); }

BOOL SliceTool::IsSelectUnderClick (  ClickModifiers  cmods  )  const [protected]

Decides whether the current click is modified to be an "under" click or not. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 14/10/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the current click signifies the object below the clicked object should be selected, FALSE otherwise. Errors: - See also: SliceTool::HandleSingleClick Definition at line 2195 of file slicetool.cpp. { return (!cmods.Constrain && cmods.Alternative1); }

BOOL SliceTool::IsTranslateShortcut (  ClickModifiers  cmods  )  const [protected]

Detects whether the current mouse click modifiers denote the translate drag operation shortcut. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 5/10/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the translate shortcut keys are detected. Errors: - See also: - Definition at line 2147 of file slicetool.cpp. { return cmods.Constrain && cmods.Alternative1; }

void SliceTool::MakeSelectionValidForDrag (   )  [protected]

Runs through the selected nodes, making sure they are all happy with being dragged. Checks are:- 1. Sub-Selected text characters are deselected, and their parent story (and all other nodes sharing its name) are selected instead. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 3/5/95 Parameters: -  [INPUTS] Can  change the current selection, causing an immediate SelChanged message [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1329 of file slicetool.cpp. { SelRange *pSelection = GetApplication()->FindSelection(); RangeControl rg = pSelection->GetRangeControlFlags(); rg.IgnoreInvisibleLayers = TRUE; // oddly setting this to TRUE actually means DO INCLUDE INIVISIBLE LAYERS in the range!!! RangeControl rcOld = rg; rg.PromoteToParent = TRUE; pSelection->Range::SetRangeControl(rg); Node* pNode = pSelection->FindFirst(); BOOL ChangedSelection = FALSE; while (pNode != NULL) { // Push any text sub-selection up to the selected story, and make sure // that any other Nodes sharing the text-story's name are also selected. if (pNode->IsAnAbstractTextChar()) { ((NodeRenderableInk*)pNode)->DeSelect(TRUE); TextStory* pStory = (TextStory*)pNode->FindParent(CC_RUNTIME_CLASS(TextStory)); if (pStory != NULL) { String_256 SetName; SetName.Empty(); SliceHelper::SelectAllSetsOfThisNode(pStory, SetName, FALSE); if (SetName.IsEmpty()) pStory->Select(TRUE); ChangedSelection = TRUE; } } pNode = pSelection->FindNext(pNode); } // if we needed to change the selection, tell everyone. if (ChangedSelection) { // this call commented out, as I don't think it is required. pushing the selection // up to the letter's text-story in this way does not actually change the overall // state of the selection wrt named sets, as the story shares the same set name as // the character (always?). - Karim 25/10/1999 // GetApplication()->FindSelection()->Update(TRUE); // is this call actually m_bSliceToolSetSel = TRUE; } pSelection->Range::SetRangeControl(rcOld); }

void SliceTool::OnClick (  DocCoord  PointerPos, ClickType  Click, ClickModifiers  ClickMods, Spread *  pSpread )  [virtual]

To handle a Mouse Click event for the Slice Tool. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 Parameters: PointerPos  - The DocCoord of the point where the mouse button was clicked [INPUTS] Click - Describes the type of click that was detected. ClickMods - Indicates which buttons caused the click and which modifers were pressed at the same time pSpread - The spread in which the click happened Returns: - See also: Tool::MouseClick; ClickType; ClickModifiers Reimplemented from DragTool. Definition at line 622 of file slicetool.cpp. { // we ignore any clicks with the Menu mouse button. if (ClickMods.Menu) return; // remember the mouse position, in case we're starting a drag. if (Click == CLICKTYPE_SINGLE) { ClickStart = PointerPos; StartSpread = pSpread; } // remember the click modifiers for later use in the click-processing code. this->ClickMods = ClickMods; TypeOfClick = Click; // update our spread and bounds info about the selection. UpdateSelectionInfo(); // refresh our ptr to the app's selection, for use in the click-processing code. SelectRange = GetApplication()->FindSelection(); RangeControl rc = SelectRange->GetRangeControlFlags(); rc.IgnoreInvisibleLayers = TRUE; SelectRange->Range::SetRangeControl(rc); // we process clicks in three stages, stopping as soon as // a stage successfully processes the click. // this function checks for and lets us drag guidelines. if (!PreProcessClick()) { // this function is a carry-over from the Selector tool code. // it currently does nothing. if (!ProcessObjectClick()) { // this function deals with normal mouse-click handling. PostProcessClick(); } } }

BOOL SliceTool::OnKeyPress (  KeyPress *  pKeyPress  )  [virtual]

key-press event handler. Catch CTRL/ALT/SHIFT modifiers and change the status-line/cursor appropriately. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08/10/1999 Parameters: pKeyPress  pointer to a key-press object. [INPUTS] [OUTPUTS]  Returns: Errors: See also: Reimplemented from Tool_v1. Definition at line 1171 of file slicetool.cpp. { // Find the current state of the "click" keyboard modifiers... ClickMods = ClickModifiers::GetClickModifiers(); switch (pKeyPress->GetVirtKey()) { case CAMKEY(CC_MOD_ADJUST): // bit 0 of fKeyStates (SHIFT) case CAMKEY(CC_MOD_ALTERNATIVE): // bit 1 of fKeyStates (ALT) case CAMKEY(CC_MOD_CONSTRAIN): // bit 2 of fKeyStates (CONTROL) // apparently, this is a bodge for speed. // see SelectorTool::OnKeyPress for details :-) break; case CAMKEY(TAB): // moves selection to next rendered node if (pKeyPress->IsPress()) HandleTabKey(ClickMods.Adjust); break; case CAMKEY(HOME): // select first object in render order if (pKeyPress->IsPress()) { if (SelectionSpread != NULL) NodeRenderableInk::DeselectAll(); HandleTabKey(FALSE); } break; case CAMKEY(END): // select last object in render order if (pKeyPress->IsPress()) { if (SelectionSpread != NULL) NodeRenderableInk::DeselectAll(); HandleTabKey(TRUE); } break; default: // not interested in processing this return FALSE; } // If we processed a click modifier then update the cursor and return that we processed // the keystroke. SetKeyDownCursor(ClickMods); // Yes, we processed this key-event. return TRUE; }

void SliceTool::OnMouseMove (  DocCoord  PointerPos, Spread *  pSpread, ClickModifiers  ClickMods )  [virtual]

To handle a Mouse Move event for the Slice Tool. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 Parameters: PointerPos  - The DocCoord of the point where the mouse has moved to [INPUTS] pSpread - The spread in which the move occurred ClickMods - The state of the various modifiers at the time of the mouse move Returns: TRUE if it handled the Click, FALSE otherwise See also: Tool::MouseClick; ClickType; ClickModifiers Reimplemented from Tool_v1. Definition at line 1291 of file slicetool.cpp. { // Display status bar text for the current position // DisplayStatusBarHelp(PointerPos, pSpread, ClickMods); // If there isn't any selection, or it's in a different spread, then do nothing. if (SelectionSpread == NULL || SelectionSpread != pSpread) return; String_256 str; Cursor* pcPointerShape; FigureUserFeedback(pSpread, PointerPos, ClickMods, FALSE, &str, &pcPointerShape); if (!(str.IsEmpty())) SetStatusText(&str); if (CurrentCursorID != CURSORID_UNSET) CursorStack::GSetTop(pcPointerShape, CurrentCursorID); }

void SliceTool::PostProcessClick (   )  [protected, virtual]

Provided a click wasn't eaten by a pre- or mid- processor, we deal with it here. This passes the event on to specific handler routines, depending on its type (TypeOfClick):. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08/10/1999 Parameters: [INPUTS]  [OUTPUTS]  Returns: CLICKTYPE_SINGLE HandleSingleClick CLICKTYPE_DOUBLE HandleDoubleClick CLICKTYPE_DRAG HandleDragClick CLICKTYPE_UP HandleButtonUp Returns: Errors: See also: Definition at line 848 of file slicetool.cpp. { switch (TypeOfClick) { case CLICKTYPE_SINGLE: HandleSingleClick(); break; case CLICKTYPE_DOUBLE: HandleDoubleClick(); break; case CLICKTYPE_DRAG: HandleDragClick(); break; case CLICKTYPE_UP: HandleButtonUp(); break; default: // unrecognised click-type - do nothing. break; } }

BOOL SliceTool::PreProcessClick (   )  [protected, virtual]

Allows a click to be handled before going through the main click-handling code. This function checks for a clicked Node, and allows it to respond to the click. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08/10/1999 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if the mouse event was handled here, FALSE otherwise. Errors: See also: SliceTool::OnClick Definition at line 685 of file slicetool.cpp. { // look for a Node which may be interested in this click, and allow it to respond. pPreProcClickNode = FindPreProcessClickNode(StartSpread, ClickStart); if (pPreProcClickNode != NULL) if (pPreProcClickNode->OnClick(ClickStart, TypeOfClick, ClickMods, StartSpread)) return TRUE; // no preprocess node, or it didn't want the click. return FALSE; }

BOOL SliceTool::ProcessObjectClick (   )  [protected, virtual]

In the selector tool, this function OnClick()'s each object in the tool's range if the Selector tool is using Object blobs. We don't, so we won't. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08/10/1999 Parameters: [INPUTS]  [OUTPUTS]  Returns: FALSE always. Errors: See also: SelectorTool::ProcessObjectClick Definition at line 820 of file slicetool.cpp. { return FALSE; }

void SliceTool::RenderToolBlobs (  Spread *  pSpread, DocRect *  pClipRect )  [virtual]

Render the SliceTool's tool blob. This consists of a bounding rect identical to that used when dragging the selection (dotted, red line), around whatever is currently selected. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06/07/2000 Parameters: pSpread  the spread to render blobs for - must == this->SelectionSpread. [INPUTS] pClipRect the rect to clip to - used to prevent unnecessary drawing. See also: SLICETOOL_BLOBS define at the top of this file to turn this off. Reimplemented from Tool_v1. Definition at line 2464 of file slicetool.cpp. { #ifdef SLICETOOL_BLOBS // don't bother if there's no selection spread or if we're asked to render for // a spread which isn't the selection spread. if ( SelectionSpread == NULL || pSpread != SelectionSpread ) { return; } // get the selected DocView - if we can't get it, then leave now. DocView* pView = DocView::GetSelected(); if (pView == NULL) return; // sorry, this isn't the neatest programming. // The size of the SliceTool blob bitmap is about 10 pixels square. // The desired distance between blob and selection is 2 pixels. INT32 BlobGap = (INT32)(2 * pView->GetScaledPixelWidth().MakeDouble()); INT32 BlobRadius = (INT32)(10 * pView->GetScaledPixelWidth().MakeDouble()); BlobRadius /= 2; // the absolute position of the blob - just left and below the top of the selection rect. DocCoord dcBlobPos( m_drBlobRect.hix + (BlobGap + BlobRadius), m_drBlobRect.hiy - (BlobGap + BlobRadius) ); // render the blobs for all appropriate render regions. RenderRegion* pRegion = DocView::RenderOnTop(pClipRect, pSpread, ClippedEOR); while (pRegion != NULL) { pRegion->SaveContext(); // draw a bounding box around the selection. pRegion->SetLineColour(COLOUR_XORSELECT); pRegion->DrawDragBounds(&m_drBlobRect); // draw a little named-set bitmap to denote what sets are selected. switch (m_SetSelectionState) { case FullSetsSelected: pRegion->DrawBitmapBlob(dcBlobPos, _R(IDBMP_SLICE_SELALL)); break; case HalfSetsSelected: pRegion->DrawBitmapBlob(dcBlobPos, _R(IDBMP_SLICE_SELSOME)); break; case NoSetsSelected: pRegion->DrawBitmapBlob(dcBlobPos, _R(IDBMP_SLICE_SELNONE)); break; default: ERROR3("SliceTool::RenderToolBlobs; unrecognised set-selection state!"); break; } pRegion->RestoreContext(); // Go on to the next render region, if any. pRegion = DocView::GetNextOnTop(pClipRect); } #endif }

void SliceTool::SelectChange (  BOOL  isSelected  )  [virtual]

Starts up and closes down the Slice tool. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/94 Parameters: isSelected  - TRUE = tool has been selected [INPUTS] FALSE = tool has been deselected -  [OUTPUTS] Returns: - Errors: Debug warning if creating the cursor fails. See also: - Reimplemented from Tool_v1. Definition at line 356 of file slicetool.cpp. { if (isSelected) { // create the tool's cursors and push the default one onto the stack. if (!CreateCursors()) return; CurrentCursorID = CursorStack::GPush(pcNormalSliceCursor, FALSE); pcCurrentCursor = pcNormalSliceCursor; // This tool is now the current one. CurrentTool = TRUE; // Create and display the tool's info bar. if (pSliceInfoBarOp->Create()) pSliceInfoBarOp->SetSliceTool(this); // register the Slice tool's blob preference with the app. BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr != NULL) { // we only use Tiny blobs. BlobStyle bsBlobs; bsBlobs.Tiny = TRUE; pBlobMgr->ToolInterest(bsBlobs); } // make a note that we mustn't ignore any selection-changed messages. m_fIgnoreSelChange = FALSE; // Update our info on the selection, and if necessary, render our tool blobs on. if (UpdateSelectionInfo()) pBlobMgr->RenderToolBlobsOn(this, SelectionSpread, NULL); } else { // destroy the tool's cursors, if they exist. if (pcCurrentCursor != NULL) { CursorStack::GPop(CurrentCursorID); pcCurrentCursor = NULL; CurrentCursorID = 0; } DestroyCursors(); // remove the info-bar's slice-tool pointer. pSliceInfoBarOp->SetSliceTool(NULL); // Remove the info bar from view by deleting the actual underlying window pSliceInfoBarOp->m_InfoBarCreated = FALSE; pSliceInfoBarOp->Delete(); // ensure any tool object blobs are removed. BlobManager* BlobMgr = GetApplication()->GetBlobManager(); if (BlobMgr != NULL) { BlobStyle bsRemoves; bsRemoves.ToolObject = TRUE; BlobMgr->RemoveInterest(bsRemoves); } // No longer the current tool CurrentTool = FALSE; // Ensure our tool blobs have been rendered off the selected spread. BlobMgr->RenderToolBlobsOff(this, SelectionSpread, NULL); } }

void SliceTool::SelectionHasChanged (  void   )  [virtual]

A public function, for other people to call whenever they need to let the Slice tool know that the selection has changed. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 19/10/1999 Allows the Slice tool to update its private information about the selection. Returns: Errors: See also: UpdateSelectionInfo(); Definition at line 440 of file slicetool.cpp. { // we sometimes ignore selection-changed messages, so that we don't get our tool-blobs // in a tizzy. if (m_fIgnoreSelChange) return; BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr==NULL) return; // ok, remove any of our previous tool blobs. pBlobMgr->RenderToolBlobsOff(this, SelectionSpread, NULL); // reset our set-sel flag, to indicate that we did not change the selection. // this flag needs to be cleared whenever the selection changes, in order to // keep a record of whether we changed the selection. whenever we update the // selection from within SliceTool, we must set this flag manually *after* we // tell everyone that the selection changed. m_bSliceToolSetSel = FALSE; // update the Slice tool's selection information, // and if necessary then render our tool blobs on. if (UpdateSelectionInfo()) pBlobMgr->RenderToolBlobsOn(this, SelectionSpread, NULL); }

void SliceTool::SetKeyDownCursor (  ClickModifiers  cmMods  )  [protected, virtual]

Decodes the bit-field fKeyStates, indicating which combination of modifier keys are down, and sets the cursor appropriately. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08/10/1999 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 1253 of file slicetool.cpp. { // Get current position information for call to change pointer shape... Spread* pSpread; DocCoord dcMousePos; if (DocView::GetCurrentMousePos(&pSpread, &dcMousePos) && Tool::GetCurrentID() == TOOLID_SLICETOOL && !BaseBar::IsDragging()) { // Call nice central routine to figure out what pointer shape to show... // (Set the status bar text while we're at it.) String_256 Str; Cursor* pPtr; FigureUserFeedback(pSpread, dcMousePos, cmMods, TRUE, &Str, &pPtr); if (CurrentCursorID != CURSORID_UNSET) CursorStack::GSetTop(pPtr, CurrentCursorID); if (!(Str.IsEmpty())) SetStatusText( &Str ); } }

void SliceTool::SetStatusText (  String_256 *  pStr  )  [static, protected]

Sets the status bar text to the given string. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/94 Parameters: pStr  pointer to the string to display [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 2101 of file slicetool.cpp. { GetApplication()->UpdateStatusBarText(pStr); }

void SliceTool::SetStatusText (  UINT32  nStringID  )  [static, protected]

Sets the status bar text to the given string. Alternative to loading the string yourself and calling the other SetStatusText function. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 12/10/94 Parameters: nStringID  the numeric identifier of the string resource [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 2123 of file slicetool.cpp. { String_256 str(nStringID); SetStatusText(&str); }

BOOL SliceTool::UpdateSelectionInfo (   )  [protected, virtual]

Updates the slice tool's record of the spread and bounding rectangle of the current selection. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com>, from JustinF's SelectorTool::UpdateSelectionInfo() code. Date: 14/10/1999 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if there is a current selection, FALSE if no object is selected. Errors: See also: SliceTool::SelectChange Definition at line 2545 of file slicetool.cpp. { // Reset all our infomation about the selection to "no selection". SelectionSpread = NULL; SelectionRect.MakeEmpty(); m_drBlobRect.MakeEmpty(); // we want to take controller nodes into account in this selection. RangeControl rc = SelectRange->GetRangeControlFlags(); RangeControl rcOld = rc; rc.PromoteToParent = TRUE; SelectRange->Range::SetRangeControl(rc); // Go find the first node in the selection, so that we can find out about its spread Node* pFirstNode = SelectRange->FindFirst(); if (pFirstNode != NULL) { // Find the spread that the selection lives on, if any, and its bounds. SelectionSpread = pFirstNode->FindParentSpread(); if (SelectionSpread != NULL) { // Update the bounding rectangle of the selection. SelectionRect = SelectRange->GetBoundingRect(); // update our tool-blob rendering info. m_drBlobRect = SelectRange->GetBoundingRectForEorDragging(); // call the name-gallery to update named set info. NameGallery* pNameGallery = NameGallery::Instance(); if (pNameGallery) pNameGallery->FastUpdateNamedSetSizes(); // decide what set-selection info we'll be displaying. INT32 nSetSelection = SliceHelper::DoesSelectionOnlyContainCompleteSets(); m_SetSelectionState = (nSetSelection == 1) ? FullSetsSelected : (nSetSelection == 0) ? HalfSetsSelected : NoSetsSelected; if (SelectionRect.IsEmpty()) SelectionRect.Inflate(1); } } SelectRange->Range::SetRangeControl(rcOld); // Return TRUE if there is a selection. return SelectionSpread != NULL; }

BOOL SliceTool::ValidateLastClickInside (  NodeRenderableInk *  pLastClickNode, NodeRenderableInk *  pClickSimpleNode )  [protected]

Validate that the simple node is inside the last clicked node. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com>, from Phil's SelectorTool code Date: 11/10/1999 Parameters: -  [INPUTS] pLastClickNode  Pointer to last node selected or NULL [OUTPUTS] Returns: TRUE if the simple clicked node is inside the last clicked node somewhere FALSE otherwise Errors: - See also: SliceTool::HandleButtonUp Definition at line 2027 of file slicetool.cpp. { Node* pSearchNode = pClickSimpleNode; while (pSearchNode && pSearchNode!=pLastClickNode) pSearchNode = pSearchNode->FindParent(); return (pSearchNode!=NULL); }

BOOL SliceTool::ValidateLastClickUnder (  NodeRenderableInk *  pLastClickNode, Spread *  pStartSpread, DocCoord  ClickStart )  [protected]

Validate that the last click node is still under the pointer Note! This routine can be slow depending on how deep it has to look in the tree for the last selected object. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com>, from Phil's SelectorTool code Date: 11/10/1999 Parameters: -  [INPUTS] pLastClickNode  Pointer to last node selected or NULL [OUTPUTS] Returns: TRUE if last click node is still under the pointer (somewhere) FALSE otherwise Errors: - See also: SliceTool::HandleButtonUp Definition at line 1996 of file slicetool.cpp. { NodeRenderableInk* pSearchNode = NULL; do { pSearchNode = NodeRenderableInk::FindSimpleAtPoint(pStartSpread,ClickStart,pSearchNode); } while (pSearchNode && pLastClickNode!=NodeRenderableInk::FindCompoundFromSimple(pSearchNode,pLastClickNode)); return (pSearchNode!=NULL); }

void SliceTool::ViewChanged (  const DocViewMsg &  msg  )

The SliceTool's view-changed message handler. This method is called directly from the message handler of SliceInfoBarOp, which lives further down in this file. Its sole purpose is to let us redraw our blobs correctly. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06/07/2000 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: Definition at line 485 of file slicetool.cpp. { #ifdef SLICETOOL_BLOBS BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr==NULL) return; switch (msg.State) { case DocViewMsg::DocViewState::SELABOUTTOCHANGE: { // Only bother rendering our tool blobs off if the new view is valid. if (msg.pNewDocView != NULL) { pBlobMgr->RenderToolBlobsOff(this, SelectionSpread, NULL); // so that we don't draw tool blobs onto any new view, we must ignore any // select-change message until the new view is installed. m_fIgnoreSelChange = TRUE; } break; } case DocViewMsg::DocViewState::SELCHANGED: { // if the new DocView is valid, then draw our blobs onto it. if (msg.pNewDocView != NULL) if (UpdateSelectionInfo()) pBlobMgr->RenderToolBlobsOn(this, SelectionSpread, NULL); // ok, the new view is now here - we can stop ignoring sel-changed messages. m_fIgnoreSelChange = FALSE; break; } default: break; } #endif }

---

Friends And Related Function Documentation

friend class OpSliceDragBox [friend]

Definition at line 137 of file slicetool.h.

friend class OpSliceTranslate [friend]

Definition at line 138 of file slicetool.h.

---

Member Data Documentation

char * SliceTool::Author = "Simon K" [static, private]

Reimplemented from DragTool. Definition at line 341 of file slicetool.h.

TransformBoundingData SliceTool::BoundingData [protected]

Definition at line 319 of file slicetool.h.

ClickModifiers SliceTool::ClickMods [protected]

Definition at line 272 of file slicetool.h.

DocCoord SliceTool::ClickStart [protected]

Definition at line 270 of file slicetool.h.

INT32 SliceTool::CurrentCursorID [private]

Definition at line 336 of file slicetool.h.

BOOL SliceTool::CurrentTool = FALSE [static, private]

Definition at line 332 of file slicetool.h.

char * SliceTool::FamilyName = "Slice Tools" [static, private]

Reimplemented from DragTool. Definition at line 338 of file slicetool.h.

BOOL SliceTool::m_bSliceToolSetSel [protected]

Definition at line 279 of file slicetool.h.

DocRect SliceTool::m_drBlobRect [protected]

Definition at line 282 of file slicetool.h.

BOOL SliceTool::m_fIgnoreSelChange [private]

Definition at line 344 of file slicetool.h.

enum SetSelectionState SliceTool::m_SetSelectionState [protected]

Definition at line 315 of file slicetool.h.

Cursor* SliceTool::pcAdjustCursor [protected]

Definition at line 257 of file slicetool.h.

Cursor* SliceTool::pcALLCursor [protected]

Definition at line 265 of file slicetool.h.

Cursor* SliceTool::pcCurrentCursor [private]

Definition at line 335 of file slicetool.h.

Cursor* SliceTool::pcHorzGuideCursor [protected]

Definition at line 266 of file slicetool.h.

Cursor* SliceTool::pcInsideAdjustCursor [protected]

Definition at line 261 of file slicetool.h.

Cursor* SliceTool::pcInsideCursor [protected]

Definition at line 259 of file slicetool.h.

Cursor* SliceTool::pcLeafAdjustCursor [protected]

Definition at line 263 of file slicetool.h.

Cursor* SliceTool::pcLeafCursor [protected]

Definition at line 262 of file slicetool.h.

NodeRenderableInk* SliceTool::pClickCompoundNode [protected]

Definition at line 286 of file slicetool.h.

NodeRenderableInk* SliceTool::pClickSimpleNode [protected]

Definition at line 285 of file slicetool.h.

Cursor* SliceTool::pcNormalSliceCursor [protected]

Definition at line 256 of file slicetool.h.

Cursor* SliceTool::pcUnderAdjustCursor [protected]

Definition at line 260 of file slicetool.h.

Cursor* SliceTool::pcUnderCursor [protected]

Definition at line 258 of file slicetool.h.

Cursor* SliceTool::pcVertGuideCursor [protected]

Definition at line 267 of file slicetool.h.

NodeRenderableInk* SliceTool::pLastClickNode [protected]

Definition at line 287 of file slicetool.h.

NodeRenderableInk* SliceTool::pPreProcClickNode [protected]

Definition at line 288 of file slicetool.h.

SliceInfoBarOp * SliceTool::pSliceInfoBarOp = NULL [static, private]

Definition at line 333 of file slicetool.h.

char * SliceTool::Purpose = "Slice manipulation" [static, private]

Reimplemented from DragTool. Definition at line 340 of file slicetool.h.

DocRect SliceTool::SelectionRect [protected]

Definition at line 278 of file slicetool.h.

Spread* SliceTool::SelectionSpread [protected]

Definition at line 276 of file slicetool.h.

SelRange* SliceTool::SelectRange [protected]

Definition at line 277 of file slicetool.h.

Spread* SliceTool::StartSpread [protected]

Definition at line 271 of file slicetool.h.

char * SliceTool::ToolName = "Slice Tool" [static, private]

Reimplemented from DragTool. Definition at line 339 of file slicetool.h.

ClickType SliceTool::TypeOfClick [protected]

Definition at line 273 of file slicetool.h.

---

The documentation for this class was generated from the following files:

• tools/slicetool.h (r1785/r1282)
• tools/slicetool.cpp (r1785/r1282)

---