TransOperation Class Reference

The base class for all the Transform Operations. This class should provide most of the functionality for all the transform operations such as handling the eored drag events etc. At the end of the day it will transform the selection is some way (depending on the derived class). More...

#include <transop.h>

Inheritance diagram for TransOperation:

List of all members.

Public Member Functions
	TransOperation ()
virtual	~TransOperation ()
	TransOperation destructor.
BOOL	DoStartTransOp (BOOL RecordSelTwice, Node *NodeToTransform=NULL, Range *RangeToTransform=NULL)
	This function must be called by all TransOperations. It does the following: Records the current selection status Invalidates the rectangle covered by the selection and its blobs.
virtual void	End ()
	Calls DoEndTransOp(), then Operation::End().
virtual Matrix	GetCurrentMatrix ()
Range *	GetTransformRange ()
virtual void	DoWithParam (OpDescriptor *, OpParam *pOpParam)
	Does an immediate version of the transform. This attempts to transform the selection and build all the neccesary Undo information. Derived class only need overide InitTransformImmediate() to set up the specifics of there own transform unless they need to do something not covered by this base class version.
virtual void	DragStarted (TransformData *, DragTool *, TransformBoundingData *, DocCoord, Spread *, ClickModifiers, DocCoord ClickOffset=DocCoord(0, 0), Node *NodeToTrans=NULL, DragType dragtype=DRAGTYPE_AUTOSCROLL, BOOL bSolidDrag=FALSE)
	Starts an interactive drag version of the transformation operation.Changes made: pTool is now of type DragTool*, instead of SelectorTool*.
virtual BOOL	ShouldPointerBeOffset ()
	Allows the transforms to decide if they want the mouse position to be moved for them to the edge of the selection.
virtual void	DragPointerMove (DocCoord, ClickModifiers, Spread *, BOOL bSolidDrag)
	Handles the event of the mouse moving during a drag. This function will try to undraw all the eored data from the screen and start drawing it in again in a new location.
virtual void	DragPointerIdle (DocCoord, ClickModifiers, Spread *, BOOL bSolidDrag)
	This function is called during the drag when the mouse is not moving. It makes use of this idle time to draw a few more shapes from the selection to the screen. Thus, if you are tranforming a selection of objects you will see more detail when the mouse stops moving.
virtual void	DragFinished (DocCoord, ClickModifiers, Spread *, BOOL, BOOL bSolidDrag)
	Marks the end of the drag. It is at this point that all the transformations should be applied to the selection if everything worked.
virtual BOOL	DragKeyPress (KeyPress *pKeyPress, BOOL bSolidDrag)
	Find out if any of the key modifiers are being pressed when the mouse is not moving.
virtual void	DragModeChanged (BOOL bSolidDrag)
	Find out if any of the key modifiers are being pressed when the mouse is not moving.
virtual void	OnClickWhileDragging (OilCoord PointerPos, ClickType Click, ClickModifiers Mods, BOOL bSolidDrag)
	This virtual function handles clicks with one mouse button while another mouse button is dragging. For example, the user drags with the left mouse button and clicks the right button during the drag.
BOOL	DragCopyAction (BOOL bSolidDrag)
BOOL	DropCopy (BOOL bSolidDrag)
BOOL	SetLeaveCopy ()
virtual void	RenderDragBlobs (DocRect ClipRect, Spread *ParentSpread, BOOL bSolidDrag)
	Draws the EORed stuff ("blobs") to the screen during a drag.
BOOL	CompleteTransformation ()
	Builds the actual Undo information etc for the transformation as well as actually performing the transformation itself. This should be called by both DragFinished() and DoWithParams().
void	ComputeNewBounds ()
	Applies the current transformation matrix to the original bounding box data to compute the new bounds of the objects. It also notes that the bounds may be severely distorted by the transform and so it sorts and recombines the output coordinates to construct a new bounding rectangle.
void	SelectNodeAfterDrag (Node *NodeToSelect)
void	ClearNodesToSelect ()
virtual BOOL	MayChangeNodeBounds () const
Static Public Member Functions
static BOOL	DeclarePrefs ()
	Declares any preferences that the class needs to declare.
