Extender Class Reference

Preliminary container class for Extend() function. This performs automatic extension and stretching of nodes. More...

#include <extender.h>

List of all members.

Static Public Member Functions
static DocRect	CheckValidExtend (NodeRenderableInk *pNode, BYTE fExtendFlags, const DocRect &drTriggerRelation, const DocRect &drTargetRelation, const DocRect &drThisTrigger, const DocRect &drLastTrigger, const DocRect &drLastTarget, BOOL *pOK=NULL, const BOOL ExtendAroundTarget=FALSE)
	This function tests whether or not a call to the extend function will extend an object in a valid way. For example, a path cannot be shrunken so that its control points cross its centre, as this operation is irreversible - if the path was extended back again, these points would extend the wrong direction. Similarly, an invalid extend occurs when a trigger set is shrunk so that its centre happens to move over the centre of a target node which is not moving in this particular extension; undoing this operation would end up dragging the target node back with the trigger.
static void	Extend (NodeRenderableInk *pNode, BYTE fExtendFlags, const DocRect &drTriggerRelation, const DocRect &drTargetRelation, const DocRect &drNewTrigger, const DocRect &drLastTrigger, const DocRect &drLastTarget, const DocRect *pdrDifference=NULL, const BOOL ExtendAroundTarget=FALSE, UndoableOperation *pOp=NULL)
	Perform an extend operation on the given Node and its children, using the given rectangles and flags to determine how the Node should transform.
static BOOL	ConvertQuickShapesInSelRangeToPaths (UndoableOperation *pUndoOp, Range *pRange)
	Iterates over the given SelRange looking for any NodeRegularShapes, ie QuickShapes. If we find any then they get zapped, and all that is left is a smoking pair of shoes! ... erm, sorry - a NodePath.
static BOOL	CheckValidExtend (NodeRenderableInk *pNode, DocRect *pStartRect, DocRect *pEndRect, BYTE fStretchType, DocRect *pOldStartRect=NULL)
	** DEPRECATED - DO NOT CALL **
static void	Extend (NodeRenderableInk *pNode, DocRect *pStartRect, DocRect *pEndRect, BYTE fStretchType, DocRect *pOldStartRect=NULL)
	** DEPRECATED - DO NOT CALL **
static DocRect	ValidateControlPoints (INT32 numPoints, const DocCoord *doccArray, const ExtendParams &ExtParams)
	Validate the given points, using the provided extend parameters. If extending the points is invalid, then return a rectangle containing the largest distances which the points can be shrunk in by.
static void	CalculateExtendParams (ExtendParams *pEPS, BYTE fExtendFlags, const DocRect &drTriggerRelation, const DocRect &drTargetRelation, const DocRect &drNewTrigger, const DocRect &drLastTrigger, const DocRect &drLastTarget, const DocRect *pdrDifference=NULL, const BOOL ExtendAroundTarget=FALSE)
	Given the rectangles and flags which define an extension, this function derives the bare information which a Node requires to perform the extension on itself.
Private Member Functions
	CC_DECLARE_MEMDUMP (Extender)
Static Private Member Functions
static INT32	CheckInvalidShrinkingPoints (INT32 nCentre, INT32 nDelta, INT32 nOffset, INT32 nNumPoints, const DocCoord *doccArray, BOOL bExamineX)
	Check whether any of the points in the given array will be shrunk past the given limiting value. If all the points check out, we return an all-clear value, which is negative. Otherwise, the maximum safe shrinkage is given.
static INT32	CheckInvalidExpandingPoints (INT32 nCentre, INT32 nDelta, INT32 nOffset, INT32 nNumPoints, const DocCoord *doccArray, BOOL bExamineX)
	Two checks:.
static INT32	CheckLimits (const INT32 limit, const INT32 delta, const INT32 value)
	Checks that the given value may be reduced by the amount delta without going below the given limit value. If it cannot, we return the most which the given value can be safely reduced by.

---

Detailed Description

Preliminary container class for Extend() function. This performs automatic extension and stretching of nodes.

Author:

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

Date:

10/09/1999

Stretching is defined as application of a matrix transformation to control points, causing the points to scale and translate. The distance a point is moved depends on its own distance from some centre - think 'x -> ax+b'.

Extension is defined as translation of control points, depending on their initial position. All points are moved by the same fixed amount, although the direction* follows the same rules as for stretching - 'x -> x +/- delta'. See also:

Definition at line 203 of file extender.h.

---

Member Function Documentation

void Extender::CalculateExtendParams (  ExtendParams *  pEPS, BYTE  fExtendFlags, const DocRect &  drTriggerRelation, const DocRect &  drTargetRelation, const DocRect &  drNewTrigger, const DocRect &  drLastTrigger, const DocRect &  drLastTarget, const DocRect *  pdrDifference = NULL, const BOOL  ExtendAroundTarget = FALSE )  [static]

