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 Camelot.GetBlobManager()->BlobRenderingOn(FALSE); if (bSolidDrag && pSelToolCopy) { // Note that this function call renders blobs into all current RenderRegions // so that they are back in sync with the selection state Camelot.GetBlobManager()->RenderToolBlobsOn(pSelToolCopy, pSpreadCopy, NULL); } }

void TransOperation::DragInputChanged (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  pSpread )  [private, virtual]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: PointerPos  - The current position of the mouse [INPUTS] ClickMods - Which of the modifiers are held down pSpread - The spread that the mouse is over Definition at line 972 of file transop.cpp. { // Process raw mouse coordinate according to Offset distances... if (ShouldPointerBeOffset()) PointerPos.translate(Offset.x,Offset.y); // Rub all that old EORed stuff out, 'cos we sure don't want it now. m_pTransformRange->RenderXOROutlinesOff(NULL, CurrentSpread, &Transform); // Constrain the mouse position if required (45 degrees until we get a better system) if (ClickMods.Constrain) ConstrainDrag(&PointerPos); // if the adjust button is down, we will use the centre // of the selection as the centre of transform if (ClickMods.Adjust) CentreOfTrans = BoundingCentre; else CentreOfTrans = OriginalCentre; // rebuild the transform matrix UpdateTransformOnDrag(PointerPos, pSpread, ClickMods); BuildMatrix(); // Draw the fabby new EORed stuff to the screen m_pTransformRange->RenderXOROutlinesOn(NULL, CurrentSpread, &Transform, ObjectUnderCursor); UpdateTransformBoundingData(); }

BOOL TransOperation::DragKeyPress (  KeyPress *  pKeyPress, BOOL  bSolidDrag )  [virtual]

Find out if any of the key modifiers are being pressed when the mouse is not moving. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 15/02/95 Parameters: pKeyPress  - pointer to a keypress object [INPUTS] Returns: TRUE if it handled the keypress, FALSE otherwise Reimplemented from Operation. Definition at line 1365 of file transop.cpp. { // Need something to see if there was a usful keypress BOOL KeyRecognised = FALSE; // and something to keep them in ClickModifiers ClickMods; ClickMods.Adjust = FALSE; ClickMods.Menu = FALSE; ClickMods.Constrain = FALSE; ClickMods.Alternative1 = FALSE; ClickMods.Alternative2 = FALSE; ClickMods.Pressure = 0; if (pKeyPress->IsPress() && !pKeyPress->IsRepeat()) // I.e. is this a non-auto-repeated key-down event? { switch (pKeyPress->GetVirtKey()) { // Numeric + key case CAMKEY(NUMPAD_ADD): { // Markn 31/5/95: Only allow the LeaveCopy flag to toggled if select-inside is NOT present if (!m_pTransformRange->ContainsSelectInside()) { // Graham 24/6/96: The '+' key's function depends on a preference // DragCopyAction() will perform whatever operation // is assigned to the + key by this preference. KeyRecognised = DragCopyAction(bSolidDrag); } break; } // Numeric / key case CAMKEY(NUMPAD_DIVIDE): { ScaleLines = !ScaleLines; BoundingData.ScaleLinesChanged = TRUE; KeyRecognised = TRUE; } // Numeric - key case CAMKEY(NUMPAD_SUBTRACT): { TransFills = !TransFills; BoundingData.TransFillsChanged = TRUE; KeyRecognised = TRUE; } } // If key recognised in the first part of this routine then it will have changed the status help... if (KeyRecognised) { BoundingData.ScaleLines = ScaleLines; BoundingData.LeaveCopy = LeaveCopy; BoundingData.TransFills = TransFills; String_256 Text; FigureStatusText(&Text); GetApplication()->UpdateStatusBarText(&Text); } } // If a modifier key has changed state, or the key pressed was one that we recognise, // update the drag data immediately if (KeyPress::ModifierChanged() || KeyRecognised) { // Set up the click modifier ClickMods.Constrain = pKeyPress->IsConstrainPressed(); ClickMods.Adjust = pKeyPress->IsAdjustPressed(); ClickMods.Alternative1 = pKeyPress->IsAlternativePressed(); // Click modifiers changed (sort of) so go change the transform... // DragInputChanged(LastRawPos, ClickMods, CurrentSpread); // Right, the mouse pos changed, so go change the transform... if (bSolidDrag) DragSolidChanged(LastRawPos, ClickMods, CurrentSpread, KeyRecognised); else DragInputChanged(LastRawPos, ClickMods, CurrentSpread); // Tell the keypress people that we used the keypress KeyRecognised = TRUE; } // Did or did not use the click return KeyRecognised; }

void TransOperation::DragModeChanged (  BOOL  bSolidDrag  )  [virtual]

Find out if any of the key modifiers are being pressed when the mouse is not moving. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 15/02/95 Parameters: pKeyPress  - pointer to a keypress object [INPUTS] Returns: TRUE if it handled the keypress, FALSE otherwise Reimplemented from Operation. Definition at line 1469 of file transop.cpp. { DocView* pDocView = DocView::GetSelected(); BlobManager* pBlobManager = Camelot.GetBlobManager(); ENSURE(pBlobManager, "Can't get BlobManager"); if (bSolidDrag) { // The drag rendering mode has just become solid // Hide the original objects and show the dragged objects m_pTransformRange->SetRenderable(FALSE); m_pTransformRange->ForceRedrawView(pDocView, TRUE, FALSE, TRUE); // Don't recache objects - they haven't changed if (m_pDraggedRange) { m_bFirstRedraw = TRUE; // Actually move the dragged objects here SolidDragTransform(FALSE); m_pDraggedRange->SetRenderable(TRUE); // m_pDraggedRange->ForceRedrawView(pDocView); m_pTransformRange->RenderXOROutlinesOff(NULL, CurrentSpread, &Transform); if (m_bShowOriginalOutlines) m_pTransformRange->RenderXOROutlinesOn(NULL, CurrentSpread, &OriginalTransform, ObjectUnderCursor); if (pSelTool) pBlobManager->RenderToolBlobsOff(pSelTool, CurrentSpread, NULL); pBlobManager->BlobRenderingOff(FALSE); } } else { // The drag rendering mode has just become outline // Show the original objects and hide the dragged objects m_pTransformRange->SetRenderable(TRUE); m_pTransformRange->ForceRedrawView(pDocView, TRUE, FALSE, TRUE); // Don't recache objects - they haven't changed if (m_pDraggedRange) { pBlobManager->BlobRenderingOn(FALSE); if (pSelTool) pBlobManager->RenderToolBlobsOn(pSelTool, CurrentSpread, NULL); if (m_bShowOriginalOutlines) m_pTransformRange->RenderXOROutlinesOff(NULL, CurrentSpread, &OriginalTransform); m_pTransformRange->RenderXOROutlinesOn(NULL, CurrentSpread, &Transform, ObjectUnderCursor); m_pDraggedRange->SetRenderable(FALSE); m_pDraggedRange->ForceRedrawView(pDocView, TRUE); } } // Show status help message if (StatusHelpID!=0) { String_256 Text; FigureStatusText(&Text); GetApplication()->UpdateStatusBarText(&Text); } // Render any invalidated regions // Call ServiceRendering to do a render directly within this function (without waiting // for the idle processor to do it) pDocView->FlushRedraw(); GetApplication()->ServiceRendering(); }

void TransOperation::DragPointerIdle (  DocCoord  Coord, ClickModifiers  , Spread *  , BOOL  bSolidDrag )  [virtual]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 8/12/94 Parameters: None  Used [INPUTS] Reimplemented from Operation. Definition at line 1120 of file transop.cpp. { // Draw a few more outlines if (!bSolidDrag) m_pTransformRange->RenderXOROutlinesOn(NULL, CurrentSpread, &Transform, ObjectUnderCursor); else { if (m_timeIdle.Elapsed(DocView::IdleDragDelay)) { // Assume OriginalTransform is Identity. m_bShowOriginalOutlines = TRUE; m_pTransformRange->RenderXOROutlinesOn(NULL, CurrentSpread, &OriginalTransform, ObjectUnderCursor); } if (m_timeIdle.Elapsed(DocView::IdleDragDelay2)) { // Don't show the outlines at the dragged position if that position is the original // position if (!(Transform==OriginalTransform)) { // We need to ensure that the dragged objects have actually been transformed // (Their cached containers might have been dragged instead to save time) // Would be nice to be able to test whether this recreation of the dragged // objects is really necessary here but I can't think of a decent way right now if (!m_bRangeFullyTransformed) { SolidDragTransform(TRUE, FALSE); ERROR3IF(!this->m_bRangeFullyTransformed, "Failed to transform shapes in DragPointerIdle"); } m_bShowDraggedOutlines = TRUE; if (m_pDraggedRange) { m_pDraggedRange->RenderXOROutlinesOn(NULL, CurrentSpread, &OriginalTransform, NULL); } } } } }

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

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: PointerPos  - The current position of the mouse [INPUTS] ClickMods - Which of the modifiers are held down pSpread - The spread that the mouse is over Reimplemented from Operation. Definition at line 935 of file transop.cpp. { // Has the mouse position actually moved? Check raw PointerPos against raw LastPos if (PointerPos != LastRawPos) { // First off, we will note the fact that the mouse has moved MouseHasMoved = TRUE; RawPos = PointerPos; // Right, the mouse pos changed, so go change the transform... if (bSolidDrag) DragSolidChanged(PointerPos, ClickMods, pSpread); else DragInputChanged(PointerPos, ClickMods, pSpread); // Preserve last raw mouse position LastRawPos = RawPos; } }

void TransOperation::DragSolidChanged (  DocCoord  PointerPos, ClickModifiers  ClickMods, Spread *  pSpread, BOOL  bForceRecopy = FALSE )  [private, virtual]

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. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 1/12/2003 Parameters: PointerPos  - The current position of the mouse [INPUTS] ClickMods - Which of the modifiers are held down pSpread - The spread that the mouse is over Definition at line 1022 of file transop.cpp. { DocCoord modPointerPos = PointerPos; DocView* pDocView = DocView::GetSelected(); m_timeIdle.Sample(); if (m_bShowDraggedOutlines) { m_pDraggedRange->RenderXOROutlinesOff(NULL, CurrentSpread, &OriginalTransform); m_bShowDraggedOutlines = FALSE; } if (!DocView::OriginOutlineShowAlways) { if (m_bShowOriginalOutlines && TransformOverlapsOriginal()) { m_pTransformRange->RenderXOROutlinesOff(NULL, CurrentSpread, &OriginalTransform); m_bShowOriginalOutlines = FALSE; } } // Process raw mouse coordinate according to Offset distances... if (ShouldPointerBeOffset()) modPointerPos.translate(Offset.x,Offset.y); // Constrain the mouse position if required (45 degrees until we get a better system) if (ClickMods.Constrain) ConstrainDrag(&modPointerPos); // if the adjust button is down, we will use the centre // of the selection as the centre of transform if (ClickMods.Adjust) CentreOfTrans = BoundingCentre; else CentreOfTrans = OriginalCentre; // rebuild the transform matrix UpdateTransformOnDrag(modPointerPos, pSpread, ClickMods); BuildMatrix(); // Actually move the dragged objects here // Start a timer covering both the transform and the render... MonotonicTime timeRender; { SolidDragTransform(bForceRecopy); // Tell the dragging tool about the changes UpdateTransformBoundingData(); // Render the tree and DON'T do any EOR rendering! // Call ServiceRendering to do a render directly within this function (without waiting // for the idle processor to do it) pDocView->FlushRedraw(); GetApplication()->ServiceRendering(); } // If render took more than 150 ms (SolidDragTimeLimit), fall back // NOTE! This is clever, the 150ms time will only be exceeded if a single object takes that // INT32 to render. Otherwise the background rendering timeslice will suspend rendering // and return. So background rendering will cope with complex selections but this clause // will fire if certain objects are taking too long. if (timeRender.Elapsed(DocView::SolidDragTimeLimit)) { TRACEUSER( "Phil", _T("TOO COMPLEX TO DRAG SOLIDLY!\n")); pDocView->SetSolidDragState(FALSE); // Turn off solid dragging in this drag op DragModeChanged(FALSE); } // Draw the EORed stuff to the screen if we need to... if (!DocView::OriginOutlineShowAlways) { if (!m_bShowOriginalOutlines && DocView::OriginOutlineShowNonOverlap && !TransformOverlapsOriginal()) { m_pTransformRange->RenderXOROutlinesOn(NULL, CurrentSpread, &OriginalTransform, NULL); m_bShowOriginalOutlines = TRUE; } } }

void TransOperation::DragStarted (  TransformData *  TransData, DragTool *  pTool, TransformBoundingData *  pBounds, DocCoord  ClickPos, Spread *  pSpread, ClickModifiers  ClickMods, DocCoord  ClickOffset = DocCoord(0, 0), Node *  NodeToTransform = NULL, DragType  dragtype = DRAGTYPE_AUTOSCROLL, BOOL  bSolidDrag = FALSE )  [virtual]

Starts an interactive drag version of the transformation operation.Changes made: pTool is now of type DragTool*, instead of SelectorTool*. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 14/10/1999 Definition at line 643 of file transop.cpp. { // Ensure all the data is acceptable ENSURE( TransData!=NULL, "The Transform Data was NULL in DragStarted"); // What is the node that we should be concentrating on in this transform? // (even if many nodes are being transformed) // If we haven't been told of a specific node and the drag pos is not offset // Then we can try to look for one directly under the cursor. // Phil says: This is horrible because // (a) the caller already knows this info // (b) the primary dragged node might not be the simple one under the pointer ObjectUnderCursor = NodeToTransform; if (ObjectUnderCursor == NULL && !ShouldPointerBeOffset()) { ObjectUnderCursor = NodeRenderableInk::FindSimpleAtPoint(pSpread, ClickPos); } // Copy all the data that we will want to be keeping StartSpread = pSpread; CurrentSpread = pSpread; m_pDragSpread = pSpread; RawStartPos = ClickPos; StartPos = ClickPos; MagStartPos = ClickPos; LastRawPos = ClickPos; Offset = ClickOffset; MouseHasMoved = FALSE; pSelTool = pTool; MagneticGripPoint = FALSE; // Process raw mouse coordinate according to Offset distances... if (ShouldPointerBeOffset()) { StartPos.translate(Offset.x,Offset.y); MagStartPos = StartPos; } else if (ObjectUnderCursor != NULL) { // If the click position is the position we intend to drag (ie. not offset) // and we have been informed about the node that position refers to // then we can try magnetic snapping to get a more accurate start pos MagneticGripPoint = DocView::SnapToMagneticNode(pSpread, ObjectUnderCursor, &MagStartPos); } // Get the information about the current size, position etc of the selection if (pBounds != NULL) { BoundingData.x = pBounds->x; BoundingData.y = pBounds->y; BoundingData.Width = pBounds->Width; BoundingData.Height = pBounds->Height; BoundingData.XScale = pBounds->XScale; BoundingData.YScale = pBounds->YScale; BoundingData.Rotation = pBounds->Rotation; BoundingData.Shear = pBounds->Shear; // Get the bounding rectangle into an array ready for quick transformation OriginalBounds[0].x = BoundingData.x; OriginalBounds[0].y = BoundingData.y; OriginalBounds[1].x = BoundingData.x+BoundingData.Width; OriginalBounds[1].y = BoundingData.y; OriginalBounds[2].x = BoundingData.x+BoundingData.Width; OriginalBounds[2].y = BoundingData.y+BoundingData.Height; OriginalBounds[3].x = BoundingData.x; OriginalBounds[3].y = BoundingData.y+BoundingData.Height; // Work out the centre of the selection BoundingCentre.x = BoundingData.x + (BoundingData.Width/2); BoundingCentre.y = BoundingData.y + (BoundingData.Height/2); } m_AccuracyTestRect = DocRect(OriginalBounds[0].x, OriginalBounds[0].y, OriginalBounds[2].x, OriginalBounds[2].y); // Get the info out of the structure OriginalCentre = TransData->CentreOfTrans; LockAspect = TransData->LockAspect; LeaveCopy = TransData->LeaveCopy; ScaleLines = TransData->ScaleLines; TransFills = TransData->TransFills; BoundingData.XYChanged = FALSE; BoundingData.WHChanged = FALSE; BoundingData.ScaleChanged = FALSE; BoundingData.RotateChanged = FALSE; BoundingData.ShearChanged = FALSE; BoundingData.TransFillsChanged = FALSE; BoundingData.LeaveCopyChanged = FALSE; BoundingData.ScaleLinesChanged = FALSE; // This section allows certain values passed into this func to be toggled // if their keyboard short-cuts are being pressed (markn 25/7/95) // BOOL FlagsChanged = FALSE; //Graham 28/6/96: If the + key is pressed do the following: //IF its function is to set the LeaveCopy flag, do it //IF its function is to drop a copy, do nothing if (KeyPress::IsKeyPressed(CAMKEY(NUMPAD_ADD))) { if (ClickWhileDragFunc>1) LeaveCopy = !LeaveCopy; } if (KeyPress::IsKeyPressed(CAMKEY(NUMPAD_DIVIDE))) { ScaleLines = !ScaleLines; } if (KeyPress::IsKeyPressed(CAMKEY(NUMPAD_SUBTRACT))) { TransFills = !TransFills; } if (ClickMods.Menu) { AbortTransAtEnd = TRUE; StatusHelpID=_R(IDS_ABORT_TRANSFORMATION1); } BoundingData.TransFills = TransFills; BoundingData.ScaleLines = ScaleLines; BoundingData.LeaveCopy = LeaveCopy; // By default we will use the proper centre of transform. Adjust may change this later CentreOfTrans = OriginalCentre; // Where was this operation started from, and are we interested SetStartBlob(TransData->StartBlob); // Set up the rendering matrix parameters InitTransformOnDrag(GetStartPos(), ClickMods); // Use the SliceHelper function to help the user to select buttons & bars... - Matt 9/11/2000 SliceHelper::ModifySelectionToContainWholeButtonElements(); // Go find the selection and make sure that there really is something in it SetTransformRange(TransData->pRange, NodeToTransform); // Mike 01/02/95 - Change the range control to include NoneRenderables now RangeControl TransFlags = m_pTransformRange->GetRangeControlFlags(); TransFlags.IgnoreNoneRenderable=TRUE; //Include invisible layers in the selection... Matt 9/11/2000 TransFlags.IgnoreInvisibleLayers = TRUE; m_pTransformRange->SetRangeControl(TransFlags); Node* pFirstNode = m_pTransformRange->FindFirst(); ENSURE(pFirstNode!=NULL, "There was no selection to transform!"); if (pFirstNode==NULL) return; // Reset the EORed stuff m_pTransformRange->ResetXOROutlineRenderer(); // Build the transformation matrix BuildMatrix(); OriginalTransform = Transform; // Setup the solid dragging flag for this transform drag instance bSolidDrag = DocView::SolidDragging; // Hide the current selection and make a copy of it // Change the range flags before transforming to implement DMc's // horrible PromoteToParent bodge for his nasty objects // BOOL oldPromoteVal = TransFlags.PromoteToParent; TransFlags.PromoteToParent = TRUE; m_pTransformRange->SetRangeControl(TransFlags); m_pDraggedRange = m_pTransformRange->CloneNodes(DocView::SolidDragTimeLimit, AbortTransAtEnd); m_bFirstRedraw = TRUE; BOOL bEnableSolidDragging = TRUE; if (m_pDraggedRange==NULL) { bSolidDrag = FALSE; bEnableSolidDragging = FALSE; } else { m_pDraggedRange->SetDraggedNodes(TRUE); bEnableSolidDragging = TRUE; } // Start XOR rendering going. We find the (ink) object which was clicked on, and // pass that in the the renderer, so that it can ensure that object outline is // rendered first (this allows the user to drag a small object interactively rather // than having to wait for the entire image to XOR onto screen before they can see // the precise object they are dragging) if (!bSolidDrag) { m_pTransformRange->SetRenderable(TRUE); if (m_pDraggedRange) m_pDraggedRange->SetRenderable(FALSE); m_pTransformRange->RenderXOROutlinesOn(NULL, CurrentSpread, &Transform, ObjectUnderCursor); } else { // Hide the selection blobs, hide the selection, show the drag selection m_timeIdle.Sample(); if (!AbortTransAtEnd) m_pTransformRange->SetRenderable(FALSE); if (m_pDraggedRange) m_pDraggedRange->SetRenderable(TRUE); if (pSelTool) Camelot.GetBlobManager()->RenderToolBlobsOff(pSelTool, CurrentSpread, NULL); Camelot.GetBlobManager()->BlobRenderingOff(TRUE); // Do we need to show the original outlines right away? if (DocView::IdleDragDelay==0 || DocView::OriginOutlineShowAlways) { m_pTransformRange->RenderXOROutlinesOn(NULL, CurrentSpread, &OriginalTransform, NULL); m_bShowOriginalOutlines = TRUE; } } // And tell the Dragging system that we need drags to happen StartDrag(dragtype, NULL, &StartPos, FALSE, bEnableSolidDragging); // Now that everything is set up, show status help message // (FigureStatusText will now have all the info it needs to provide correct feedback) if (StatusHelpID!=0) { String_256 Text; FigureStatusText(&Text); GetApplication()->UpdateStatusBarText(&Text); } }

BOOL TransOperation::DropCopy (  BOOL  bSolidDrag  )

Because the user has dropped objects during the drag, we assume he does not want to transform the original objects at the end of the drag. That is, the user has used this drag to copy objects, not to move them. So we set the AbortTransAtEnd flag. Returns: Errors: One memory error if no space for an error See also: TransOperation::DragCopyAction; OpCopyAndTransform::Do Definition at line 2394 of file transop.cpp. { //Because we are dropping a copy, we take that as a signal the user doesn't //want the drag to transform the selection. Setting this flag will abort the //transformation when the drag ends. AbortTransAtEnd=TRUE; //Prepare the Trans2DMatrix to send to the CopyAndTransform operation Trans2DMatrix MatrixToSend(Transform); MatrixToSend.TransFills = TransFills; MatrixToSend.TransLines = ScaleLines && CanScaleLines; //Create a new CopyAndTransform operation with that matrix OpCopyAndTransform* pOpCopyAndTransform = new OpCopyAndTransform(MatrixToSend); ERROR1IF(pOpCopyAndTransform==NULL, FALSE, _R(IDE_NOMORE_MEMORY)); // DMc - store the original selection // DMc - build a list of the original selection, so we can reselect them later Range Sel(*(GetApplication()->FindSelection())); List * pSelList = Sel.MakeListOfNodes(FALSE); //Do the operation pOpCopyAndTransform->Do(NULL); // Make sure the dragged objects are on top by removing them and then putting them back on top // (Could just move them in the tree but there's no routine to do that at the moment...) if (m_pDraggedRange) { Range* pNewDraggedRange = m_pDraggedRange->CloneNodes(DocView::SolidDragTimeLimit, TRUE); if (pNewDraggedRange) { if (bSolidDrag) { pNewDraggedRange->SetRenderable(TRUE); } else { pNewDraggedRange->SetRenderable(FALSE); } pNewDraggedRange->SetDraggedNodes(TRUE); m_pDraggedRange->DeleteNodes(); delete m_pDraggedRange; m_pDraggedRange = pNewDraggedRange; } } // DMc - restore the selection afterwards // restore the selection back to what it was before we entered the operation if (pSelList) { NodeRenderableInk::DeselectAll(FALSE, FALSE); // get back the original selection NodeListItem * pItem = (NodeListItem *)pSelList->GetHead(); while (pItem) { pItem->pNode->SetSelected(TRUE); pItem = (NodeListItem *)pSelList->GetNext(pItem); } pSelList->DeleteAll(); delete pSelList; GetApplication()->UpdateSelection(); } //Change the initial status bar message to read "Selection will not move after drag" StatusHelpID=_R(IDS_ABORT_TRANSFORMATION1); // Show the original objects if we are solid dragging, since they will be left behind // now that we have dropped a copy DocView* pDocView = GetWorkingDocView(); m_pTransformRange->SetRenderable(TRUE); m_pTransformRange->ForceRedrawView(pDocView, TRUE, FALSE, TRUE); // Don't recache objects - they haven't changed if (m_bShowOriginalOutlines) { m_pTransformRange->RenderXOROutlinesOff(NULL, CurrentSpread, &OriginalTransform); m_bShowOriginalOutlines = FALSE; } pDocView->FlushRedraw(); GetApplication()->ServiceRendering(); //StatusHelpID2 contains all the information on SHIFT-dragging, CTRL-dragging etc. //This does not change when a copy is dropped, so the variable stays the same. //And return to say it worked return TRUE; }

void TransOperation::End (   )  [virtual]

Calls DoEndTransOp(), then Operation::End(). Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/94 Reimplemented from Operation. Definition at line 529 of file transop.cpp. { if (OpStatus == DO && (!OpFlags.Failed)) { // We don't want to perform this if we are undoing or redoing do we DoEndTransOp(); } Operation::End(); }

void TransOperation::FigureStatusText (  String_256 *  pText  )  [private]

Compute help text for this transform. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 16/02/95 Parameters: -  [INPUTS] pText  - [OUTPUTS] Returns: - Errors: this==NULL Definition at line 2286 of file transop.cpp. { pText->Empty(); if (StatusHelpID!=0) pText->Load(StatusHelpID); // Get info about current drag mode and show the user DocView* pDocView = GetWorkingDocView(); if (pDocView && pDocView->GetCurrentSolidDragAbility()) { if (pDocView->GetCurrentSolidDragState()) *pText += String_256(_R(IDS_TAB_SOLID_OFF)); else *pText += String_256(_R(IDS_TAB_SOLID_ON)); } // Is the click-while-dragging preference is set for dropping copies? if (ClickWhileDragFunc>1) { //Yes. Show the "dropping copies" status bar text *pText += String_256(_R(IDS_DROP_COPY)); } else { //Otherwise, the preference is set so that clicking while dragging //sets the LeaveCopy flag. Show the "leaving copies" status bar text. if (LeaveCopy) *pText += String_256(_R(IDS_LEAVE_COPY_ON_B)); else *pText += String_256(_R(IDS_LEAVE_COPY_OFF_B)); } if (TransFills) *pText += String_256(_R(IDS_TRANSFILLS_ON)); else *pText += String_256(_R(IDS_TRANSFILLS_OFF)); if (StatusHelpID2!=0) *pText += String_256(StatusHelpID2); if (CanScaleLines) { if (ScaleLines) *pText += String_256(_R(IDS_SCALELINES_ON)); else *pText += String_256(_R(IDS_SCALELINES_OFF)); } }

virtual Matrix TransOperation::GetCurrentMatrix (  void   )  [inline, virtual]

Reimplemented from Operation. Definition at line 240 of file transop.h. { return Transform; };

DocCoord TransOperation::GetStartPos (   )  [protected]

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. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 05/04/95 Returns: DocCoord of start of drag. Definition at line 911 of file transop.cpp. { DocView* pDocView = DocView::GetSelected(); if (pDocView && pDocView->GetSnapToObjectsState()) return MagStartPos; else return StartPos; }

OpState TransOperation::GetState (  String_256 *  Description, OpDescriptor *  )  [static]

Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Reimplemented in OpAlign, OpNudge, OpPullOntoGrid, OpPageResize, OpPathNudge, and OpMovePathPoint. Definition at line 1673 of file transop.cpp. { OpState Blobby; return Blobby; }

BOOL TransOperation::GetStatusLineText (  String_256 *  pText, Spread *  , DocCoord  , ClickModifiers  )  [private, virtual]

get status line hlep for drag op Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 16/02/95 Parameters: Spread*,DocCoord,ClickModifiers  - not used [INPUTS] pText  - [OUTPUTS] Returns: TRUE if returning valid text Errors: this==NULL Reimplemented from Operation. Definition at line 2263 of file transop.cpp. { ERROR2IF(this==NULL, FALSE,"TransOperation::GetStatusLineText() - this==NULL"); ERROR2IF(pText==NULL,FALSE,"TransOperation::GetStatusLineText() - pText==NULL"); FigureStatusText(pText); return TRUE; }

Range* TransOperation::GetTransformRange (   )  [inline]

Definition at line 242 of file transop.h. { return m_pTransformRange; }

void TransOperation::InitTransformImmediate (  OpParam *   )  [private, virtual]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 27/7/94 Parameters: OpParam  - The operations parameters [INPUTS] Reimplemented in OpFlipTrans, OpRotateTrans, OpScaleTrans, OpShearTrans, OpSquashTrans, OpSliceTranslate, and OpTranslateTrans. Definition at line 1696 of file transop.cpp. { }

void TransOperation::InitTransformOnDrag (  DocCoord  PointerPos, ClickModifiers  ClickMods )  [private, virtual]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: PointerPos  - The position of the mouse at the start of the drag [INPUTS] ClickMods - the keyboard modifiers that were active at the start of the drag Reimplemented in OpRotateTrans, OpScaleTrans, OpShearTrans, OpSquashTrans, OpSliceTranslate, and OpTranslateTrans. Definition at line 1714 of file transop.cpp. { // Overide this function if your transformation operation needs to do anything // set up the matrix builder in a drag version. }

BOOL TransOperation::LeaveCopyOfSelection (   )  [private]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/7/94 Returns: TRUE if it worked, FALSE if it did not See also: TransOperation::CompleteTransformation() Definition at line 2214 of file transop.cpp. { // we have to go through the current selection and make copies of all the nodes Node* pNode = m_pTransformRange->FindFirst(); while (pNode!=NULL) { // Make sure that the node is bounded ENSURE(pNode->IsKindOf(CC_RUNTIME_CLASS(NodeRenderableBounded)), "Selected node was not bounded"); // Go and find the next selected node before we do any insertions Node* pNext = m_pTransformRange->FindNext(pNode); // Make a copy of this node and return FALSE if it failed Node* pCopy; if (!pNode->NodeCopy(&pCopy)) return FALSE; // Ensure that the copy is not selected pCopy->SetSelected(FALSE); // Insert the new node into the tree just after the original, // without effecting the selection, or forcing a redraw. if (!DoInsertNewNode((NodeRenderableBounded*)pCopy, pNode, PREV, FALSE, FALSE, FALSE)) return FALSE; // Find the next node to copy pNode = pNext; } // All worked return TRUE; }

virtual BOOL TransOperation::MayChangeNodeBounds (   )  const [inline, virtual]

Reimplemented from UndoableOperation. Definition at line 299 of file transop.h. { return TRUE; }

void TransOperation::OnClickWhileDragging (  OilCoord  PointerPos, ClickType  Click, ClickModifiers  Mods, BOOL  bSolidDrag )  [virtual]

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. void TransOperation::OnClickWhileDragging(OilCoord PointerPos, ClickType Click, ClickModifiers Mods, BOOL bSolidDrag) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 18/6/96 Parameters: OilCoord  PointerPos: position of click [INPUTS] ClickType Click: single, double or triple ClickModifiers Mods: whether shift, ctrl etc was pressed during the click -  [OUTPUTS] Returns: - This case of the virtual function overrides the empty virtual function Operation::OnClickWhileDragging. This function calls DragCopyAction to find out what the function assigned to Clicks-While-Dragging is. Feel free to add other overriding functions to handle clicks-while- dragging for other operations. Returns: Errors: None. See also: ClickModifiers::ClickWhileDrag (member variable); DocView::OnClick; ScreenView::HandleDragEvent; ScreenView::HandleButtonUp; TransOperation::OnClickWhileDragging Reimplemented from Operation. Definition at line 1566 of file transop.cpp. { //If Click is an up-click, we are not interested in this particular case if (Click==CLICKTYPE_UP) return; // Karim 21/06/2000 similarly to the way we handle tapping '+' while dragging, // we only acknowledge the click if select-inside is not present. if (!m_pTransformRange->ContainsSelectInside()) { //Do whatever the ClickWhileDragging preference says we should do DragCopyAction(bSolidDrag); } //And update the status bar String_256 Text; FigureStatusText(&Text); GetApplication()->UpdateStatusBarText(&Text); }

void TransOperation::RenderDragBlobs (  DocRect  ClipRect, Spread *  pSpread, BOOL  bSolidDrag )  [virtual]

Draws the EORed stuff ("blobs") to the screen during a drag. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/93 Parameters: ClipRect  - NULL, or the region that needs to be redrawn [INPUTS] pSpread - The spread to render to See also: Operation::RenderDragBlobs Reimplemented from Operation. Definition at line 1599 of file transop.cpp. { // If solid dragging is turned on, only render any if we have turned them on! if (bSolidDrag) { if (m_bShowOriginalOutlines) m_pTransformRange->RenderXOROutlinesToCatchUp(&ClipRect, CurrentSpread, &OriginalTransform); if (m_bShowDraggedOutlines) m_pDraggedRange->RenderXOROutlinesToCatchUp(&ClipRect, CurrentSpread, &OriginalTransform); return; } // Build the transform matrix BuildMatrix(); // draw the blobs for the specific region up to the same level as everywhere else if (pSpread==CurrentSpread) m_pTransformRange->RenderXOROutlinesToCatchUp(&ClipRect, CurrentSpread, &Transform); }

void TransOperation::SelectNodeAfterDrag (  Node *  NodeToSelect  )

>>> void TransOperation::SelectNodeAfterDrag (Node* NodeToSelect) Author: Graham_Walmsley (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/96 Parameters: The  node we want to select after the drag [INPUTS] Purpose Adds the node to list of nodes to select after the drag Definition at line 2522 of file transop.cpp. { NodeListItem* pnliNode=new NodeListItem(NodeToSelect); lstNodesToSelect.AddTail((ListItem*) pnliNode); }

BOOL TransOperation::SetLeaveCopy (   )

Definition at line 2500 of file transop.cpp. { //If SelectInside is off, set the LeaveCopy flag and corresponding BoundingData flags. if (!m_pTransformRange->ContainsSelectInside()) { LeaveCopy = !LeaveCopy; BoundingData.LeaveCopy = LeaveCopy; BoundingData.LeaveCopyChanged = TRUE; } return TRUE; }

void TransOperation::SetStartBlob (  INT32  StartBlob  )  [private, virtual]

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 25/7/94 Parameters: StartBlob  - the Number of the blob that the operation was initiated on, [INPUTS] if applicabale. They are numbered as follows :- MonoOn 1 2 3 4 5 6 7 8 MonoOff All operations that were not started from one of the 8 blobs should use 0 Reimplemented in OpFlipTrans, OpScaleTrans, OpShearTrans, and OpSquashTrans. Definition at line 1828 of file transop.cpp. { }

BOOL TransOperation::SetTransformRange (  Range *  pTransformRange, Node *  pTransformNode )  [private]

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. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 17/12/2003 Returns: - Definition at line 2557 of file transop.cpp. { // If we have a good range and we're being given the same range then do nothing if (m_pTransformRange!=NULL && pTransformRange==m_pTransformRange) return TRUE; // If we have a good range and the caller is giving us nothing then do nothing if (m_pTransformRange && pTransformRange==NULL && pTransformNode==NULL) return TRUE; if (pTransformNode) { // Only transforming single node. First check it's correct type ERROR3IF(!pTransformNode->IS_KIND_OF(NodeRenderableBounded), "Should be bounded"); m_pTransformRange = new Range(pTransformNode, pTransformNode, RangeControl(TRUE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE,TRUE)); ERROR2IF(m_pTransformRange==NULL, FALSE, "Can't create simple range"); } else { if (pTransformRange) { m_pTransformRange = new Range(*pTransformRange); ERROR2IF(m_pTransformRange == NULL, FALSE, "No supplied range"); } else { m_pTransformRange = new Range(*(GetApplication()->FindSelection())); ERROR2IF(m_pTransformRange == NULL, FALSE, "No selected range"); m_pTransformRange->SetPromoteToParent(TRUE); } } // If this goes off there's a logical error in the above code that works // out the range to transform. ERROR3IF(!m_pTransformRange, "No range to transform in TransOperation::DoStartTransOp"); return (m_pTransformRange!=NULL); }

BOOL TransOperation::ShouldPointerBeOffset (   )  [virtual]

Allows the transforms to decide if they want the mouse position to be moved for them to the edge of the selection. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 13/9/94 Returns: TRUE if the transform wants the mouse pointer to be offsets to the edge of the selection, FALSE if it wants it left alone. Reimplemented in OpRotateTrans, OpSliceTranslate, and OpTranslateTrans. Definition at line 888 of file transop.cpp. { return TRUE; }

BOOL TransOperation::SolidDragTransform (  BOOL  bForceRecopy = FALSE, BOOL  bForceRedraw = TRUE )  [private]

Transform the selection into the drag range. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 2/12/2003 Returns: TRUE if it worked Definition at line 2019 of file transop.cpp. { BOOL TransOK = FALSE; if (m_pDraggedRange==NULL) return FALSE; // Build the appropriate transform object to transform the selection Trans2DMatrix* Trans; Trans = new Trans2DMatrix(Transform); // See if the memory allocation worked if (Trans == NULL) return FALSE; //TRACEUSER( "Phil", _T("SolidDragTransform hscale = %f, %f\n"), Trans->GetScale().MakeDouble(), Trans->GetAspect().MakeDouble()); // Set the flags in the transform according to the flags set here Trans->TransFills = TransFills; Trans->TransLines = ScaleLines && CanScaleLines; // Get rid of the last set of dragged objects and make a new copy of the selection // Note! This would be much faster if just the coords of the drag selection could be transformed! // Redraw just the current view m_pDraggedRange->ForceRedrawView(GetWorkingDocView(), TRUE, m_bFirstRedraw); m_bFirstRedraw = FALSE; BOOL bQualNotSolid = !(GetWorkingDocView()->RenderQuality.GetFillQuality() > Quality::Solid); #if SOLID_TRANSFORM_METHOD == 1 // Update the dragged objects the dumb way - by deleting and recreating them m_pDraggedRange->DeleteNodes(); delete m_pDraggedRange; m_pDraggedRange = m_pTransformRange->CloneNodes(DocView::SolidDragTimeLimit); if (m_pDraggedRange==NULL) return FALSE; m_pDraggedRange->SetDraggedNodes(TRUE); m_pDraggedRange->SetRenderable(TRUE); // Scan the selection, and transform each selected object. Trans->bSolidDrag = TRUE; Trans->bHaveTransformedAllCached = TRUE; // having transformed none we can say all caches have been transformed Trans->bHaveTransformedAllChildren = TRUE; // having transformed none we can say all caches have been transformed Trans->bTransformYourChildren = bQualNotSolid; // The transform does not have to transform all its data TransOK = m_pDraggedRange->TransformNodes(Trans); m_bRangeCacheTransformed = Trans->bHaveTransformedAllCached; m_bRangeFullyTransformed = Trans->bHaveTransformedAllChildren; #endif #if SOLID_TRANSFORM_METHOD == 2 // Update the dragged objects the smart way by copying the contents of the selection // into the dragged nodes m_pTransformRange->CopyNodesContents(m_pDraggedRange, TRUE, TRUE); // Scan the selection, and transform each selected object. Trans->bSolidDrag = TRUE; Trans->bHaveTransformedAllCached = TRUE; // having transformed none we can say all caches have been transformed Trans->bHaveTransformedAllChildren = TRUE; // having transformed none we can say all caches have been transformed Trans->bTransformYourChildren = bQualNotSolid; // The transform does not have to transform all its data TransOK = m_pDraggedRange->TransformNodes(Trans); m_bRangeCacheTransformed = Trans->bHaveTransformedAllCached; m_bRangeFullyTransformed = Trans->bHaveTransformedAllChildren; #endif #if SOLID_TRANSFORM_METHOD == 3 // Move objects back to original position simply by premultiplying the transformation // matrix by the inverse of the previous transform m_PrevTransform.Invert(); m_PrevTransform *= *Trans; // Scan the selection, and transform each selected object. m_PrevTransform.bSolidDrag = TRUE; m_PrevTransform.bHaveTransformedAllCached = TRUE; // having transformed none we can say all caches have been transformed m_PrevTransform.bHaveTransformedAllChildren = TRUE; // having transformed none we can say all caches have been transformed m_PrevTransform.bTransformYourChildren = bQualNotSolid; // The transform does not have to transform all its data TransOK = m_pDraggedRange->TransformNodes(&m_PrevTransform); m_bRangeCacheTransformed = Trans->bHaveTransformedAllCached; m_bRangeFullyTransformed = Trans->bHaveTransformedAllChildren; m_PrevTransform = *Trans; // Store previous transform #endif #if SOLID_TRANSFORM_METHOD == 4 // If the dragged objects have become innacurate compared to the transformed // originals then we must ReCopy, else we can continue to transform the dragged // objects // // Get width/height of dragged objects // Calc width height of transformed original bounds // If the two differ by more than half a pixel // Recopy // DocRect tr = DocRect(OriginalBounds[0].x, OriginalBounds[0].y, OriginalBounds[2].x, OriginalBounds[2].y); m_PrevTransform.Transform((DocCoord*)&tr, 2); //TRACEUSER( "Phil", _T("M4 Test %d %d\n"), abs(tr.lox-m_AccuracyTestRect.lox), abs(tr.loy-m_AccuracyTestRect.loy)); // We may need to move the dragged range to a new spread if the transform requires it... if (CanChangeSpread() && (m_pDragSpread!=CurrentSpread)) { // Move m_DraggedRange to the new spread //TRACEUSER("Phil", _T("Move m_Dragged range to new spread!\n")); bForceRecopy = TRUE; } if( bForceRecopy || abs( tr.lo.x - m_AccuracyTestRect.lo.x ) > 10 || abs( tr.lo.y - m_AccuracyTestRect.lo.y ) > 10 || abs( tr.hi.x - m_AccuracyTestRect.hi.x ) > 10 || abs( tr.hi.y - m_AccuracyTestRect.hi.y ) > 10 ) { //TRACEUSER( "Phil", _T("M4 Recopy %f\n"), Trans->GetScale().MakeDouble()); // Update the dragged objects the dumb way - by deleting and recreating them m_pDraggedRange->DeleteNodes(); delete m_pDraggedRange; Layer* pTargetLayer = NULL; if (CurrentSpread!=m_pDragSpread) pTargetLayer = CurrentSpread->FindActiveLayer(); // This logic must match the final copy done in DragFinished m_pDraggedRange = m_pTransformRange->CloneNodes(DocView::SolidDragTimeLimit, FALSE, FALSE, pTargetLayer); if (m_pDraggedRange==NULL) return FALSE; m_pDraggedRange->SetDraggedNodes(TRUE); m_pDraggedRange->SetRenderable(TRUE); m_pDragSpread = CurrentSpread; // Scan the selection, and transform each selected object. Trans->bSolidDrag = TRUE; Trans->bHaveTransformedAllCached = TRUE; Trans->bHaveTransformedAllChildren = TRUE; Trans->bTransformYourChildren = bForceRecopy | bQualNotSolid; // if forced recopy then also force transformation of everything TransOK = m_pDraggedRange->TransformNodes(Trans); m_bRangeCacheTransformed = Trans->bHaveTransformedAllCached; m_bRangeFullyTransformed = Trans->bHaveTransformedAllChildren; // Reset accuracy test rect because we have just reset the dragged objects m_AccuracyTestRect = DocRect(OriginalBounds[0].x, OriginalBounds[0].y, OriginalBounds[2].x, OriginalBounds[2].y); Trans->Transform((DocCoord*)&m_AccuracyTestRect, 2); } else { //TRACEUSER( "Phil", _T("M4 Transform\n")); // Move objects back to original position simply by premultiplying the transformation // matrix by the inverse of the previous transform m_PrevTransform.Invert(); m_PrevTransform *= *Trans; // Scan the selection, and transform each selected object. m_PrevTransform.bSolidDrag = TRUE; m_PrevTransform.bHaveTransformedAllCached = TRUE; // having transformed none we can say all caches have been transformed m_PrevTransform.bHaveTransformedAllChildren = TRUE; // having transformed none we can say all caches have been transformed m_PrevTransform.bTransformYourChildren = bQualNotSolid; // The transform does not have to transform all its data TransOK = m_pDraggedRange->TransformNodes(&m_PrevTransform); m_bRangeCacheTransformed = m_PrevTransform.bHaveTransformedAllCached; m_bRangeFullyTransformed = m_PrevTransform.bHaveTransformedAllChildren; // Transform accuracy test rect in the same way we have just done for the dragged objects // to track what's hapenning to them... m_PrevTransform.Transform((DocCoord*)&m_AccuracyTestRect, 2); } m_PrevTransform = *Trans; #endif if (m_pDraggedRange && bForceRedraw) m_pDraggedRange->ForceRedrawView(GetWorkingDocView(), TRUE); if (!TransOK) return FALSE; delete Trans; return TRUE; }

BOOL TransOperation::TransformOverlapsOriginal (   )  [private]

Check whether transform objects overlap originals. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 19/03/2004 Returns: TRUE if the original bounds overlap the transformed bounds Definition at line 2611 of file transop.cpp. { DocRect TransformBounds(BoundingData.x, BoundingData.y, BoundingData.x+BoundingData.Width, BoundingData.y+BoundingData.Height ); DocRect OrigBounds(OriginalBounds[0].x, OriginalBounds[0].y, OriginalBounds[2].x, OriginalBounds[2].y); return (TransformBounds.IsIntersectedWith(OrigBounds)); }

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

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. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/8/94 Reimplemented in OpRotateTrans, OpScaleTrans, and OpSquashTrans. Definition at line 1850 of file transop.cpp. { #ifndef STANDALONE // Tell the tool about the current transform bounding data if (pSelTool != NULL) { pSelTool->DragMove(&BoundingData); } #endif }

void TransOperation::UpdateTransformOnDrag (  DocCoord  , Spread *  , ClickModifiers &  )  [private, virtual]

This function re-calculates the parameters specific to the transform based on the mouse position. This is only used in interactive drag style transforms. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/7/94 Parameters: PointerPos  - The position of the mouse [INPUTS] Spread - The spread that the mouse is over right now ClickModifiers - The current click modifiers Reimplemented in OpRotateTrans, OpScaleTrans, OpShearTrans, OpSquashTrans, OpSliceTranslate, and OpTranslateTrans. Definition at line 1737 of file transop.cpp. { // Overide this function if you need to do anything during a mouse move }

---

Member Data Documentation

BOOL TransOperation::AbortTransAtEnd [protected]

Definition at line 405 of file transop.h.

DocCoord TransOperation::BoundingCentre [protected]

Definition at line 369 of file transop.h.

TransformBoundingData TransOperation::BoundingData [protected]

Definition at line 349 of file transop.h.

BOOL TransOperation::CanScaleLines [protected]

Definition at line 401 of file transop.h.

DocCoord TransOperation::CentreOfTrans [protected]

Definition at line 361 of file transop.h.

INT32 TransOperation::ClickWhileDragFunc [static, protected]

Definition at line 408 of file transop.h.

Spread* TransOperation::CurrentSpread [protected]

Definition at line 363 of file transop.h.

DocCoord TransOperation::LastRawPos [protected]

Definition at line 359 of file transop.h.

BOOL TransOperation::LeaveCopy [protected]

Definition at line 397 of file transop.h.

BOOL TransOperation::LockAspect [protected]

Definition at line 396 of file transop.h.

List TransOperation::lstNodesToSelect

Definition at line 294 of file transop.h.

DocRect TransOperation::m_AccuracyTestRect [protected]

Definition at line 435 of file transop.h.

BOOL TransOperation::m_bFirstRedraw [protected]

Definition at line 426 of file transop.h.

BOOL TransOperation::m_bRangeCacheTransformed [protected]

Definition at line 430 of file transop.h.

BOOL TransOperation::m_bRangeFullyTransformed [protected]

Definition at line 431 of file transop.h.

BOOL TransOperation::m_bShowDraggedOutlines [protected]

Definition at line 427 of file transop.h.

BOOL TransOperation::m_bShowOriginalOutlines [protected]

Definition at line 429 of file transop.h.

Range* TransOperation::m_pDraggedRange [protected]

Definition at line 421 of file transop.h.

Spread* TransOperation::m_pDragSpread [protected]

Definition at line 424 of file transop.h.

Trans2DMatrix TransOperation::m_PrevTransform [protected]

Definition at line 434 of file transop.h.

List* TransOperation::m_pSelList [protected]

Definition at line 418 of file transop.h.

Range* TransOperation::m_pTransformRange [protected]

Definition at line 389 of file transop.h.

MonotonicTime TransOperation::m_timeIdle [protected]

Definition at line 428 of file transop.h.

BOOL TransOperation::MagneticGripPoint [protected]

Definition at line 365 of file transop.h.

DocCoord TransOperation::MagStartPos [protected]

Definition at line 356 of file transop.h.

BOOL TransOperation::MouseHasMoved [protected]

Definition at line 400 of file transop.h.

Node* TransOperation::ObjectUnderCursor [protected]

Definition at line 383 of file transop.h.

DocCoord TransOperation::Offset [protected]

Definition at line 364 of file transop.h.

Coord TransOperation::OriginalBounds[4] [protected]

Definition at line 353 of file transop.h.

DocCoord TransOperation::OriginalCentre [protected]

Definition at line 370 of file transop.h.

Matrix TransOperation::OriginalTransform [protected]

Definition at line 374 of file transop.h.

DragTool* TransOperation::pSelTool [protected]

Definition at line 346 of file transop.h.

DocCoord TransOperation::RawPos [protected]

Definition at line 358 of file transop.h.

DocCoord TransOperation::RawStartPos [protected]

Definition at line 357 of file transop.h.

BOOL TransOperation::RecordTwice [protected]

Definition at line 378 of file transop.h.

BOOL TransOperation::ScaleLines [protected]

Definition at line 398 of file transop.h.

SelectionState* TransOperation::SelState [protected]

Definition at line 393 of file transop.h.

DocCoord TransOperation::StartPos [protected]

Definition at line 355 of file transop.h.

Spread* TransOperation::StartSpread [protected]

Definition at line 362 of file transop.h.

UINT32 TransOperation::StatusHelpID [protected]

Definition at line 411 of file transop.h.

UINT32 TransOperation::StatusHelpID2 [protected]

Definition at line 414 of file transop.h.

BOOL TransOperation::TransFills [protected]

Definition at line 399 of file transop.h.

Matrix TransOperation::Transform [protected]

Definition at line 373 of file transop.h.

---

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

• Kernel/transop.h (r1785/r1282)
• Kernel/transop.cpp (r1785/r1393)

---