static BOOL	Declare ()
static OpState	GetState (String_256 *Description, OpDescriptor *)
Public Attributes
List	lstNodesToSelect
Protected Member Functions
DocCoord	GetStartPos ()
	Get the raw start position or the magnetically snapped one depending on the state of the magnetic switch in the drag view. This function must be called instead of accessing StartPos directly in any place where the magnetically snapped start position is going to be used. It does not need to be used when magnetic snapping is not an issue. Then, StartPos can simply be read directly.
Protected Attributes
DragTool *	pSelTool
TransformBoundingData	BoundingData
Coord	OriginalBounds [4]
DocCoord	StartPos
DocCoord	MagStartPos
DocCoord	RawStartPos
DocCoord	RawPos
DocCoord	LastRawPos
DocCoord	CentreOfTrans
Spread *	StartSpread
Spread *	CurrentSpread
DocCoord	Offset
BOOL	MagneticGripPoint
DocCoord	BoundingCentre
DocCoord	OriginalCentre
Matrix	Transform
Matrix	OriginalTransform
BOOL	RecordTwice
Node *	ObjectUnderCursor
Range *	m_pTransformRange
SelectionState *	SelState
BOOL	LockAspect
BOOL	LeaveCopy
BOOL	ScaleLines
BOOL	TransFills
BOOL	MouseHasMoved
BOOL	CanScaleLines
BOOL	AbortTransAtEnd
UINT32	StatusHelpID
UINT32	StatusHelpID2
List *	m_pSelList
Range *	m_pDraggedRange
Spread *	m_pDragSpread
BOOL	m_bFirstRedraw
BOOL	m_bShowDraggedOutlines
MonotonicTime	m_timeIdle
BOOL	m_bShowOriginalOutlines
BOOL	m_bRangeCacheTransformed
BOOL	m_bRangeFullyTransformed
Trans2DMatrix	m_PrevTransform
DocRect	m_AccuracyTestRect
Static Protected Attributes
static INT32	ClickWhileDragFunc
Private Member Functions
virtual void	InitTransformImmediate (OpParam *)
	Allows a transformation to set itself up ready for an immediate transform. If your class wants to support immediate transforms it should overide this function or the DoWithParam function. This base class version of the function does nothing.
virtual void	InitTransformOnDrag (DocCoord, ClickModifiers)
	Sets up the parameters needed to build the transform matrix at the start of the drag. This base class version of this function does nothing.
virtual void	UpdateTransformOnDrag (DocCoord, Spread *, ClickModifiers &)
	This function re-calculates the parameters specific to the transform based on the mouse position. This is only used in interactive drag style transforms.
virtual void	ConstrainDrag (DocCoord *)
	Gives the operation the chance to constrain the mouses movement if it is relavent. If it is not, then do not overide this function.
virtual void	SetStartBlob (INT32 StartBlob)
	Allows the operations to know how it was started. Some operation do different things depending on if they are going vertically or horizontally and this will allow you to figure that out. Overide this function if you need to deal with this situation (ie the Shear operation). The base class version does nothing. This function is called from the DragStarted() function.
virtual void	UpdateTransformBoundingData ()
	Should update the information in the TransformBoundingData object of the class and tell the Selector tool using the DragMove function. This is the base class version of the function that just tells the tool but does not change any of the data. This function is called at the end of the DragPointerMove function. It is possible for your transform to simple change the data in the BoundingData var as it goes and leave this base class version of the function to tell the tool about the changes.
virtual void	DragInputChanged (DocCoord, ClickModifiers, Spread *)
	Deals with any input changing during a transform drag. This mostly means the mouse position changing but it is also called when the click modifiers change or potentially any other input.
virtual void	DragSolidChanged (DocCoord PointerPos, ClickModifiers ClickMods, Spread *pSpread, BOOL bForceRecopy=FALSE)
	Deals with any input changing during a solid transform drag. This mostly means the mouse position changing but it is also called when the click modifiers change or potentially any other input.
virtual BOOL	CanChangeSpread ()
	Tell the baseclass functions whether to draw drag feedback only on the start spread or to allow drag rendering to be done on other spreads too.