Given the rectangles and flags which define an extension, this function derives the bare information which a Node requires to perform the extension on itself. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/1999 Parameters: pEPS  pointer to an ExtendParams object to fill. [INPUTS] fExtendFlags bitwise flags, describing any combination of x- or y- stretching or extending, except that you may not extend and stretch along an axis at the same time. Values: X_EXTEND the node should be extended along the x-axis Y_EXTEND the node should be extended along the y-axis X_STRETCH the node should be stretched along the x-axis Y_STRETCH the node should be stretched along the y-axis drTriggerRelation relationship rectangle - the bounding box of the trigger sets when the relationship is defined. drTargetRelation relationship rectangle - the bounding box of the target sets when the relationship is defined. drNewTrigger bounding box of sets of triggers which started the call to this function. drLastTrigger the bounding box of the trigger set(s) before it changed. drLastTarget the bounding box of the target set before it is extended. pdrDifference a rectangle containing four difference parameters which may be used to alter the extend. ok to omit or be NULL. Parameters: *pEPS  will be set up to contain extend information derived from the inputs. [OUTPUTS] Returns: Errors: ERROR3 in debug builds if pEPS is NULL. See also: Extender::Extend(). Definition at line 987 of file extender.cpp. { // validate input. ERROR3IF(pEPS == NULL, "Extender::CalculateExtendParams- pEPS is NULL!"); // use the relationship rects and the new trigger rect to calculate the new target rect. DocRect drNewTarget(drNewTrigger); // x-extend - the new target rect must be x-offset from new-trigger on each // side, by the same amount as target-relation from trigger-relation. if (fExtendFlags & X_EXTEND) { // if the trigger and target-relation rects do not overlap in the x-direction, // then the new target rect must be x-offset from new-trigger on its near-side, // by the same amount as target-relation from trigger-relation. if (drTargetRelation.lo.x > drTriggerRelation.hi.x) { drNewTarget.lo.x = drNewTrigger.hi.x + (drTargetRelation.lo.x - drTriggerRelation.hi.x); drNewTarget.hi.x = drNewTrigger.hi.x + (drTargetRelation.hi.x - drTriggerRelation.hi.x); } else if (drTargetRelation.hi.x < drTriggerRelation.lo.x) { drNewTarget.lo.x = drNewTrigger.lo.x - (drTriggerRelation.lo.x - drTargetRelation.lo.x); drNewTarget.hi.x = drNewTrigger.lo.x - (drTriggerRelation.lo.x - drTargetRelation.hi.x); } // normal extend behaviour - distances between corresponding sides are kept constant. else { drNewTarget.lo.x += drTargetRelation.lo.x - drTriggerRelation.lo.x; drNewTarget.hi.x += drTargetRelation.hi.x - drTriggerRelation.hi.x; // if the target's new sides are coincident or invalid, then // they need to be moved back into valid positions. if (drNewTarget.lo.x >= drNewTarget.hi.x) { drNewTarget.hi.x = drNewTarget.lo.x + 2; } } } else if (fExtendFlags & X_STRETCH) { double a = drNewTrigger.Width() / (double)drTriggerRelation.Width(); INT32 b = drNewTrigger.hi.x - (INT32)(a * drTriggerRelation.hi.x); drNewTarget.lo.x = b + (INT32)(a * drTargetRelation.lo.x); drNewTarget.hi.x = b + (INT32)(a * drTargetRelation.hi.x); } // y-extend - the new target rect must be y-offset from new-trigger on top and // bottom, by the same amount as target-relation from trigger-relation. if (fExtendFlags & Y_EXTEND) { // if the trigger and target-relation rects do not overlap in the y-direction, // then the new target rect must be y-offset from new-trigger on its near-side, // by the same amount as target-relation from trigger-relation. if (drTargetRelation.lo.y > drTriggerRelation.hi.y) { drNewTarget.lo.y = drNewTrigger.hi.y + (drTargetRelation.lo.y - drTriggerRelation.hi.y); drNewTarget.hi.y = drNewTrigger.hi.y + (drTargetRelation.hi.y - drTriggerRelation.hi.y); } else if (drTargetRelation.hi.y < drTriggerRelation.lo.y) { drNewTarget.lo.y = drNewTrigger.lo.y - (drTriggerRelation.lo.y - drTargetRelation.lo.y); drNewTarget.hi.y = drNewTrigger.lo.y - (drTriggerRelation.lo.y - drTargetRelation.hi.y); } // normal extend behaviour - distances between corresponding sides are kept constant. else { drNewTarget.lo.y += drTargetRelation.lo.y - drTriggerRelation.lo.y; drNewTarget.hi.y += drTargetRelation.hi.y - drTriggerRelation.hi.y; // if the target's new top and bottom are coincident or invalid, then // they need to be moved back into valid positions. if (drNewTarget.lo.y >= drNewTarget.hi.y) { drNewTarget.hi.y = drNewTarget.lo.y + 2; } } } else if (fExtendFlags & Y_STRETCH) { double a = drNewTrigger.Height() / (double)drTriggerRelation.Height(); INT32 b = drNewTrigger.hi.y - (INT32)(a * drTriggerRelation.hi.y); drNewTarget.lo.y = b + (INT32)(a * drTargetRelation.lo.y); drNewTarget.hi.y = b + (INT32)(a * drTargetRelation.hi.y); } // use the old and new target rectangles to calculate our extension working values. // extend flags. pEPS->fExtendFlags = fExtendFlags; // the start- and end- centres of extension + the offset between them. // Karim 14/03/2000 - changed to use the trigger set bounds if their old centre // lies within the bounds of the old target set. if (!ExtendAroundTarget && drLastTarget.ContainsCoord(drLastTrigger.Centre())) { pEPS->doccStartCentre = drLastTrigger.Centre(); pEPS->doccEndCentre = drNewTrigger.Centre(); pEPS->doccOffset = pEPS->doccEndCentre - pEPS->doccStartCentre; } else { pEPS->doccStartCentre = drLastTarget.Centre(); pEPS->doccEndCentre = drNewTarget.Centre(); pEPS->doccOffset = pEPS->doccEndCentre - pEPS->doccStartCentre; } // magnitudes of extension. note that under extension, objects are first offset // from start- to end- centre, then extended. this makes extension mirror-symmetric // so that xinc == xdec (+/- 1). pEPS->xinc = drNewTarget.hi.x - (drLastTarget.hi.x + pEPS->doccOffset.x); pEPS->xdec = (drLastTarget.lo.x + pEPS->doccOffset.x) - drNewTarget.lo.x; pEPS->yinc = drNewTarget.hi.y - (drLastTarget.hi.y + pEPS->doccOffset.y); pEPS->ydec = (drLastTarget.lo.y + pEPS->doccOffset.y) - drNewTarget.lo.y; // scale factors, if automatic _stretching_ is required. pEPS->xscale = drNewTarget.Width() / (double)drLastTarget.Width(); pEPS->yscale = drNewTarget.Height() / (double)drLastTarget.Height(); // if our difference rect is non-NULL, then we may need to substitute // xinc, xdec, yinc, ydec with negative copies of some of its values. if (pdrDifference != NULL) { if (pdrDifference->lo.x != INT32_MAX) pEPS->xdec = -pdrDifference->lo.x; if (pdrDifference->lo.y != INT32_MAX) pEPS->ydec = -pdrDifference->lo.y; if (pdrDifference->hi.x != INT32_MAX) pEPS->xinc = -pdrDifference->hi.x; if (pdrDifference->hi.y != INT32_MAX) pEPS->yinc = -pdrDifference->hi.y; } // TODO: should probably not use these, but the equivalent of b (used above) instead. pEPS->doccScaleStart = drLastTarget.lo; pEPS->doccScaleEnd = drNewTarget.lo; // set the various dead-zones; these depend on the signs of the expansions in each dirn. pEPS->xincExtendBuffer = (pEPS->xinc >= 0) ? EXT_EXPAND_BUFFER : EXT_SHRINK_BUFFER; pEPS->xdecExtendBuffer = (pEPS->xdec >= 0) ? EXT_EXPAND_BUFFER : EXT_SHRINK_BUFFER; pEPS->yincExtendBuffer = (pEPS->yinc >= 0) ? EXT_EXPAND_BUFFER : EXT_SHRINK_BUFFER; pEPS->ydecExtendBuffer = (pEPS->ydec >= 0) ? EXT_EXPAND_BUFFER : EXT_SHRINK_BUFFER; }

Extender::CC_DECLARE_MEMDUMP (  Extender   )  [private]

INT32 Extender::CheckInvalidExpandingPoints (  INT32  nCentre, INT32  nDelta, INT32  nOffset, INT32  nNumPoints, const DocCoord *  doccArray, BOOL  bExamineX )  [static, private]

Two checks:. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 25/01/2000 Parameters: nCentre  the centre x- or y- value from which point are expanding. [INPUTS] nDelta (currently unused) the distance by which the points are moving. nOffset an offset which should be applied to the points before testing. nNumPoints the number of points to test. doccArray the array of points to test. bExamineX whether to examine x-coords (TRUE) or y-coords (FALSE). [OUTPUTS]  Returns: Negative value if all points can expand safely away from nCentre, or Zero if any of the points cannot be safely moved away. No points may lie inside the dead-zone. Due to rounding errors, the centre-point of an object depends on whether its width is even or odd. There is a potential for error here, if a point lying one millipoint outside the dead zone is moved out from the centre, and the operation then reversed. If the centre-point changes position due to a new width then the point may be moving back *inside* the dead zone, which will be disallowed -> irreversible operation. This method checks for these points. (boy, what a mouthful!) Assumptions: That the extension being checked is symmetric - ie all points are moving away from the centre point, regardless of their position relative to it. Returns: Errors: See also: Definition at line 1174 of file extender.cpp. { // return with an all-clear if delta is zero. if (nDelta == 0) return -1; // each point should be offset by nOffset, so instead we 'un-offset' the centre. // INT32 myCentre = nCentre - nOffset; /* * Karim 11/05/2000 * Commented out, as this test is being moved into the actual extension code - rather than * have invariant points limit the extension, they will have no effect, and will instead * just not themselves extend. * // The test we do is simple - ensure that no points lie within one millipoint of the // dead zone. We only need one invalid point for the test to fail. BOOL bPassedTest = TRUE; if (bExamineX) { for (INT32 i = 0; i < nNumPoints && bPassedTest; i ++) { bPassedTest = (doccArray[i].x > (myCentre + EXT_EXPAND_BUFFER)) || (doccArray[i].x < (myCentre - EXT_EXPAND_BUFFER)); } } else { for (INT32 i = 0; i < nNumPoints && bPassedTest; i ++) { bPassedTest = (doccArray[i].y > (myCentre + EXT_EXPAND_BUFFER)) || (doccArray[i].y < (myCentre - EXT_EXPAND_BUFFER)); } } return bPassedTest ? -1 : 0; */ return -1; }

INT32 Extender::CheckInvalidShrinkingPoints (  INT32  nCentre, INT32  nDelta, INT32  nOffset, INT32  nNumPoints, const DocCoord *  doccArray, BOOL  bExamineX )  [static, private]

Check whether any of the points in the given array will be shrunk past the given limiting value. If all the points check out, we return an all-clear value, which is negative. Otherwise, the maximum safe shrinkage is given. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 07/12/1999 Parameters: nCentre  the limiting x or y centre-value, to which points are shrinking. [INPUTS] nDelta the distance by which the points are being shrunk. nOffset an offset which should be applied to the points before testing. nNumPoints the number of points to test. doccArray the array of points to test. bExamineX whether to examine x-coords (TRUE) or y-coords (FALSE). [OUTPUTS]  Returns: The maximum safe distance that points can be extended towards nCentre by. This value will be non-negative if any invalid points were found, or negative if all points passed the test. Karim 11/05/2000 With the addition of invariant points, this method only checks those points which would move under extension. If a point is invariant, ie it is so close to nCentre that it would not be moved, it is disregarded. It is up to the various extend methods to ensure that these invariant points actually *stay* invariant! Returns: Errors: See also: Definition at line 824 of file extender.cpp. { // return with an all-clear if delta is zero. if (nDelta == 0) return -1; // test the points we were given, and determine the furthest we can move them without // dragging any into the dead zone, defined as the limit value +/- our buffer size. // this value will be the least of all the maximum distances that each point can // shrink by. INT32 maxShrink, smallest_maxShrink = INT32_MAX; // each point should be offset by nOffset so for testing, we 'un-offset' the centre. INT32 myCentre = nCentre - nOffset; // nDelta < 0 means we are being dragged down or left. // we're checking that each point can stretch by nDelta down towards nCentre. // if it can't, we see how far it _can_ go. if (nDelta < 0) { // validate the x-component of the coordinates. if (bExamineX) { for (INT32 i = 0; i < nNumPoints; i ++) { maxShrink = CheckLimits(myCentre, nDelta, doccArray[i].x); if (maxShrink >= 0 && smallest_maxShrink > maxShrink) smallest_maxShrink = maxShrink; } } // validate the y-component of the coordinates. else { for (INT32 i = 0; i < nNumPoints; i ++) { maxShrink = CheckLimits(myCentre, nDelta, doccArray[i].y); if (maxShrink >= 0 && smallest_maxShrink > maxShrink) smallest_maxShrink = maxShrink; } } } // nDelta > 0 means we are being dragged up or right. // we're checking that each point can stretch by nDelta up towards nCentre. // if it can't, we see how far it _can_ go. else { // validate the x-component of the coordinates. if (bExamineX) { for (INT32 i = 0; i < nNumPoints; i ++) { maxShrink = CheckLimits(myCentre, -nDelta, myCentre - doccArray[i].x + myCentre); if (maxShrink >= 0 && smallest_maxShrink > maxShrink) smallest_maxShrink = maxShrink; } } // validate the y-component of the coordinates. else { for (INT32 i = 0; i < nNumPoints; i ++) { maxShrink = CheckLimits(myCentre, -nDelta, myCentre - doccArray[i].y + myCentre); if (maxShrink >= 0 && smallest_maxShrink > maxShrink) smallest_maxShrink = maxShrink; } } } return smallest_maxShrink == INT32_MAX ? -1 : smallest_maxShrink; }

INT32 Extender::CheckLimits (  const INT32  limit, const INT32  delta, const INT32  value )  [inline, static, private]

Checks that the given value may be reduced by the amount delta without going below the given limit value. If it cannot, we return the most which the given value can be safely reduced by. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 07/12/1999 Parameters: limit  the limiting value to use. [INPUTS] delta the amount to attempt to shrink by - should always be negative. value the value to validate. [OUTPUTS]  Returns: -1 if the validation was successful, non-negative integer value otherwise. A preset buffer value is applied, defining a 'dead zone' around the limit, into which the value may not be reduced. All calculations performed within this method take account of this dead zone. Also note that if a value begins within the dead zone, then an all-clear value of -1 will be returned, as we don't want this invariant point to interfere with shrinking of other values. The actual extension code should always check for and not alter these points. Returns: Errors: ERROR3 if delta is non-negative (ie >= 0). See also: Definition at line 930 of file extender.cpp. { // data validation. ERROR3IF(delta >= 0, "Extender::CheckLimits called with delta non-negative!"); // we return an all-clear if the test value starts in the buffer zone. if (value >= limit - EXT_SHRINK_BUFFER && value <= limit + EXT_SHRINK_BUFFER) return -1; // give the all-clear if the test value lies below the limit value already. // also give the all-clear if the test value will not be drawn down into the dead-zone. if (value < limit - EXT_SHRINK_BUFFER || value + delta > limit + EXT_SHRINK_BUFFER) return -1; // ok, we're invalid - return the safe shrinkage distance for the test value. return value - (limit + EXT_SHRINK_BUFFER + 1); }

BOOL Extender::CheckValidExtend (  NodeRenderableInk *  pNode, DocRect *  pStartRect, DocRect *  pEndRect, BYTE  fExtendFlags, DocRect *  pOldStartRect = NULL )  [static]

** DEPRECATED - DO NOT CALL ** Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 17/11/1999 Parameters: [INPUTS]  [OUTPUTS]  Returns: FALSE Errors: ERROR2 always. See also: Definition at line 186 of file extender.cpp. { ERROR2( FALSE, "This implementation of Extender::CheckValidExtend is no longer used or valid" ); }

DocRect Extender::CheckValidExtend (  NodeRenderableInk *  pNode, BYTE  fExtendFlags, const DocRect &  drTriggerRelation, const DocRect &  drTargetRelation, const DocRect &  drNewTrigger, const DocRect &  drLastTrigger, const DocRect &  drLastTarget, BOOL *  pOK = NULL, const BOOL  ExtendAroundTarget = FALSE )  [static]

This function tests whether or not a call to the extend function will extend an object in a valid way. For example, a path cannot be shrunken so that its control points cross its centre, as this operation is irreversible - if the path was extended back again, these points would extend the wrong direction. Similarly, an invalid extend occurs when a trigger set is shrunk so that its centre happens to move over the centre of a target node which is not moving in this particular extension; undoing this operation would end up dragging the target node back with the trigger. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/1999 Parameters: pNode  pointer to a NodeRenderableInk which will be extended. [INPUTS] fExtendFlags bitwise flags, describing any combination of x- or y- stretching or extending, except that you may not extend and stretch along an axis at the same time. Values: X_EXTEND the node should be extended along the x-axis Y_EXTEND the node should be extended along the y-axis X_STRETCH the node should be stretched along the x-axis Y_STRETCH the node should be stretched along the y-axis drTriggerRelation relationship rectangle - the bounding box of the trigger sets when the relationship is defined. drTargetRelation relationship rectangle - the bounding box of the target sets when the relationship is defined. drNewTrigger bounding box of sets of triggers which started the call to this function. drLastTrigger the bounding box of the trigger set(s) before it changed. drLastTarget the bounding box of the target set before it is extended. This function should always be called on all objects sharing the same name, before* Extender::Extend is called to actually perform the extension on those objects, to make sure that no irreversible operation is performed. Returns: A DocRect, whose values will all be set to INT32_MAX if the test was passed. For each side on which the test failed, the corresponding value will be set to how far in it is safe to extend the node, eg if the node could only be shrunk inwards by 10 millipoints on the right-hand side, then the hix value of the DocRect will contain 10, while all other values will be INT32_MAX. Errors: ERROR2 with FALSE if fExtendFlags holds contradictory flags or any parameters are NULL. See also: Extender::CheckValidExtend() and for more information, see: \Earth V3 Objects - Mechanism.doc NOTE: A call to Extender::CheckValidExtend must *always* be made before performing a corresponding Extender::Extend process. Definition at line 436 of file extender.cpp. { // validate parameters. ERROR2IF( pNode == NULL, DocRect(0, 0, 0, 0), "NULL parameters passed to Extender::CheckValidExtend" ); ERROR2IF( ((fExtendFlags & X_EXTEND) && (fExtendFlags & X_STRETCH)) || ((fExtendFlags & Y_EXTEND) && (fExtendFlags & Y_STRETCH)), DocRect(0, 0, 0, 0), "Extender::CheckValidExtend called with contradictory flags in fExtendFlags" ); if (pOK) *pOK = TRUE; // quit immediately if any of the bounding rectangles is invalid, // or is of zero width or height. if( !drTriggerRelation.IsValid() || !drTargetRelation.IsValid() || !drNewTrigger.IsValid() || !drLastTrigger.IsValid() || !drLastTarget.IsValid() || drTriggerRelation.Height() == 0 || drTriggerRelation.Width() == 0 || drTargetRelation.Height() == 0 || drTargetRelation.Width() == 0 || drNewTrigger.Height() == 0 || drNewTrigger.Width() == 0 || drLastTrigger.Height() == 0 || drLastTrigger.Width() == 0 || drLastTarget.Height() == 0 || drLastTarget.Width() == 0) { if (pOK) *pOK = FALSE; return DocRect(0, 0, 0, 0); } // determine extension working values. ExtendParams eps; CalculateExtendParams( &eps, fExtendFlags, drTriggerRelation, drTargetRelation, drNewTrigger, drLastTrigger, drLastTarget, NULL, ExtendAroundTarget ); // check whether pNode, or any child of pNode, is extendible. // also, check that extending all of these Nodes is a valid operation. // if this is the case, recursively extend pNode and its children. DocRect drMinExtend = pNode->ValidateExtend(eps); BOOL bValidExtend = ( drMinExtend.lo.x == INT32_MAX && drMinExtend.lo.y == INT32_MAX && drMinExtend.hi.x == INT32_MAX && drMinExtend.hi.y == INT32_MAX ); // DEBUG: #ifdef _DEBUG TRACEUSER( "Karim", _T("%5s ValidateExtend() on %s\n"), bValidExtend ? _T("TRUE") : _T("FALSE"), pNode->Name()); #endif BOOL bExtendible = TRUE; if (!bExtendible || !bValidExtend) { //#ifdef _DEBUG // TRACEUSER( "Karim", _T("Invalid Extend on %s; Ext: %d, Valid: %d\n"), // pNode->Name(), bExtendible, bValidExtend); //#endif return drMinExtend; } // return the outcome of the test, in the form of drMinExtend. return drMinExtend; }

BOOL Extender::ConvertQuickShapesInSelRangeToPaths (  UndoableOperation *  pUndoOp, Range *  pRange )  [static]

Iterates over the given SelRange looking for any NodeRegularShapes, ie QuickShapes. If we find any then they get zapped, and all that is left is a smoking pair of shoes! ... erm, sorry - a NodePath. Notes: This is all done undoably. There is however a problem in that we do not necessarily want to completely unwind the UndoOp we were given if anything goes wrong. But if we don't do that then what _can_ we do??? Currently, if things go wrong while converting to shapes, we just try to convert as many shapes to paths as possible and return FALSE at the end. We don't mind if pSel is empty or has no QuickShapes. Our search of the SelRange is deep - we look at children of nodes in the range too. Returns: Errors: ERROR2 with FALSE if we get invalid parameters. See also: Definition at line 235 of file extender.cpp. { // validate params. ERROR2IF(pUndoOp == NULL || pRange == NULL, FALSE, "Invalid parameter(s)"); // TODO: May need to set the range's RangeControl to avoid promoting to parents. // iterate over the range and build a list of QuickShapes. // we do a depth-first search from every node in the range, // looking everywhere for those those pesky QuickShapes :) BOOL bQuickShapesConverted = FALSE; std::list<NodeRegularShape*> lpShapes; Node* pCurrentRangeNode = pRange->FindFirst(); while (pCurrentRangeNode != NULL) { Node* pNextNode = NULL; Node* pCurrentNode = pCurrentRangeNode->FindFirstDepthFirst(); while (pCurrentNode != NULL) { pNextNode = pCurrentNode->FindNextDepthFirst(pCurrentRangeNode); if (pCurrentNode->IsARegularShape()) { if (!(pCurrentNode->FindParent (CC_RUNTIME_CLASS (NodeBlend)))) { // note thate we're *saying* we're going to replace with only one node. // this isn't necessarily true - DoBecomeA on a brushed path results in // many ungrouped nodes. it's just the best we can do, considering blends. ObjChangeFlags ocf; ocf.ReplaceNode = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING, ocf, pCurrentNode, pUndoOp); if (pCurrentNode->AllowOp(&ObjChange, FALSE, FALSE)) lpShapes.push_front((NodeRegularShape*)pCurrentNode); } /*else { // note thate we're *saying* we're going to replace with only one node. // this isn't necessarily true - DoBecomeA on a brushed path results in // many ungrouped nodes. it's just the best we can do, considering blends. ObjChangeFlags ocf; ocf.ReplaceNode = TRUE; ObjChangeParam ObjChange(OBJCHANGE_STARTING, ocf, pCurrentNode, pUndoOp); if (pCurrentNode->AllowOp(&ObjChange, TRUE, FALSE)) lpShapes.push_front((NodeRegularShape*)pCurrentNode); }*/ } pCurrentNode = pNextNode; } pCurrentRangeNode = pRange->FindNext(pCurrentRangeNode, TRUE); } // okay, if our list isn't empty then we have work to do. if (!lpShapes.empty()) { // invalidate the region of the selection. if (pUndoOp->DoInvalidateNodesRegions(*pRange, TRUE)) { // change all the QuickShapes into NodePaths. NodeRegularShape* pCurrentShape = NULL; while (!lpShapes.empty()) { pCurrentShape = lpShapes.front(); lpShapes.pop_front(); BecomeA BecomeAPath( BECOMEA_REPLACE, CC_RUNTIME_CLASS(NodePath), pUndoOp, pCurrentShape->IsSelected() ); if (pCurrentShape->CanBecomeA(&BecomeAPath)) { if (!(pCurrentShape->FindParent (CC_RUNTIME_CLASS (NodeBlend)))) { if (pCurrentShape->DoBecomeA(&BecomeAPath)) { pCurrentShape->DeSelect(FALSE); bQuickShapesConverted = TRUE; } } /*else { NodeBlend* ptrBlend = (NodeBlend*) pCurrentShape->FindParent (CC_RUNTIME_CLASS (NodeBlend)); BecomeA BecomeAPath( BECOMEA_REPLACE, CC_RUNTIME_CLASS(NodePath), pUndoOp, pCurrentShape->IsSelected() ); if (pCurrentShape->DoBecomeA(&BecomeAPath)) { pCurrentShape->DeSelect(FALSE); bQuickShapesConverted = TRUE; } // nastiness - to reinitialise the blend, I need a ptr to the converted path // BUT there is no easy way of doing this! This is a hack - which seems to // hold up well .... NOTE: assumes that the last action executed was a // HideNodeAction (i.e. hide pCurrentShape) ActionList* actList = pUndoOp->GetUndoActionList (); // get undo history ListItem* pItem = actList->GetTail (); // get last op ERROR3IF (!IS_A (pItem, HideNodeAction), "Assumed HideNodeAction is not a HideNodeAction!"); HideNodeAction* hnAct = (HideNodeAction*) pItem; NodeRenderableInk* newNode = (NodeRenderableInk*) hnAct->GetNode (); ERROR3IF (!IS_A (ptrBlend, NodeBlend), "NodeBlend is not a NodeBlend!"); BOOL done = FALSE; NodeBlender* ptrNode = ptrBlend->FindFirstBlender (); while (!done) { ptrNode->Deinit (); if (ptrNode->GetNodeStart () == pCurrentShape) { ptrNode->Reinit(newNode, NULL, FALSE); } if (ptrNode->GetNodeEnd () == pCurrentShape) { ptrNode->Reinit(NULL, newNode, FALSE); } ptrNode = ptrBlend->FindNextBlender (ptrNode); if (!ptrNode) { done = TRUE; } } }*/ } } } if (bQuickShapesConverted) pRange->Update(); } return bQuickShapesConverted; }

void Extender::Extend (  NodeRenderableInk *  pNode, DocRect *  pStartRect, DocRect *  pEndRect, BYTE  fExtendFlags, DocRect *  pOldStartRect = NULL )  [static]

** DEPRECATED - DO NOT CALL ** Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 10/09/1999 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: ERROR2 always. See also: Definition at line 157 of file extender.cpp. { ERROR2RAW("This implementation of Extender::Extend is no longer used or valid"); }

void Extender::Extend (  NodeRenderableInk *  pNode, BYTE  fExtendFlags, const DocRect &  drTriggerRelation, const DocRect &  drTargetRelation, const DocRect &  drNewTrigger, const DocRect &  drLastTrigger, const DocRect &  drLastTarget, const DocRect *  pdrDifference = NULL, const BOOL  ExtendAroundTarget = FALSE, UndoableOperation *  pOp = NULL )  [static]

Perform an extend operation on the given Node and its children, using the given rectangles and flags to determine how the Node should transform. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 03/12/1999 Parameters: pNode  pointer to a NodeRenderableInk which will be extended. [INPUTS] fExtendFlags bitwise flags, describing any combination of x- or y- stretching or extending, except that you may not extend and stretch along an axis at the same time. Values: X_EXTEND the node should be extended along the x-axis Y_EXTEND the node should be extended along the y-axis X_STRETCH the node should be stretched along the x-axis Y_STRETCH the node should be stretched along the y-axis drTriggerRelation relationship rectangle - the bounding box of the trigger sets when the relationship is defined. drTargetRelation relationship rectangle - the bounding box of the target sets when the relationship is defined. drNewTrigger bounding box of sets of triggers which started the call to this function. drLastTrigger the bounding box of the trigger set(s) before it changed. drLastTarget the bounding box of the target set before it is extended. pdrDifference a rectangle containing four difference parameters which may be used to alter the extend. ok to omit or be NULL. Parameters: pNode  may be extended or stretched horizontally [OUTPUTS] or vertically in any combination. Returns: Errors: ERROR2 if fExtendFlags holds contradictory flags or any parameters are NULL. See also: Extender::CheckValidExtend() and for more information, see: \Earth V3 Objects - Mechanism.doc NOTE: A call to Extender::CheckValidExtend must always be made before performing a corresponding Extender::Extend process. Definition at line 560 of file extender.cpp. { // validate parameters. if (pNode == NULL) { ERROR2RAW("NULL parameters passed to Extender::Extend."); return; } if (((fExtendFlags & X_EXTEND) && (fExtendFlags & X_STRETCH)) || ((fExtendFlags & Y_EXTEND) && (fExtendFlags & Y_STRETCH))) { ERROR2RAW("Extender::Extend called with contradictory flags in fExtendFlags"); return; } // quit immediately if any of the bounding rectangles is invalid, // or is of zero width or height. if (!drTriggerRelation.IsValid() || !drTargetRelation.IsValid() || !drNewTrigger.IsValid() || !drLastTrigger.IsValid() || !drLastTarget.IsValid() || drTriggerRelation.Height() == 0 || drTriggerRelation.Width() == 0 || drTargetRelation.Height() == 0 || drTargetRelation.Width() == 0 || drNewTrigger.Height() == 0 || drNewTrigger.Width() == 0 || drLastTrigger.Height() == 0 || drLastTrigger.Width() == 0 || drLastTarget.Height() == 0 || drLastTarget.Width() == 0) { ERROR2RAW("Extender::Extend; Invalid or zero-width rectangle"); return; } // determine extension working values. ExtendParams eps; eps.pOp = pOp; CalculateExtendParams( &eps, fExtendFlags, drTriggerRelation, drTargetRelation, drNewTrigger, drLastTrigger, drLastTarget, pdrDifference, ExtendAroundTarget ); // this hasn't really changed size so do nothing if (!eps.xdec && !eps.xinc && !eps.ydec && !eps.yinc && eps.xscale == 1.0 && eps.yscale == 1.0 && eps.doccOffset.x == 0 && eps.doccOffset.y == 0) return; // invalidate the old image of the object, perform the extension // and flag that the object should be redrawn. // we must look above this node, to detect whether we are the child // of a node whose on-screen bounds are greater than ours. // if this is the case, we need to invalidate *that* node and // get it to redraw. // TODO: there may be a better way of doing this (is it necessary at all with the AllowOp mechanism?) BOOL bFoundBigParent = FALSE; Node* pInvalidateNode = pNode->FindParent(); while (pInvalidateNode != NULL && !IS_A(pInvalidateNode, Layer) && !bFoundBigParent) { if (IS_A(pInvalidateNode, NodeBevelController) || IS_A(pInvalidateNode, NodeShadowController) || IS_A(pInvalidateNode, NodeContourController)) bFoundBigParent = TRUE; else pInvalidateNode = pInvalidateNode->FindParent(); } if (!bFoundBigParent) pInvalidateNode = pNode; ((NodeRenderableInk*)pInvalidateNode)->RedrawObject(); ((NodeRenderableInk*)pInvalidateNode)->InvalidateBoundingRect(); pNode->Extend(eps); // DEBUG: //#ifdef _DEBUG // TRACEUSER( "Karim", _T("Extend() on %s\n"), pNode->Name()); //#endif ((NodeRenderableInk*)pInvalidateNode)->RedrawObject(); }

DocRect Extender::ValidateControlPoints (  INT32  numPoints, const DocCoord *  doccArray, const ExtendParams &  ExtParams )  [static]

Validate the given points, using the provided extend parameters. If extending the points is invalid, then return a rectangle containing the largest distances which the points can be shrunk in by. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 07/12/1999 Parameters: numPoints  number of coordinates to validate. [INPUTS] doccArray the array of coordinates. ExtParams extend parameters. Returns: A DocRect containing maximum safe shrink distances for the points: lox maximum shrinkage in from the left. hix maximum shrinkage in from the right. loy maximum shrinkage in from the bottom. hiy maximum shrinkage in from the top. If shrinking in a particular direction is ok, the corresponding DocRect value will be set to INT32_MAX. Returns: Errors: ERROR3 if doccArray is NULL. See also: Definition at line 677 of file extender.cpp. { // validate data ERROR3IF(doccArray == NULL, "Extender::ValidateControlPoints- NULL doccArray passed!"); DocRect drMaxSafeShrink(INT32_MAX, INT32_MAX, INT32_MAX, INT32_MAX), drCheckExtend; // this check is only necessary if extension will be occurring along an // axis; if the extension type is stretch, or no action, no validation // is required. // for each of the four directions of displacement, and only if we shrank, check that // none of the points lie in a position to which they would not be returned under the // inverse extend operation. if they do, we record the largest safe amount we could // shrink them in by. // providing the extend operation involves displacing all points by the difference // between start- and end- centres, followed by the extension, these invalid points // will be only those which would be dragged inwards, to cross over the end-centre. if (ExtParams.fExtendFlags & X_EXTEND) { if (ExtParams.xinc < 0) { INT32 minXshrink = CheckInvalidShrinkingPoints( ExtParams.doccEndCentre.x, ExtParams.xinc, ExtParams.doccOffset.x, numPoints, doccArray, TRUE ); if (minXshrink >= 0) // invalid, so record the return value. drMaxSafeShrink.hi.x = minXshrink; } // we do a different test if we're expanding. else if (ExtParams.xinc > 0) { INT32 minXshrink = CheckInvalidExpandingPoints( ExtParams.doccEndCentre.x, ExtParams.xinc, ExtParams.doccOffset.x, numPoints, doccArray, TRUE ); if (minXshrink >= 0) // invalid, so record the return value. drMaxSafeShrink.hi.x = minXshrink; } if (ExtParams.xdec < 0) { INT32 minXshrink = CheckInvalidShrinkingPoints( ExtParams.doccEndCentre.x, -ExtParams.xdec, ExtParams.doccOffset.x, numPoints, doccArray, TRUE ); if (minXshrink >= 0) // invalid, so record the return value. drMaxSafeShrink.lo.x = minXshrink; } // we do a different test if we're expanding. else if (ExtParams.xdec > 0) { INT32 minXshrink = CheckInvalidExpandingPoints( ExtParams.doccEndCentre.x, -ExtParams.xdec, ExtParams.doccOffset.x, numPoints, doccArray, TRUE ); if (minXshrink >= 0) // invalid, so record the return value. drMaxSafeShrink.lo.x = minXshrink; } } if (ExtParams.fExtendFlags & Y_EXTEND) { if (ExtParams.yinc < 0) { INT32 minYshrink = CheckInvalidShrinkingPoints( ExtParams.doccEndCentre.y, ExtParams.yinc, ExtParams.doccOffset.y, numPoints, doccArray, FALSE ); if (minYshrink >= 0) // invalid, so record the return value. drMaxSafeShrink.hi.y = minYshrink; } // we do a different test if we're expanding. else if (ExtParams.yinc > 0) { INT32 minYshrink = CheckInvalidExpandingPoints( ExtParams.doccEndCentre.y, ExtParams.yinc, ExtParams.doccOffset.y, numPoints, doccArray, FALSE ); if (minYshrink >= 0) // invalid, so record the return value. drMaxSafeShrink.hi.y = minYshrink; } if (ExtParams.ydec < 0) { INT32 minYshrink = CheckInvalidShrinkingPoints( ExtParams.doccEndCentre.y, -ExtParams.ydec, ExtParams.doccOffset.y, numPoints, doccArray, FALSE ); if (minYshrink >= 0) // invalid, so record the return value. drMaxSafeShrink.lo.y = minYshrink; } // we do a different test if we're expanding. else if (ExtParams.ydec > 0) { INT32 minYshrink = CheckInvalidExpandingPoints( ExtParams.doccEndCentre.y, -ExtParams.ydec, ExtParams.doccOffset.y, numPoints, doccArray, FALSE ); if (minYshrink >= 0) // invalid, so record the return value. drMaxSafeShrink.lo.y = minYshrink; } } return drMaxSafeShrink; }

---

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

• Kernel/extender.h (r1785/r1282)
• Kernel/extender.cpp (r1785/r1282)

---