CSnap Class Reference

Performs the snapping required by Camelot. More...

#include <snap.h>

List of all members.

Public Member Functions
	CSnap (DocView *pThisDocView, Spread *pThisSpread)
	The constructor. At the moment, snapping is controlled on a per-view basis, so a DocView has to be supplied. Also, snapping to objects happens on a per-spread basis, hence the need to supply a spread.
BOOL	Snap (DocCoord *pDocCoord, BOOL TryMagSnap=TRUE, BOOL TryGridSnap=TRUE)
	Allows you to easily snap a coord to something relevant in the given spread (e.g. to a grid, magnetic object, etc).
BOOL	Snap (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Allows you to easily snap a rectangle to objects.
BOOL	TryToSnapToObject (Node *pNode, DocCoord *pDocCoord)
	Allows a test to see if a particular node snaps to a particaular coord.
BOOL	SnapToGrids (DocCoord *pDocCoord)
	Allows you to easily snap a coord to a grid in a spread.
BOOL	SnapToGuidelines (DocCoord *pDocCoord, GuidelineType Type=GUIDELINE_NOTYPE)
	Allows you to easily snap a coord to a guideline in a spread.
void	SetSpread (Spread *pThisSpread)
Static Public Member Functions
static MILLIPOINT	GetSnapDist ()
static MILLIPOINT	GetSnapToCoordDist ()
static BOOL	SnapCoordToPath (DocCoord *pDocCoord, Path *pPath)
	Common code called by a number of Nodes Snap(DocCoord*) functions. Attempts to snap a coord onto a path.
static BOOL	SnapRectToRect (DocRect *pSnappedRect, const DocRect &RefRect)
	Snap a rectangle so that it lines up with one or more sides of another rectangle. This will only happen if the first rectangle is close to the second rectangle.
Private Member Functions
	CC_DECLARE_MEMDUMP (CSnap)
BOOL	SnapToGrids (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Allows you to easily snap a coord to a grid in a spread.
BOOL	SnapToObjects (Node *pRootNode, DocCoord *pDocCoord, BOOL Magnetic, BOOL GuideLayersOnly)
	Allows you to snap a coord to an object in a spread. This will try and snap the coord to NodeRenderableBounded nodes in the sub-tree in the reverse order in which they are rendered. Each eligable node is firstly checked to see if the bounds contain the coord. If the Magnetic param is TRUE, only NodeRend nodes with their Man.
BOOL	SnapToObjects (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord, BOOL Magnetic, BOOL GuideLayersOnly)
	Allows you to easily snap a coord to an object in a spread.
BOOL	SnapToGuidelines (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Allows you to easily snap a rect to a guideline in a spread.
BOOL	SnapToGuidesInLayer (Layer *pLayer, DocCoord *pDocCoord, GuidelineType Type)
	Helper function that will snap one component of the DocCoord to one type of guideline.
BOOL	SnapToGuideObjects (DocCoord *pDocCoord)
	Allows you to easily snap a coord to objects in guide layers.
BOOL	SnapToGuideObjects (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Allows you to easily snap a rect to objects in guide layers.
BOOL	SnapToPages (DocCoord *pDocCoord)
	Allows you to easily snap a coord to a page in a spread.
BOOL	SnapToPages (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Allows you to easily snap a coord to a page in a spread.
void	CalcSnapDist ()
	Calculates the snapping distance to objects for this CSnap object's DocView. Uses the DocView's scale factor as a parameter, so this should be called every time the DocView's scale factor changes.
Static Private Member Functions
static BOOL	SnapToValue (const INT32 RefValue, INT32 *pTestValue, INT32 *pLockedValue)
	Given a reference and pointers to two variable values, this function attempts to snap the first variable value to the reference, and if successful adjusts the second variable value by the same amount as the first.
Private Attributes
DocView *	pDocView
Spread *	pSpread
Node *	pLastSnappingObject
Static Private Attributes
static MILLIPOINT	SnapDist = 1
static MILLIPOINT	SnapToCoordDist = 1
static BOOL	TrySnapToPages = TRUE

---

Detailed Description

Performs the snapping required by Camelot.

Author:

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

Date:

20/9/94

Definition at line 123 of file snap.h.

---

Constructor & Destructor Documentation

CSnap::CSnap (  DocView *  pThisDocView, Spread *  pThisSpread )

The constructor. At the moment, snapping is controlled on a per-view basis, so a DocView has to be supplied. Also, snapping to objects happens on a per-spread basis, hence the need to supply a spread. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pThisDocView  - the view in which this snapping is occuring [INPUTS] pThisSpread - the spread that constains the objects (grids, guides, etc) to snap to See also: Definition at line 150 of file snap.cpp. { pDocView = pThisDocView; pSpread = pThisSpread; pLastSnappingObject = NULL; CalcSnapDist(); }

---

Member Function Documentation

void CSnap::CalcSnapDist (   )  [private]

Calculates the snapping distance to objects for this CSnap object's DocView. Uses the DocView's scale factor as a parameter, so this should be called every time the DocView's scale factor changes. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/9/94 Definition at line 1076 of file snap.cpp. { // Find out the Magnetic Line Radius preference from its owner INT32 MagneticRad = NodeRenderableBounded::MagneticLineRadius; INT32 PointRad = NodeRenderableBounded::MagneticPointRadius; // Scale it according to the ScaleFactor. if (pDocView!=NULL) { // Get the Scale factor and modify the magnetic radius double Scale = pDocView->GetViewScale().MakeDouble(); MagneticRad = (INT32) ((double)MagneticRad / Scale); PointRad = (INT32) ((double)PointRad / Scale); } // Set the snapping distance to the (hopefully) modified magnetic radius SnapDist = MagneticRad; SnapToCoordDist = PointRad; }

CSnap::CC_DECLARE_MEMDUMP (  CSnap   )  [private]

static MILLIPOINT CSnap::GetSnapDist (   )  [inline, static]

Definition at line 142 of file snap.h. { return SnapDist; }

static MILLIPOINT CSnap::GetSnapToCoordDist (   )  [inline, static]

Definition at line 143 of file snap.h. { return SnapToCoordDist; }

void CSnap::SetSpread (  Spread *  pThisSpread  )  [inline]

Definition at line 140 of file snap.h. { pSpread = pThisSpread; }

BOOL CSnap::Snap (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )

Allows you to easily snap a rectangle to objects. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pDocRect  = a rectangle is spread coords [INPUTS] PrevCoord = Used to determine how rect is snapped CurCoord = As above Returns: TRUE - The rect has been snapped to something FALSE - The rect is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 267 of file snap.cpp. { ERROR3IF(pDocView == NULL || pSpread == NULL,"Invalid DocView and/or spread"); if (pDocView == NULL || pSpread == NULL) return FALSE; // This has to be called here so that the static SnapDist member var is // correct for this CSnap's DocView CalcSnapDist(); BOOL Snapped = FALSE; if (!Snapped && pDocView->GetSnapToGuidesState()) Snapped = SnapToGuidelines(pDocRect,PrevCoord,CurCoord); if (!Snapped && pDocView->GetSnapToGuidesState()) Snapped = SnapToGuideObjects(pDocRect,PrevCoord,CurCoord); BOOL SnapToAllObjs = pDocView->GetSnapToObjectsState(); // "Snap to all objects" state BOOL SnapToMagObjs = pDocView->GetSnapToMagObjectsState(); // "Snap to magnetic objects" state if (!Snapped) { // Only try and snap to objects if either the "snap to all objects" OR "snap to magnetic objects" // flags are set if (SnapToAllObjs || SnapToMagObjs) { // Only check magnetic objects if the "snap to magnetic objects" flag is TRUE and the // "Snap to all objects" flag is FALSE BOOL Magnetic = (SnapToMagObjs && !SnapToAllObjs); Snapped = SnapToObjects(pDocRect,PrevCoord,CurCoord,Magnetic,FALSE); } } // Try snapping to the page boundaries if (!Snapped && TrySnapToPages && SnapToAllObjs) Snapped = SnapToPages(pDocRect,PrevCoord,CurCoord); // Try and snap to the grids if (!Snapped && pDocView->GetSnapToGridState()) Snapped = SnapToGrids(pDocRect,PrevCoord,CurCoord); return (Snapped); }

BOOL CSnap::Snap (  DocCoord *  pDocCoord, BOOL  TryMagSnap = TRUE, BOOL  TryGridSnap = TRUE )

Allows you to easily snap a coord to something relevant in the given spread (e.g. to a grid, magnetic object, etc). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pDocCoord  = a coord relative to the given spread [INPUTS] Returns: TRUE - The coord has been snapped to something FALSE - The coord is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 179 of file snap.cpp. { ERROR2IF(pDocView==NULL,FALSE,"CSnap::Snap() - pDocView==NULL"); ERROR2IF( pSpread==NULL,FALSE,"CSnap::Snap() - pSpread==NULL"); // This has to be called here so that the static SnapDist member var is // correct for this CSnap's DocView CalcSnapDist(); BOOL Snapped=FALSE; // Try snapping to the guidelines on the guide layers if (!Snapped && pDocView->GetSnapToGuidesState()) Snapped = SnapToGuidelines(pDocCoord); // Try snapping to the objects on the guide layers if (!Snapped && pDocView->GetSnapToGuidesState()) Snapped = SnapToGuideObjects(pDocCoord); // Find the state of the snapping flags BOOL SnapToAllObjs = TryMagSnap && pDocView->GetSnapToObjectsState(); // "Snap to all objects" state BOOL SnapToMagObjs = TryMagSnap && pDocView->GetSnapToMagObjectsState(); // "Snap to magnetic objects" state // Only try and snap to objects if either the flags are set if (!Snapped && (SnapToAllObjs || SnapToMagObjs)) { // try and snap to the last object we snapped to if ((pLastSnappingObject!=NULL) && // Do we have a last snapped object? (pLastSnappingObject->FindParent() != NULL) && // Does it have a parent (i.e. not been hidden)? (TryToSnapToObject(pLastSnappingObject, pDocCoord)) ) { Snapped=TRUE; } else { // We failed to snap to the last object we snapped to, so set the pointer to NULL pLastSnappingObject = NULL; // Only check magnetic objects if the "snap to magnetic objects" flag is TRUE and the // "Snap to all objects" flag is FALSE BOOL Magnetic = (SnapToMagObjs && !SnapToAllObjs); if (SnapToObjects(pSpread->FindLastChild(), pDocCoord, Magnetic, FALSE)) Snapped=TRUE; } } // Try snapping to the page boundaries if (!Snapped && TrySnapToPages && SnapToAllObjs) Snapped = SnapToPages(pDocCoord); // set a flag to indicate if snapped to an object but not the grid // for update of magnetic snap indicator BOOL NonGridSnapped=Snapped; // if not already snapped to an object, try to snap to grid if (!Snapped) if (TryGridSnap && (pDocView->GetSnapToGridState()) && (SnapToGrids(pDocCoord))) Snapped=TRUE; #if !defined(EXCLUDE_FROM_RALPH) // update mouse position in StatusLine (with snapped mouse position) StatusLine* pStatusLine=GetApplication()->GetpStatusLine(); if (pStatusLine) pStatusLine->UpdateMousePosAndSnap(pDocCoord,pSpread,pDocView,NonGridSnapped); #endif return Snapped; }

BOOL CSnap::SnapCoordToPath (  DocCoord *  pDocCoord, Path *  pPath )  [static]

Common code called by a number of Nodes Snap(DocCoord*) functions. Attempts to snap a coord onto a path. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 19/10/95 Parameters: pDocCoord  = a coord in Spread coords [INPUTS] pPath - the path it should be snapped to pDocCoord  will hiold the snapped coodinate, if snapped [OUTPUTS] Returns: TRUE - the DocCoord has been snapped to the path. FALSE - the DocCoord has not been snapped Definition at line 1112 of file snap.cpp. { BOOL Snapped = FALSE; MILLIPOINT SnapDist = CSnap::GetSnapDist(); MILLIPOINT SqrSnapDist = SnapDist*SnapDist; INT32 NearEl = 0; double mu = 0; double SqrDist = pPath->SqrDistanceToPoint(*pDocCoord, &NearEl, &mu); if (SqrDist <= SqrSnapDist) { *pDocCoord = pPath->ClosestPointTo(mu, NearEl); Snapped = TRUE; } return (Snapped); }

BOOL CSnap::SnapRectToRect (  DocRect *  pSnappedRect, const DocRect &  RefRect )  [static]

Snap a rectangle so that it lines up with one or more sides of another rectangle. This will only happen if the first rectangle is close to the second rectangle. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26/10/1999 Parameters: pSnappedRect  pointer to the rectangle which will be snapped. [INPUTS] RefRect the reference rectangle, to snap to. pSnappedRect  may be snapped to RefRect. [OUTPUTS] Returns: TRUE if pSnappedRect was snapped, FALSE otherwise. Errors: ERROR2 if pSnappedRect is NULL. See also: Definition at line 1152 of file snap.cpp. { // validate input. ERROR2IF(pSnappedRect == NULL, FALSE, "CSnap::SnapRectToRect- NULL pSnappedRect."); // before we start doing loads of snap-testing, we need to check that the two rectangles // are close enough together. DocRect TestIntersect = *pSnappedRect; TestIntersect.Inflate(SnapDist); if (!TestIntersect.IsIntersectedWith(RefRect)) return FALSE; // try to snap the y-coordinates of pSnappedRect to those of RefRect. // order of snap-attempts goes: // // top-to-top, bottom-to-bottom, bottom-to-top, top-to-bottom // // ,where we are snapping y-values in pSnappedRect-to-RefRect. BOOL bSnappedY = FALSE; if (!bSnappedY) bSnappedY = SnapToValue(RefRect.hi.y, &(pSnappedRect->hi.y), &(pSnappedRect->lo.y)); if (!bSnappedY) bSnappedY = SnapToValue(RefRect.lo.y, &(pSnappedRect->lo.y), &(pSnappedRect->hi.y)); if (!bSnappedY) bSnappedY = SnapToValue(RefRect.hi.y, &(pSnappedRect->lo.y), &(pSnappedRect->hi.y)); if (!bSnappedY) bSnappedY = SnapToValue(RefRect.lo.y, &(pSnappedRect->hi.y), &(pSnappedRect->lo.y)); // try to snap the x-coordinates of pSnappedRect to those of RefRect. // order of snap-attempts goes: // // left-to-left, right-to-right, left-to-right, right-to-left // // ,where we are snapping x-values in pSnappedRect-to-RefRect. BOOL bSnappedX = FALSE; if (!bSnappedX) bSnappedX = SnapToValue(RefRect.lo.x, &(pSnappedRect->lo.x), &(pSnappedRect->hi.x)); if (!bSnappedX) bSnappedX = SnapToValue(RefRect.hi.x, &(pSnappedRect->hi.x), &(pSnappedRect->lo.x)); if (!bSnappedX) bSnappedX = SnapToValue(RefRect.hi.x, &(pSnappedRect->lo.x), &(pSnappedRect->hi.x)); if (!bSnappedX) bSnappedX = SnapToValue(RefRect.lo.x, &(pSnappedRect->hi.x), &(pSnappedRect->lo.x)); // return the result. return bSnappedY || bSnappedX; }

BOOL CSnap::SnapToGrids (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [private]

Allows you to easily snap a coord to a grid in a spread. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pDocRect  = a rectangle is spread coords [INPUTS] PrevCoord = Used to determine how rect is snapped CurCoord = As above Returns: TRUE - The rect has been snapped to something FALSE - The rect is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 782 of file snap.cpp. { // Make sure that we can and should be snapping to grids ERROR3IF(pDocView == NULL || pSpread == NULL,"Invalid DocView and/or spread"); if (pDocView == NULL || pSpread == NULL) return FALSE; if (!pDocView->GetSnapToGridState()) return (FALSE); BOOL Snapped = FALSE; // find the first grid in this layer Node* pNode = pSpread->FindFirstChild(); if (!pNode->IS_KIND_OF(NodeGrid)) pNode = pNode->FindNext(CC_RUNTIME_CLASS(NodeGrid)); DocRect SnappedRect,ClosestSnappedRect; while (pNode != NULL) { NodeGrid* pNodeGrid = (NodeGrid *)pNode; SnappedRect = *pDocRect; if (pNodeGrid->Snap(&SnappedRect,PrevCoord,CurCoord)) { if (Snapped) { if (pDocRect->lo.Distance(SnappedRect.lo) < pDocRect->lo.Distance(ClosestSnappedRect.lo)) ClosestSnappedRect = SnappedRect; } else { ClosestSnappedRect = SnappedRect; Snapped = TRUE; } } pNode = pNode->FindNext(CC_RUNTIME_CLASS(NodeGrid)); } if (Snapped) *pDocRect = ClosestSnappedRect; return (Snapped); }

BOOL CSnap::SnapToGrids (  DocCoord *  pDocCoord  )

Allows you to easily snap a coord to a grid in a spread. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pDocCoord  = a spread coord [INPUTS] Returns: TRUE - The coord has been snapped to a grid FALSE - The coord is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 712 of file snap.cpp. { // Make sure that we can and should be snapping to grids ERROR3IF(pDocView == NULL || pSpread == NULL,"Invalid DocView and/or spread"); if (pDocView == NULL || pSpread == NULL) return FALSE; // >>>> Phil says: This isn't needed because the caller always checks this // >>>> if necessary. // if (!pDocView->GetSnapToGridState()) return (FALSE); // We haven't snapped yet BOOL Snapped = FALSE; // find the first grid in this layer Node* pNode = pSpread->FindFirstChild(); if (!pNode->IS_KIND_OF(NodeGrid)) pNode = pNode->FindNext(CC_RUNTIME_CLASS(NodeGrid)); // Get some DocCoords ready DocCoord SnappedCoord,ClosestSnappedCoord; while (pNode != NULL) { // We've got a kind of grid NodeGrid* pNodeGrid = (NodeGrid *)pNode; SnappedCoord = *pDocCoord; if (pNodeGrid->Snap(&SnappedCoord)) { // We've now got a snapped version of the coord // Keep the snapped coord that is closest to the original point if (Snapped) { if (pDocCoord->Distance(SnappedCoord) < pDocCoord->Distance(ClosestSnappedCoord)) ClosestSnappedCoord = SnappedCoord; } else { ClosestSnappedCoord = SnappedCoord; Snapped = TRUE; } } // Get the next node, it could be a grid! pNode = pNode->FindNext(CC_RUNTIME_CLASS(NodeGrid)); } if (Snapped) *pDocCoord = ClosestSnappedCoord; return (Snapped); }

BOOL CSnap::SnapToGuidelines (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [private]

Allows you to easily snap a rect to a guideline in a spread. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/9/95 Parameters: pDocRect  = a spread rect [INPUTS] PrevCoord = Prev coord of mouse pointer CurCoord = Current coord of mouse pointer Returns: TRUE - The rect has been snapped to something FALSE - The rect is untouched by man and beast This will snap the sides of the rect closest to the guidelines on the page. It snaps the H & V sides of the rect independantly, so that the corner of the rect will snap into H & V guideline intersection points correctly/ See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 545 of file snap.cpp. { ERROR2IF(pDocRect == NULL,FALSE,"pDocRect is NULL"); // This is the amount we will be translating pDocRect by in order to get it to snap INT32 DeltaX = 0, DeltaY = 0; // Copy of the original pDocRect to preserve the original coords DocRect SnappedRect = *pDocRect; //---- // Snap the left or right hand side of the rect //---- BOOL SnappedLoX = SnapToGuidelines(&SnappedRect.lo,GUIDELINE_VERT); // Snap the left hand side BOOL SnappedHiX = SnapToGuidelines(&SnappedRect.hi,GUIDELINE_VERT); // Snap the right hand side if (SnappedLoX && SnappedHiX) { // Did both sides snap? I.e. are both sides very close to a vertical guideline? // If so, choose to snap the side that's closest to a guideline BOOL DeltaLoX = SnappedRect.lo.x - pDocRect->lo.x; BOOL DeltaHiX = SnappedRect.hi.x - pDocRect->hi.x; if (abs(DeltaLoX) < abs(DeltaHiX)) DeltaX = DeltaLoX; else DeltaX = DeltaHiX; } else if (SnappedLoX) DeltaX = SnappedRect.lo.x - pDocRect->lo.x; // Only the left hand side snapped else if (SnappedHiX) DeltaX = SnappedRect.hi.x - pDocRect->hi.x; // Only the right hand side snapped //---- // Snap the top or bottom of the rect //---- BOOL SnappedLoY = SnapToGuidelines(&SnappedRect.lo,GUIDELINE_HORZ); // Snap the bottom BOOL SnappedHiY = SnapToGuidelines(&SnappedRect.hi,GUIDELINE_HORZ); // Snap the top if (SnappedLoY && SnappedHiY) { // Did both sides snap? I.e. are both sides very close to a horizontal guideline? // If so, choose to snap the side that's closest to a guideline BOOL DeltaLoY = SnappedRect.lo.y - pDocRect->lo.y; BOOL DeltaHiY = SnappedRect.hi.y - pDocRect->hi.y; if (abs(DeltaLoY) < abs(DeltaHiY)) DeltaY = DeltaLoY; else DeltaY = DeltaHiY; } else if (SnappedLoY) DeltaY = SnappedRect.lo.y - pDocRect->lo.y; // Only the bottom snapped else if (SnappedHiY) DeltaY = SnappedRect.hi.y - pDocRect->hi.y; // Only the top snapped // Did any snapping occur? BOOL Snapped = (SnappedLoX || SnappedHiX || SnappedLoY || SnappedHiY); // If it did, translate pDocRect by the required amount if (Snapped) pDocRect->Translate(DeltaX,DeltaY); return (Snapped); }

BOOL CSnap::SnapToGuidelines (  DocCoord *  pDocCoord, GuidelineType  Type = GUIDELINE_NOTYPE )

Allows you to easily snap a coord to a guideline in a spread. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/95 Parameters: pDocCoord  = a spread coord [INPUTS] Type = type of guideline to snap to (GUIDELINE_NOTYPE means snap to all types) Returns: TRUE - The coord has been snapped to a guideline FALSE - The coord is untouched by man and beast When Type == GUIDELINE_NOTYPE: It snaps the X ordinate to the vertical rulers, and the Y ordinate to horizontal rulers. This also creates the desired effect of making H & V guideline intersection points hot. When Type != GUIDELINE_NOTYPE: It snaps the given coord to this type of guideline only. (Used by the DocRect snapping version of this func) See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 410 of file snap.cpp. { ERROR3IF(pDocView == NULL || pSpread == NULL,"Invalid DocView and/or spread"); if (pDocView == NULL || pSpread == NULL) return FALSE; // We haven't snapped yet BOOL Snapped = FALSE; // Scan all layers in the spread Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL && !Snapped) { if (pLayer->IsGuide() && pLayer->IsVisible()) { // Only guide layers can contain guidelines if (Type == GUIDELINE_NOTYPE) { // OK, try to snap to both H & V guidelines Snapped = SnapToGuidesInLayer(pLayer,pDocCoord,GUIDELINE_HORZ); Snapped |= SnapToGuidesInLayer(pLayer,pDocCoord,GUIDELINE_VERT); } else // Only Snap to guidelines of the given type. Snapped = SnapToGuidesInLayer(pLayer,pDocCoord,Type); } pLayer = pLayer->FindNextLayer(); } return Snapped; }

BOOL CSnap::SnapToGuideObjects (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [private]

Allows you to easily snap a rect to objects in guide layers. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/95 Parameters: pDocRect  = a spread rect [INPUTS] PrevCoord = Prev coord of mouse pointer CurCoord = Current coord of mouse pointer Returns: TRUE - The rect has been snapped to a guideline FALSE - The rect is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 673 of file snap.cpp. { ERROR3IF(pDocView == NULL || pSpread == NULL,"Invalid DocView and/or spread"); if (pDocView == NULL || pSpread == NULL) return FALSE; // We haven't snapped yet BOOL Snapped = FALSE; // Scan all layers in the spread Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL && !Snapped) { // Only snap to objects in visible guide layers if (pLayer->IsGuide() && pLayer->IsVisible()) Snapped = SnapToObjects(pDocRect,PrevCoord,CurCoord,FALSE,TRUE); pLayer = pLayer->FindNextLayer(); } return Snapped; }

BOOL CSnap::SnapToGuideObjects (  DocCoord *  pDocCoord  )  [private]

Allows you to easily snap a coord to objects in guide layers. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 19/9/95 Parameters: pDocCoord  = a spread coord [INPUTS] Returns: TRUE - The coord has been snapped to a guideline FALSE - The coord is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 634 of file snap.cpp. { ERROR3IF(pDocView == NULL || pSpread == NULL,"Invalid DocView and/or spread"); if (pDocView == NULL || pSpread == NULL) return FALSE; // We haven't snapped yet BOOL Snapped = FALSE; // Scan all layers in the spread Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL && !Snapped) { // Only snap to objects in visible guide layers if (pLayer->IsGuide() && pLayer->IsVisible()) Snapped = SnapToObjects(pLayer,pDocCoord,FALSE,TRUE); pLayer = pLayer->FindNextLayer(); } return Snapped; }

BOOL CSnap::SnapToGuidesInLayer (  Layer *  pLayer, DocCoord *  pDocCoord, GuidelineType  Type )  [private]

Helper function that will snap one component of the DocCoord to one type of guideline. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/95 Parameters: pLayer  = ptr to layer [INPUTS] pDocCoord = ptr to DocCoord to snap Type = the type of guide to snap to (HORZ or VERT) Returns: TRUE - The coord has been snapped to a guideline FALSE - The coord is untouched by man and beast Only guidelines that are top-level children of pLayer are used The following statements describe how the snapping is performed (though the code implements a more general method) if Type == HORZ then the Y coord is snapped to the closest HORZ guideline if Type == VERT then the X coord is snapped to the closest VERT guideline See also: CSnap::SnapToGuidelines(DocCoord* pDocCoord) Definition at line 469 of file snap.cpp. { ERROR2IF(pLayer == NULL,FALSE,"pLayer is NULL"); ERROR2IF(pDocCoord == NULL,FALSE,"pDocCoord is NULL"); BOOL Snapped = FALSE; BOOL FirstSnapped = TRUE; DocCoord SnappedCoord; // Holds the snapped version of pDocCoord DocCoord ClosestSnappedCoord; // The closest snapped coord to the original coord // Scan all top-level objects in the layer for guidelines Node* pNode = pLayer->FindFirstChild(CC_RUNTIME_CLASS(NodeGuideline)); while (pNode != NULL && !Snapped) { NodeGuideline* pGuide = ((NodeGuideline*)pNode); if (pGuide->GetType() == Type) { // We've found a guideline of the correct type // Snap the coord SnappedCoord = *pDocCoord; Snapped = pGuide->Snap(&SnappedCoord); if (Snapped) { // If it has snapped, make sure our idea of the closest snapped coord is correct if (FirstSnapped) { // If it's the first time we have received a snapped coord, it must be the closest ClosestSnappedCoord = SnappedCoord; FirstSnapped = FALSE; } else { // Is this snapped coord closer to the original coord than the previous closest snapped coord? if (pDocCoord->Distance(SnappedCoord) < pDocCoord->Distance(ClosestSnappedCoord)) ClosestSnappedCoord = SnappedCoord; } } } pNode = pNode->FindNext(CC_RUNTIME_CLASS(NodeGuideline)); } // Update the supplied coord if we have a snapped version. if (Snapped) *pDocCoord = ClosestSnappedCoord; return Snapped; }

BOOL CSnap::SnapToObjects (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord, BOOL  Magnetic, BOOL  GuideLayersOnly )  [private]

Allows you to easily snap a coord to an object in a spread. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pDocRect  = a rectangle is spread coords [INPUTS] PrevCoord = Used to determine how rect is snapped CurCoord = As above Magnetic = TRUE means only snap to magnetic objects FALSE means snap to all objects GuideLayersOnly = TRUE means ignore objects on guide layers FALSE means treat guide layers as standard layers Returns: TRUE - The rect has been snapped to an object FALSE - The rect is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 1056 of file snap.cpp. { return FALSE; }

BOOL CSnap::SnapToObjects (  Node *  pRootNode, DocCoord *  pDocCoord, BOOL  Magnetic, BOOL  GuideLayersOnly )  [private]

Allows you to snap a coord to an object in a spread. This will try and snap the coord to NodeRenderableBounded nodes in the sub-tree in the reverse order in which they are rendered. Each eligable node is firstly checked to see if the bounds contain the coord. If the Magnetic param is TRUE, only NodeRend nodes with their Man. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pRootNode  = ptr to root node of sub tree of objects to snap to [INPUTS] pDocCoord = a spread coord Magnetic = TRUE means only snap to magnetic objects FALSE means snap to all objects GuideLayersOnly = TRUE means objects on visible guide layers only FALSE means objects on visible layers EXCEPT visible guide layers Returns: TRUE - The coord has been snapped to an object FALSE - The coord is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 851 of file snap.cpp. { // were we passed rubbish if (pRootNode==NULL) return FALSE; // Got a real node here. It should be the last child node of the spread Node* pNode = pRootNode; BOOL IsRising = FALSE; // BOOL Snapped = FALSE; // Find a DocView DocView* pDocView = DocView::GetCurrent(); if (pDocView==NULL) return FALSE; // set up an interval timer so we can regularly check if we need to abort const UINT32 AbortDelay = 100; // milliseconds MonotonicTime AbortTimer; AbortTimer.Sample(); while (!pNode->IsSpread()) { // at regular intervals, check to see if we should abort the snap test if (AbortTimer.Elapsed(AbortDelay)) { // if mouse moved, abort if (pDocView->IsMouseMoved()) return FALSE; // also abort if the mouse is no longer of the docview PORTNOTE("Snap", "Removed use of GetMousePosAndWindowID to abort snap processing") #if !defined(EXCLUDE_FROM_XARALX) CWindowID WinID; WinCoord WndPos; BOOL MouseOK = CCamApp::GetMousePosAndWindowID( &WinID, &WndPos ); if( MouseOK && WinID != NULL && pDocView != CCamView::GetDocViewFromWindowID( WinID ) ) return FALSE; #endif // resample timer AbortTimer.Sample(); } // while (pNode->IsLayer() && // (!(((Layer *)pNode)->IsVisible()) || (GuideLayersOnly && ((Layer*)pNode)->IsGuide())) // ) // We need to skip ALL unsuitable layers, so repeat until we find a layer we can snap to // A suitable layer has to be visible. // If 'GuideLayersOnly' flag is set, it also has to be a guide layer // Assume the layer is not suitable BOOL SuitableLayer = FALSE; // If we have found a layer, and it's not suitable, keep searching until we find one we like while (pNode->IsLayer() && !SuitableLayer) { Layer* pLayer = (Layer*)pNode; BOOL Visible = pLayer->IsVisible(); // Is layer visible? if (GuideLayersOnly) // Guide layers only? SuitableLayer = Visible && pLayer->IsGuide(); // Suitable if visible & guide layer else SuitableLayer = Visible && !pLayer->IsGuide(); // Else, suitable if visible & NOT guide layer if (!SuitableLayer) { // This layer is not suitable, so skip it if (pNode->FindPrevious() != NULL) pNode = pNode->FindPrevious(); else { pNode = pNode->FindParent(); IsRising = TRUE; // If we haven't hit a spread, then we'd better make sure // that the next if statement does the right thing } // See if we have come back to the spread if (pNode == NULL || pNode->IsSpread()) return FALSE; } } if (!IsRising) { // Get the last most child from this node if (pNode->ShouldBeRendered()) { while (pNode->FindFirstChild()!=NULL) { // Get the last node in the sibling list pNode = pNode->FindLastChild(); // If it was NULL then something odd has happened, so fail if (pNode==NULL) return FALSE; } } } // Test this node for magnetic snapping if (pNode->ShouldBeRendered()) { if (TryToSnapToObject(pNode, pDocCoord)) { // This node snapped. Note the node so we can try again next time pLastSnappingObject = pNode; return TRUE; } } // It did not snap to that node, so find the previous one if (pNode->FindPrevious()!=NULL) { // find the node before this one pNode = pNode->FindPrevious(); IsRising = FALSE; } else { // run out of nodes, so find the parent and flag that // we are going up in the tree pNode = pNode->FindParent(); IsRising = TRUE; } } // No nodes snapped to the coord return FALSE; }

BOOL CSnap::SnapToPages (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [private]

Allows you to easily snap a coord to a page in a spread. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/95 Parameters: pDocRect  = a spread rect [INPUTS] PrevCoord = Prev coord of mouse pointer CurCoord = Current coord of mouse pointer Returns: TRUE - The rect has been snapped to a page FALSE - The coord is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 366 of file snap.cpp. { ERROR3IF(pDocView == NULL || pSpread == NULL,"Invalid DocView and/or spread"); if (pDocView == NULL || pSpread == NULL) return FALSE; BOOL Snapped = FALSE; Page* pPage = pSpread->FindFirstPageInSpread(); while (pPage != NULL && !Snapped) { Snapped = pPage->Snap(pDocRect,PrevCoord,CurCoord); pPage = pPage->FindNextPage(); } return Snapped; }

BOOL CSnap::SnapToPages (  DocCoord *  pDocCoord  )  [private]

Allows you to easily snap a coord to a page in a spread. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/12/95 Parameters: pDocCoord  = a spread coord [INPUTS] Returns: TRUE - The coord has been snapped to a page FALSE - The coord is untouched by man and beast See also: All Snap member functions of all classes derived from NodeRenderableBounded. Definition at line 332 of file snap.cpp. { ERROR3IF(pDocView == NULL || pSpread == NULL,"Invalid DocView and/or spread"); if (pDocView == NULL || pSpread == NULL) return FALSE; BOOL Snapped = FALSE; Page* pPage = pSpread->FindFirstPageInSpread(); while (pPage != NULL && !Snapped) { Snapped = pPage->Snap(pDocCoord); pPage = pPage->FindNextPage(); } return Snapped; }

BOOL CSnap::SnapToValue (  const INT32  RefValue, INT32 *  pTestValue, INT32 *  pLockedValue )  [static, private]

Given a reference and pointers to two variable values, this function attempts to snap the first variable value to the reference, and if successful adjusts the second variable value by the same amount as the first. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 26/10/1999 Parameters: RefValue  a reference INT32 to snap to. [INPUTS] pTestValue pointer to a INT32 to snap to RefValue. pLockedValue pointer to a INT32 whose behaviour is locked with pTestValue's The  values referred to by pTestValue, pLockedValue may be changed, in which [OUTPUTS] case this function will return TRUE. Returns: TRUE if the given variable values were sucessfully snapped to the reference, FALSE otherwise. Errors: ERROR3 if either of the variable-value pointers is NULL. In release builds, just returns FALSE if this is the case. See also: Definition at line 1215 of file snap.cpp. { if (pTestValue == NULL || pLockedValue == NULL) { ERROR3("CSnap::SnapValues- NULL parameters"); return FALSE; } if ((*pTestValue) > RefValue && ((*pTestValue) - RefValue) <= SnapDist) { (*pLockedValue) -= ((*pTestValue) - RefValue); (*pTestValue) = RefValue; return TRUE; } else if ((*pTestValue) < RefValue && (RefValue - (*pTestValue)) <= SnapDist) { (*pLockedValue) += (RefValue - (*pTestValue)); (*pTestValue) = RefValue; return TRUE; } return FALSE; }

BOOL CSnap::TryToSnapToObject (  Node *  pNode, DocCoord *  pDocCoord )

Allows a test to see if a particular node snaps to a particaular coord. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/1/95 Parameters: pNode  - The node to try and snap to [INPUTS] pDocCoord - The coord to snap Returns: TRUE if it snapped the object to the coord, FALSE if it failed to snap Definition at line 1000 of file snap.cpp. { // Test this node for magnetic snapping if (pNode->IsBounded()) { // Convert it to a RenderableBounded NodeRenderableBounded* pNodeRndBnd = (NodeRenderableBounded*) pNode; // Don't allow snapping to dragged nodes... if (pNodeRndBnd->IsDragged()) return FALSE; // Firstly, inflate the bounds by the size of the snapping distance DocRect Bounds = pNodeRndBnd->GetBoundingRect(); if (CSnap::SnapDist > CSnap::SnapToCoordDist) Bounds.Inflate(CSnap::SnapDist); else Bounds.Inflate(CSnap::SnapToCoordDist); // If the coord lies inside the inflated bounds of the node, try and snap to the object if (Bounds.ContainsCoord(*pDocCoord)) { // Try to snap to the more significant points on the node if (pNodeRndBnd->SnapToCoords(pDocCoord)) return TRUE; // It failed, so try and snap to the outline of the shape if (pNodeRndBnd->Snap(pDocCoord)) return TRUE; } } // It did not snap to anything return FALSE; }

---

Member Data Documentation

DocView* CSnap::pDocView [private]

Definition at line 176 of file snap.h.

Node* CSnap::pLastSnappingObject [private]

Definition at line 178 of file snap.h.

Spread* CSnap::pSpread [private]

Definition at line 177 of file snap.h.

MILLIPOINT CSnap::SnapDist = 1 [static, private]

Definition at line 183 of file snap.h.

MILLIPOINT CSnap::SnapToCoordDist = 1 [static, private]

Definition at line 184 of file snap.h.

BOOL CSnap::TrySnapToPages = TRUE [static, private]

Definition at line 188 of file snap.h.

---

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

• Kernel/snap.h (r1785/r1718)
• Kernel/snap.cpp (r1785/r1282)

---