virtual void	BuildMatrix ()
	This function should build the approprate transform matrix based on all the params that are available. This base class version of the function does not build a matrix and should not be called, as a derived class version of it should exist.
BOOL	LeaveCopyOfSelection ()
	If the flag LeaveCopy is set (ie we have been instructed to leave a copy of the selection in its original location) then this function is called. It makes a copy of the current selection and places them in the tree.
BOOL	DoEndTransOp ()
	This function gets called automatically by End() It Invalidates the rectangle covered by the selection and its blobs Scope: protected.
BOOL	DoSmartInvalidate ()
	Invalidate the transform range of nodes but be careful about releasing cache info so that translations can retain cached info if possible.
virtual BOOL	GetStatusLineText (String_256 *, Spread *, DocCoord, ClickModifiers)
	get status line hlep for drag op
void	FigureStatusText (String_256 *)
	Compute help text for this transform.
BOOL	SolidDragTransform (BOOL bForceRecopy=FALSE, BOOL bForceRedraw=TRUE)
	Transform the selection into the drag range.
BOOL	SetTransformRange (Range *pTransformRange, Node *pTransformNode)
	Sets the m_pTransformRange member to be a local range created either as a copy of the supplied range or a range created to represent the node or a copy of the selection range.
BOOL	TransformOverlapsOriginal ()
	Check whether transform objects overlap originals.

---

Detailed Description

The base class for all the Transform Operations. This class should provide most of the functionality for all the transform operations such as handling the eored drag events etc. At the end of the day it will transform the selection is some way (depending on the derived class).

Author:

Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> / Rik

Date:

15/2/94

Definition at line 226 of file transop.h.

---

Constructor & Destructor Documentation

TransOperation::TransOperation (   )

TransOperation::~TransOperation (   )  [virtual]

TransOperation destructor. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/94 Definition at line 228 of file transop.cpp. { if (m_pSelList) { m_pSelList->DeleteAll(); delete m_pSelList; m_pSelList = NULL; } if (m_pDraggedRange) { delete m_pDraggedRange; m_pDraggedRange = NULL; } if (m_pTransformRange) { delete m_pTransformRange; m_pTransformRange = NULL; } }

---

Member Function Documentation

void TransOperation::BuildMatrix (   )  [private, virtual]

This function should build the approprate transform matrix based on all the params that are available. This base class version of the function does not build a matrix and should not be called, as a derived class version of it should exist. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Reimplemented in OpFlipTrans, OpRotateTrans, OpScaleTrans, OpShearTrans, OpSquashTrans, OpSliceTranslate, and OpTranslateTrans. Definition at line 1777 of file transop.cpp. { ENSURE(FALSE, "Base class version of BuildMatrix() called. A derived class version must exist"); // Sets the transform matrix to be the identity matrix in case of an emergency. Transform = Matrix(); }

BOOL TransOperation::CanChangeSpread (   )  [private, virtual]

Tell the baseclass functions whether to draw drag feedback only on the start spread or to allow drag rendering to be done on other spreads too. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/June/2006 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if this transform allows the drag to be transferred to another spread Reimplemented in OpSliceTranslate, and OpTranslateTrans. Definition at line 1757 of file transop.cpp. { // Overide this function if you allow your transform to cross spread boundaries return FALSE; }

void TransOperation::ClearNodesToSelect (   )

>>> void ClearNodesToSelect () Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/96 Purpose Empties the node list and deletes all the items in it. Definition at line 2537 of file transop.cpp. { lstNodesToSelect.DeleteAll(); }

BOOL TransOperation::CompleteTransformation (   )

Builds the actual Undo information etc for the transformation as well as actually performing the transformation itself. This should be called by both DragFinished() and DoWithParams(). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Returns: TRUE if it worked Definition at line 1930 of file transop.cpp. { // Build the appropriate transform object to transform the selection Trans2DMatrix* Trans; ALLOC_WITH_FAIL(Trans, new Trans2DMatrix(Transform), this); // See if the memory allocation worked if (Trans == NULL) return FALSE; // Ideally we should put the hourglass on here, it will be turned off in the End method BeginSlowJob(); // Set the flags in the transform according to the flags set here Trans->TransFills = TransFills; Trans->TransLines = ScaleLines && CanScaleLines; Trans->bHaveTransformedAllCached = TRUE; // having transformed none we can say all caches have been transformed Trans->bHaveTransformedAllChildren = TRUE; // having transformed none we can say all children have been transformed Trans->bTransformYourChildren = TRUE; // The transform does not have to transform all its data m_bRangeCacheTransformed = TRUE; m_bRangeFullyTransformed = TRUE; // if we need to leave a copy of the selection behind, then do it // We HAVE to do this before we call DoStartTransOp() as it builds a // run length coding of the selection, which is messed up if we insert // extra nodes into the tree. // // Markn 31/5/95: Only allow LeaveCopy if select-inside is NOT present // JustinF: 6/10/96 only do this if transforming the selection, not TransformRange! if (m_pTransformRange && LeaveCopy && !m_pTransformRange->ContainsSelectInside()) { if (!LeaveCopyOfSelection()) return FALSE; } // Start the selection operation which records the current selection status and // invalidates the rectangle covered by the selection and its blobs. BOOL RecordSelectionTwice = (CanChangeSpread()) && (StartSpread!=CurrentSpread); // If the Selection only contains a single object then we pass this object as // a parameter to DoStartTransOp. Otherwise the routine assumes that the // entire selection will be transformed. // JustinF: 7/10/96 only do this if transforming the selection, not TransformRange! if (SelState==NULL) { if (!DoStartTransOp(RecordSelectionTwice, NULL, m_pTransformRange)) return FALSE; } // Scan the selection, and transform each selected object. // Karim 29/06/2000 - modified so that the range's PromoteToParent flag is not ruined. BOOL TransOK = DoTransformNodes(*m_pTransformRange, Trans); if (!TransOK) return FALSE; // Move the selection to a new spread if it should be if (RecordSelectionTwice) { // Move the selection to a new spread here if (!DoMoveNodes(*m_pTransformRange, CurrentSpread->FindActiveLayer(), LASTCHILD)) return FALSE; Document::GetSelected()->ResetInsertionPosition(); } // Change the bounds then ripple them up the tree //SCANRANGEFORCLASS(Selection, UpdateInkBoundingRect(), NodeRenderableInk); //Selection->UpdateParentBoundsOfSelection(); m_bRangeCacheTransformed = Trans->bHaveTransformedAllCached; m_bRangeFullyTransformed = Trans->bHaveTransformedAllChildren; // It all worked, so say so. return TRUE; }

void TransOperation::ComputeNewBounds (   )

Applies the current transformation matrix to the original bounding box data to compute the new bounds of the objects. It also notes that the bounds may be severely distorted by the transform and so it sorts and recombines the output coordinates to construct a new bounding rectangle. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 04/9/94 Definition at line 1874 of file transop.cpp. { // Transform original bounding coordinates Coord NewBounds[4]; Transform.transform(NewBounds,OriginalBounds,4); // Now recombine the output coords to see where the new bottom-left and top-right coords // really are... INT32 lox = NewBounds[0].x; INT32 loy = NewBounds[0].y; INT32 hix = NewBounds[0].x; INT32 hiy = NewBounds[0].y; UINT32 i; for(i=1;i!=4;i++) { if (NewBounds[i].x < lox) lox=NewBounds[i].x; if (NewBounds[i].y < loy) loy=NewBounds[i].y; if (NewBounds[i].x > hix) hix=NewBounds[i].x; if (NewBounds[i].y > hiy) hiy=NewBounds[i].y; } // Now update the bounds structure... if (lox!=BoundingData.x || loy!=BoundingData.y) { // One or both of x or y have changed so update them and set the changed flag BoundingData.x=lox; BoundingData.y=loy; BoundingData.XYChanged = TRUE; } // Compute width and height hix = hix-lox; hiy = hiy-loy; if (hix!=BoundingData.Width || hiy!=BoundingData.Height) { // One or both of w or h have changed so update them and set the changed flag BoundingData.Width=hix; BoundingData.Height=hiy; BoundingData.WHChanged = TRUE; } }

void TransOperation::ConstrainDrag (  DocCoord *  PointerPos  )  [private, virtual]

Gives the operation the chance to constrain the mouses movement if it is relavent. If it is not, then do not overide this function. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: PointerPos  - The position of the mouse right about now [INPUTS] Reimplemented in OpRotateTrans, OpScaleTrans, OpShearTrans, OpSliceTranslate, and OpTranslateTrans. Definition at line 1798 of file transop.cpp. { // By default there is no constrain action // Write you own version of this function if you want your transformation to be constrained }

BOOL TransOperation::Declare (   )  [static]

Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Returns: TRUE if it worked, FALSE otherwise Reimplemented in OpFlipTrans, OpRotateTrans, OpScaleTrans, OpShearTrans, OpSquashTrans, OpSliceTranslate, and OpTranslateTrans. Definition at line 1634 of file transop.cpp. { return TRUE; }

BOOL TransOperation::DeclarePrefs (   )  [static]

Declares any preferences that the class needs to declare. Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 25/6/96 Returns: TRUE if it worked, FALSE if it failed Definition at line 1650 of file transop.cpp. { GetApplication()->DeclarePref( _T("Mouse"), _T("ClickWhileDragFunc"), &ClickWhileDragFunc, 0, 3 ); return TRUE; }

BOOL TransOperation::DoEndTransOp (   )  [private]

This function gets called automatically by End() It Invalidates the rectangle covered by the selection and its blobs Scope: protected. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/94 Definition at line 366 of file transop.cpp. { // If this is a translation and the nodes all managed to transform their cached // info successfully then we should avoid forcing them to recache now. // So we must do some cleverer recaching BOOL bOK = DoSmartInvalidate(); if (!bOK) return FALSE; // If we want to record the selection again, then build a new Selection State object // and record the selection into it. if (RecordTwice) { // Create a SelectionState object ALLOC_WITH_FAIL(SelState, (new SelectionState()), this); if (SelState == NULL) { return FALSE; // Failure } // We have managed to create a SelectionState instance, now lets try and // record the current selections BOOL Success; CALL_WITH_FAIL(SelState->Record(), this, Success) if (!Success) // We failed to allocate enough memory to store the selection state { // There was insufficient memory to record the selections delete SelState; // Delete the selection state SelState = NULL; return FALSE; } // We have successfully managed to create a Selection state, create an action // to restore the selections when executed } // Recorded the current selection state ok RestoreSelectionsAction* RestoreAct; ActionCode ActCode; // The SelState should have been created in the DoStartSelectionOp method. // maybe it was never called !!! ERROR2IF(SelState==NULL, FALSE, "We don't have a selection state"); // Attempt to initialise the action ActCode = RestoreSelectionsAction::Init(this, &UndoActions, SelState, !RecordTwice, // Toggle TRUE, // This action does not restore the sels // restore the selection state but // its twin will !RecordTwice, // The SelState is shared FALSE, // Don't draw the selection blobs FALSE, TRUE, // End restore ( Action**)(&RestoreAct)); // See if it all worked if (ActCode == AC_FAIL) { // We won't be needing this delete SelState; return FALSE; } // Inform all changed nodes that we have finished ObjChangeFlags cFlags; ObjChangeParam ObjChange(OBJCHANGE_FINISHED,cFlags,NULL,this); ObjChange.SetRetainCachedData(Transform.IsTranslation() && m_bRangeCacheTransformed); // Same condition in DoSmartInvalidate BOOL ok = UpdateChangedNodes(&ObjChange); // BODGE TEXT - quick (harmless?) fix for bug 'transforming 2 selected text stories => sel blobs incorrect' // it is actually due to the fact that update change nodes is not called before the sel bounds are recached SelRange* pSelRange = Camelot.FindSelection(); if (pSelRange != NULL) { BOOL bOldValue = pSelRange->SetPromoteToParent(TRUE); pSelRange->UpdateBounds(); // Try to make sure that the spread's pasteboard is big enough to include the transformed // objects. This is very quick if the pasteboard is big enough already. Node *Bob = pSelRange->FindFirst(); if (Bob != NULL) { Spread *pSpread = Bob->FindParentSpread(); DocRect IncludeRect = pSelRange->GetBoundingRect(); pSpread->ExpandPasteboardToInclude(IncludeRect); } pSelRange->SetPromoteToParent(bOldValue); } return ok; }

BOOL TransOperation::DoSmartInvalidate (   )  [private]

Invalidate the transform range of nodes but be careful about releasing cache info so that translations can retain cached info if possible. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/12/2004 Definition at line 482 of file transop.cpp. { // Issue undoable redraws... if (m_pTransformRange && !DoInvalidateNodesRegions(*m_pTransformRange, TRUE, FALSE, FALSE, FALSE)) return FALSE; // Conditionally update cached info Node* pNode = m_pTransformRange->FindFirst(); while (pNode) { if (pNode->IsBounded()) { NodeRenderableBounded* pBoundNode = (NodeRenderableBounded*)pNode; // If we have transformed all cached data successfully // And // We are translating (in which case the cached data will remain usable) // Or // The node was Direct (in which case the cached data comes from outside the tree where it can't have been affected by the transform) // Then // Don't force the recacheing of the data for this node, just its parents if (m_bRangeCacheTransformed && (Transform.IsTranslation() || pBoundNode->HasCachedDirectBitmap())) pBoundNode->ReleaseCached(TRUE, FALSE, FALSE, TRUE); // Parents and derived data only else pBoundNode->ReleaseCached(TRUE, TRUE, TRUE, TRUE); // Parents, children, self and derived data } pNode = m_pTransformRange->FindNext(pNode); } return TRUE; }

BOOL TransOperation::DoStartTransOp (  BOOL  RecordSelTwice, Node *  NodeToTransform = NULL, Range *  RangeToTransform = NULL )

This function must be called by all TransOperations. It does the following: Records the current selection status Invalidates the rectangle covered by the selection and its blobs. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/94 Parameters: RecordSelTwice  - TRUE if the selection should be recorded twice (once at [INPUTS] the start of the operation and once at the end). If it is FALSE the selection is only recorded at the start of the operation. This should only be set to TRUE if the selection is different at the end of the operation (This is quite rare) NodeToTransform: Specifies the object that will be transformed. The default NULL value specifies that the entire selection will be transformed. RangeToTransform: Specifies the range of objects to use. The default NULL value specifies that the entire selection is the range. At present only used when NodeToTransform is NULL. Used by page resizing to move all the objects on the page regardless of selection. Hence, it does not call the AllowOp if the range is selected as AllowOp errors if no selection on things like NodeBlend and NodeText. Returns: TRUE if successful, FALSE if memory ran out (call End) See also: TransOperation::End() Definition at line 282 of file transop.cpp. { // Create a SelectionState object ALLOC_WITH_FAIL(SelState, (new SelectionState()), this); if (SelState == NULL) { return FALSE; // Failure } // We have managed to create a SelectionState instance, now lets try and // record the current selections BOOL Success; CALL_WITH_FAIL(SelState->Record(), this, Success) if (!Success) // We failed to allocate enough memory to store the selection state { // There was insufficient memory to record the selections delete SelState; // Delete the selection state SelState = NULL; return FALSE; } // We have successfully managed to create a Selection state, create an action // to restore the selections when executed // Recorded the current selection state ok RestoreSelectionsAction* RestoreAct; ActionCode ActCode; RecordTwice = RecordSelTwice; // Attempt to initialise the action ActCode = RestoreSelectionsAction::Init(this, &UndoActions, SelState, !RecordTwice, // # Toggle FALSE, // This action does not restore the sels // restore the selection state but // its twin will !RecordTwice, // The SelState is shared FALSE, // Don't draw the selection blobs FALSE, FALSE, // End restore ( Action**)(&RestoreAct)); if (ActCode == AC_FAIL) { delete SelState; // We won't be needing this return FALSE; } // Create our local transform range SetTransformRange(RangeToTransform, NodeToTransform); // Ask the range whether it's OK to do the transform... // Get an ObjChangeParam ready, so we can ask op permission from nodes. ObjChangeFlags cFlags(FALSE,FALSE,FALSE,FALSE,FALSE,TRUE); // flag this is a transform ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this); BOOL bOK = m_pTransformRange->AllowOp(&ObjChange); if (!bOK) return FALSE; // Invalidate the regions covered by all the selected objects and their blobs // return (DoInvalidateNodesRegions(*m_pTransformRange, TRUE)); bOK = DoSmartInvalidate(); return bOK; }

void TransOperation::DoWithParam (  OpDescriptor *  , OpParam *  pOpParam )  [virtual]

Does an immediate version of the transform. This attempts to transform the selection and build all the neccesary Undo information. Derived class only need overide InitTransformImmediate() to set up the specifics of there own transform unless they need to do something not covered by this base class version. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: pDescriptor  - The operations descriptor [INPUTS] pOpParam - The parameters for this operation Reimplemented from Operation. Reimplemented in OpAlign, OpPageResize, and OpMovePathPoint. Definition at line 562 of file transop.cpp. { // Get at my data TransformData* TransData = (TransformData *)(void *)(pOpParam->Param1); // copy across all the relavent bits of data for the transform CentreOfTrans = TransData->CentreOfTrans; LockAspect = TransData->LockAspect; LeaveCopy = TransData->LeaveCopy; ScaleLines = TransData->ScaleLines; TransFills = TransData->TransFills; SetTransformRange(TransData->pRange, NULL); // Set spread pointers now to keep CompleteTransformation happy even // though we don't expect them to be used or changed in Immediate transforms StartSpread = NULL; CurrentSpread = StartSpread; // Where was this operation started from, and are we interested SetStartBlob(TransData->StartBlob); // Allow the specific transforms to set up anything that they may need to set InitTransformImmediate(pOpParam); // Build the transform matrix BuildMatrix(); // Build the undo if there was a selection if (!CompleteTransformation()) FailAndExecute(); // mark the selection cache as invalid (bounding rects etc will no longer be correct) m_pTransformRange->Update(); // End the operation End(); }

BOOL TransOperation::DragCopyAction (  BOOL  bSolidDrag  )

These two events have the same effect but that effect is set by a user preference. This function looks at that preference and calls the appropriate function. Returns: Errors: None. See also: TransOperation::OnClickWhileDragging; TransOperation::DropCopy; TransOperation::SetLeaveCopy; Definition at line 2360 of file transop.cpp. { //Call the function appropriate to the preference assigned to the key pressed. if (ClickWhileDragFunc > 1) { return DropCopy(bSolidDrag); } else { return SetLeaveCopy(); } }

void TransOperation::DragFinished (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  pSpread, BOOL  Success, BOOL  bSolidDrag )  [virtual]

Marks the end of the drag. It is at this point that all the transformations should be applied to the selection if everything worked. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: PointerPos  - The position of the mouse at the end of the drag [INPUTS] ClickMods - the keyboard modifiers in place pSpread - the spread that was under the mouse Worked - TRUE if the drag was completed successfully Reimplemented from Operation. Reimplemented in OpSliceTranslate. Definition at line 1179 of file transop.cpp. { // By default assume it will not work BOOL Worked = FALSE; // Deregister our idle event handler. We don't want it to keep on rendering! GetApplication()->RemoveIdleProcessor(IDLEPRIORITY_HIGH, this); // Process raw mouse coordinate according to Offset distances... if (ShouldPointerBeOffset()) PointerPos.translate(Offset.x,Offset.y); // Find out how well the drag went . . . DragEndType HowEnded; if (!Success) { HowEnded = DT_CANCELLED; } else if (MouseHasMoved) { HowEnded = (PointerPos == RawStartPos) ? DT_MOVEDTOSAME : DT_MOVEDTODIFF; } else { HowEnded = DT_DIDNOTMOVE; } // Get rid of the temporary solid drag objects... DocView* pDocView = GetWorkingDocView(); if (m_pDraggedRange) { // If we're not going to transform objects to this position // then force a redraw to remove them from the view if (AbortTransAtEnd || !Success) m_pDraggedRange->ForceRedrawView(pDocView, TRUE); else // Bodge to ensure that scaled cached data is fully wiped (because // the scaled cached data may be bigger than the actual scaled vector data) if (HowEnded==DT_MOVEDTODIFF && m_bRangeCacheTransformed && !Transform.IsTranslation()) m_pDraggedRange->ForceRedrawView(pDocView, TRUE); m_pDraggedRange->DeleteNodes(); delete m_pDraggedRange; m_pDraggedRange = NULL; } m_pTransformRange->SetRenderable(TRUE); // Rub all that old EORed stuff out, 'cos we sure don't want it now. if (!bSolidDrag) m_pTransformRange->RenderXOROutlinesOff(NULL, CurrentSpread, &Transform); else { if (m_bShowOriginalOutlines) m_pTransformRange->RenderXOROutlinesOff(NULL, CurrentSpread, &OriginalTransform); if (!Success) m_pTransformRange->ForceRedrawView(pDocView, TRUE, FALSE, TRUE); // Don't recache objects - they haven't changed } pDocView->FlushRedraw(); // Mike 01/02/95 - Change the range control to include NoneRenderables now RangeControl TransFlags = m_pTransformRange->GetRangeControlFlags(); TransFlags.IgnoreNoneRenderable=FALSE; m_pTransformRange->SetRangeControl(TransFlags); // Check to see if the operation was a success and if the tool wants me to continue. BOOL fToolDragOK = TRUE; #ifndef STANDALONE if (pSelTool != NULL) fToolDragOK = pSelTool->DragFinished(HowEnded); #endif //Graham 30/9/96: This code is a bit of a bodge to fix something before the deadline //Do we need to change the selection? if (!lstNodesToSelect.IsEmpty()) { //Yes. So first get rid of the current selection NodeRenderableInk::DeselectAll(!bSolidDrag, TRUE); //And now we need to go through the list of nodes to select, selecting each one //in turn. NodeListItem* pThisItem=((NodeListItem*)lstNodesToSelect.GetHead()); ERROR3IF(pThisItem==NULL, "TransOp::EndDrag - Node list has no head!"); while (pThisItem!=NULL) { //Select the node Node* pThisNode=pThisItem->pNode; ERROR3IF(pThisNode==NULL, "TransOp::EndDrag - Node list item is empty!"); pThisNode->SetSelected(TRUE); NodeRenderableBounded* pThisBoundedNode=((NodeRenderableBounded*) pThisNode); if (pThisBoundedNode) DoInvalidateNodeRegion(pThisBoundedNode, TRUE, FALSE); //And go on to the next node in the list. pThisItem=(NodeListItem*) lstNodesToSelect.GetNext(pThisItem); } //And get rid of the items in the list now we've used them lstNodesToSelect.DeleteAll(); } //Graham: If AbortTransAtEnd is set, we don't want to complete the transformation if (fToolDragOK && Success && HowEnded!=DT_DIDNOTMOVE && !AbortTransAtEnd) { // Try to build all the undo information Worked = CompleteTransformation(); if (CanChangeSpread()) Document::SetSelectedViewAndSpread(NULL, NULL, m_pDragSpread); // mark the selection cache as invalid (bounding rects etc will no longer be correct) m_pTransformRange->Update(); } // End the drag EndDrag(); // Use the SliceHelper function to restore the selection back to how it was if it had been modified... SliceHelper::RestoreSelection(); // If there was a problem, fail if (!Worked) FailAndExecute(); // DON'T delete these ranges because they are used inside the End() function // Rely on ~Transop to get rid of them /* // tidy up member vars if (m_pTransformRange) { delete m_pTransformRange; m_pTransformRange = NULL; } if (m_pDraggedRange) { delete m_pDraggedRange; m_pDraggedRange = NULL; } */ // Preserve some data items we need to use below, after "this" has been deleted... DragTool* pSelToolCopy = pSelTool; Spread* pSpreadCopy = CurrentSpread; // pDocview was gained locally in the code above // End the operation (and Delete ourselves!) End(); // The following code may run when "this" has been deleted! // (It has to because we don't want to re-enable blob rendering until End() has done its stuff) // Be VERY careful here! // Now turn selection blobs back on