NodeGridRect Class Reference

A class defining a rectangular grid node. More...

#include <grid.h>

Inheritance diagram for NodeGridRect:

List of all members.

Public Member Functions
	NodeGridRect ()
	This constructor creates a NodeGridRect linked to no other nodes, with all status flags false, and NULL bounding and pasteboard rectangles.
String	Describe (BOOL Plural, BOOL Verbose)
	To return a description of the Node object in either the singular or the plural. This method is called by the DescribeRange method.
void	Render (RenderRegion *pRender)
	Renders the rectangular grid item.
void	GetDebugDetails (StringBase *Str)
	For obtaining debug information about the Node.
BOOL	Snap (DocCoord *pDocCoord)
	Snaps to given coord to the nearest grid point. If it is not appropriate to snap the coord to the grid (at the moment this means the coord lies outside the grid object's bounding box), then FALSE is returned.
BOOL	Snap (DocCoord *pDocCoord, double XStep, double YStep)
	Same as Snap(pDocCoord), except the coord is snapped to grid points at the given intervals.
BOOL	Snap (DocRect *pDocRect, const DocCoord &PrevCoord, const DocCoord &CurCoord)
	Snaps the given rect to the nearest position on the grid, preserving its width and height. The coords of the rect used for the snapping are determined by the PrevCoord and CurCoord coords supplied. This is done to allow the user to control how a selection rectangle is snapped to the grid by the direction of his/her last mouse movement. To force the bottom left hand corner of the rect to be snapped, supply PrevCoord=(0,0) and CurCoord(-1,-1). Scope: public.
BOOL	SetGridParams (double Div, UINT32 SubDiv, UnitType Units, BOOL Scale=TRUE)
	Defines the grid.
double	GetDivisions (BOOL Scale=TRUE)
	Used to get the number of Units between each main grid point.
UINT32	GetSubdivisions ()
	Used to get the number of subdivisions between each main grid point.
UnitType	GetUnits (BOOL Scale=TRUE)
	Gets the units used by the grid.
GridType	GetGridType ()
double	GetMainStep ()
Node *	SimpleCopy ()
	This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes.
virtual UINT32	GetNodeSize () const
	For finding the size of a node, in concrete classes derived from Node.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
Protected Member Functions
void	CopyNodeContents (NodeGridRect *NodeCopy)
	This method copies the node's contents to the node pointed to by NodeCopy.
Private Member Functions
void	RenderMainPoints (RenderRegion *pRender, DocRect RendRect, MILLIPOINT pixelWidth)
	Renders the main grid points within the given renderable rectangle.
void	RenderSubPoints (RenderRegion *pRender, DocRect RendRect, MILLIPOINT pixelWidth)
	Renders the sub grid points within the given renderable rectangle.
Private Attributes
double	MainXStep
double	MainYStep
double	SubXStep
double	SubYStep
UnitType	Units
double	Divisions
UINT32	Subdivisions

---

Detailed Description

A class defining a rectangular grid node.

Author:

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

Date:

8/2/94 Base Classes: NodeGrid, NodeRenderablePaper, NodeRenderable, Node, CCObject

See the Node class for an important note about producing derived classes of Node.

See also:

NodeGrid, NodeRenderablePaper

Definition at line 306 of file grid.h.

---

Constructor & Destructor Documentation

NodeGridRect::NodeGridRect (   )

This constructor creates a NodeGridRect linked to no other nodes, with all status flags false, and NULL bounding and pasteboard rectangles. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/2/94 Parameters: -  [INPUTS] [OUTPUTS]  Returns: - Errors: Definition at line 946 of file grid.cpp. : NodeGrid() { Units = INCHES; Divisions = 1.0; Subdivisions= 2; MainXStep = 72000.0; SubXStep = MainXStep/Subdivisions; MainYStep = MainXStep; SubYStep = SubXStep; }

---

Member Function Documentation

void NodeGridRect::CopyNodeContents (  NodeGridRect *  NodeCopy  )  [protected]

This method copies the node's contents to the node pointed to by NodeCopy. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/2/94 Parameters: -  [INPUTS] A  copy of this node [OUTPUTS] Returns: - Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Definition at line 1445 of file grid.cpp. { ENSURE(NodeCopy != NULL,"Trying to copy a NodeGridRect's contents to a NULL node"); NodeGrid::CopyNodeContents(NodeCopy); NodeCopy->MainXStep = this->MainXStep; NodeCopy->MainYStep = this->MainYStep; NodeCopy->SubXStep = this->SubXStep; NodeCopy->SubYStep = this->SubYStep; NodeCopy->Units = this->Units; NodeCopy->Divisions = this->Divisions; NodeCopy->Subdivisions = this->Subdivisions; }

String NodeGridRect::Describe (  BOOL  Plural, BOOL  Verbose )  [virtual]

To return a description of the Node object in either the singular or the plural. This method is called by the DescribeRange method. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/2/94 Parameters: Plural,:  Flag indicating if the string description should be plural or [INPUTS] singular. -  [OUTPUTS] Retuns: Description of the object The description will always begin with a lower case letter. Returns: Errors: A resource exception will be thrown if a problem occurs when loading the string resource. See also: - Reimplemented from NodeGrid. Definition at line 986 of file grid.cpp. { if (Plural) return (String(_R(IDS_GRIDRECT_DESCRP))); else return (String(_R(IDS_GRIDRECT_DESCRS))); };

void NodeGridRect::GetDebugDetails (  StringBase *  Str  )  [virtual]

For obtaining debug information about the Node. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/2/94 Parameters: -  [INPUTS] Str,:  String giving debug info about the node [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from NodeGrid. Definition at line 1500 of file grid.cpp. { NodeGrid::GetDebugDetails(Str); }

double NodeGridRect::GetDivisions (  BOOL  Scale = TRUE  )  [virtual]

Used to get the number of Units between each main grid point. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 17/10/95 Parameters: Scale  - account for scaling (only FALSE when saving for doc compatibility) [INPUTS] Returns: Number of Units between each main grid point Reimplemented from NodeGrid. Definition at line 1603 of file grid.cpp. { return NodeGrid::CalcDivisions(Scale); }

GridType NodeGridRect::GetGridType (   )  [inline, virtual]

Reimplemented from NodeGrid. Definition at line 334 of file grid.h. { return RECTANGULAR; }

double NodeGridRect::GetMainStep (   )  [inline, virtual]

Reimplemented from NodeGrid. Definition at line 336 of file grid.h. { return MainXStep; }

virtual UINT32 NodeGridRect::GetNodeSize (   )  const [inline, virtual]

For finding the size of a node, in concrete classes derived from Node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The size of the node in bytes Errors: If this function has not been overloaded in a non-abstract class then an ENSURE failure will occur. See also: - Reimplemented from NodeGrid. Definition at line 339 of file grid.h. { return sizeof(*this); }

UINT32 NodeGridRect::GetSubdivisions (   )  [virtual]

Used to get the number of subdivisions between each main grid point. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 1/3/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Num subdivisions Errors: - See also: - Reimplemented from NodeGrid. Definition at line 1624 of file grid.cpp. { return Subdivisions; }

UnitType NodeGridRect::GetUnits (  BOOL  Scale = TRUE  )  [virtual]

Gets the units used by the grid. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/95 Parameters: Scale  - account for unit scaling (only FALSE when saving for compatibility with old docs) [INPUTS] Returns: Units used by the grid Reimplemented from NodeGrid. Definition at line 1640 of file grid.cpp. { DimScale* pDimScale = DimScale::GetPtrDimScale(this); ERROR2IF(pDimScale==NULL,NOTYPE,"NodeGridRect::GetUnits() - pDimScale==NULL"); // if scaling turned on return scale units // (except if scaling is not to be accounted for - ie during saving for compatibility with old docs) UnitType ScaleUnits = pDimScale->GetScaleUnits(); if (Scale && ScaleUnits!=NOTYPE) return ScaleUnits; return Units; }

void NodeGridRect::PolyCopyNodeContents (  NodeRenderable *  pNodeCopy  )  [virtual]

Polymorphically copies the contents of this node to another. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 18/12/2003 Parameters: -  [OUTPUTS] Returns: Errors: An assertion failure will occur if NodeCopy is NULL Scope: protected Reimplemented from NodeGrid. Definition at line 1473 of file grid.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeGridRect), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeGridRect)) CopyNodeContents((NodeGridRect*)pNodeCopy); }

void NodeGridRect::Render (  RenderRegion *  pRender  )  [virtual]

Renders the rectangular grid item. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/2/94 Parameters: pRender  = a render region [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from NodeGrid. Definition at line 1012 of file grid.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // static INT32 bbb=0; // if (IsUserName("MarkN")) TRACE( _T("\n-------------------------------------------------------------------\n")); // if (IsUserName("MarkN")) TRACE( _T("NodeGridRect::Render - %ld\n\n"),bbb++); // See if the render region likes grids to be drawn.... if (!pRender->WantsGrids()) return; // If the grid is disabled, don't bother either if (IsDisabled()) return; View* pView = pRender->GetRenderView(); if ((pView == NULL) || (!IS_A(pView, DocView))) // No docview to render to. return; DocView *pDocView = (DocView *) pView; if (!pDocView->GetShowGridState() && Tool::GetCurrentID() != TOOLID_GRID) return; // Set up attributes for drawing grid points pRender->SaveContext(); // Don't set line attributes because grid points are now plotted used filled rects // pRender->SetLineWidth(0); // Means single-pixel lines // pRender->SetLineColour(GridColour); // Grid blobs are in this colour // Set fill attributes for grid point rectangle plotting... pRender->SetLineWidth(0); pRender->SetLineColour(COLOUR_TRANS); pRender->SetFillColour(GridColour); DocRect ClipRect = pRender->GetClipRect(); // Get the current clip rect DocRect RendRect; RendRect.lo.x = max(GridBoundingRect.lo.x,ClipRect.lo.x); // hi and lo renderable grid points RendRect.lo.y = max(GridBoundingRect.lo.y,ClipRect.lo.y); // derived from the clip rect and the RendRect.hi.x = min(GridBoundingRect.hi.x,ClipRect.hi.x); // node's bounding rect RendRect.hi.y = min(GridBoundingRect.hi.y,ClipRect.hi.y); if (RendRect.IsValid()) { MILLIPOINT PixelWidth = pRender->GetScaledPixelWidth(); // the width of a single pixel RenderMainPoints(pRender,RendRect,PixelWidth); // Render the main grid points (crosshairs) RenderSubPoints(pRender,RendRect,PixelWidth); // Render the sub grid points (dots) } pRender->RestoreContext(); #endif }

void NodeGridRect::RenderMainPoints (  RenderRegion *  pRender, DocRect  RendRect, MILLIPOINT  PixelWidth )  [private]

Renders the main grid points within the given renderable rectangle. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/2/94 Parameters: pRender  = region to render to [INPUTS] RendRect = Rectangle defining the renderable portion of the grid PixelWidth = width of a pixel in millipoints [OUTPUTS]  Returns: Errors: Scope: private Definition at line 1085 of file grid.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Set the fp render step values to be the underlying main grid step value double fp_RenderXStep = MainXStep; double fp_RenderYStep = MainYStep; // Calculate the step for rendering the grid in relation to the width of a pixel and the // factors of the dominant unit CalcGridRenderSteps(PixelWidth,&fp_RenderXStep,fp_RenderXStep*::GetUnitMultiple(Units),Units); CalcGridRenderSteps(PixelWidth,&fp_RenderYStep,fp_RenderYStep*::GetUnitMultiple(Units),Units); // Snap the render rect to these adjusted steps so we render all points within the renderable // portion of the grid Snap(&RendRect.lo,fp_RenderXStep,fp_RenderYStep); Snap(&RendRect.hi,fp_RenderXStep,fp_RenderYStep); ENSURE(RendRect.IsValid(),"RendRect is invalid in NodeGridRect::RenderMainPoints"); // Get fixed point versions of the fp values for speedy grid rendering MILLIPOINT RenderXStep = (MILLIPOINT)((fp_RenderXStep * GRID_REND_FACTOR)+0.5); MILLIPOINT RenderYStep = (MILLIPOINT)((fp_RenderYStep * GRID_REND_FACTOR)+0.5); // DumpRect(RendRect,"RendRect"); // Convert RendRect to fixed point values RendRect.lo.x *= GRID_REND_FACTOR; RendRect.lo.y *= GRID_REND_FACTOR; RendRect.hi.x *= GRID_REND_FACTOR; RendRect.hi.y *= GRID_REND_FACTOR; DocRect ScaledBB = GridBoundingRect; ScaledBB.lo.x *= GRID_REND_FACTOR; ScaledBB.lo.y *= GRID_REND_FACTOR; ScaledBB.hi.x *= GRID_REND_FACTOR; ScaledBB.hi.y *= GRID_REND_FACTOR; // Make sure the render rectangle region doesn't lie outside the bounding rect while (RendRect.lo.x < ScaledBB.lo.x) RendRect.lo.x += RenderXStep; while (RendRect.lo.y < ScaledBB.lo.y) RendRect.lo.y += RenderYStep; while (RendRect.hi.x >= ScaledBB.hi.x) RendRect.hi.x -= RenderXStep; while (RendRect.hi.y >= ScaledBB.hi.y) RendRect.hi.y -= RenderYStep; RendRect.hi.x += GRID_REND_FACTOR; // compensate for errors (i.e. add the bodge factor) RendRect.hi.y += GRID_REND_FACTOR; // compensate for errors // Render those grid points boy! DocCoord GridPoint,TrueGridPoint; const MILLIPOINT Pix = pRender->GetScaledPixelWidth(); // const MILLIPOINT PixBy2 = Pix/2; const MILLIPOINT Length = PIX_CROSSHAIR_SIZE * Pix; for (GridPoint.x=RendRect.lo.x;GridPoint.x<=RendRect.hi.x;GridPoint.x+=RenderXStep) { for (GridPoint.y=RendRect.lo.y;GridPoint.y<=RendRect.hi.y;GridPoint.y+=RenderYStep) { // Scale the fixed point grid coord down to get the true coord of the grid point TrueGridPoint.x = (GridPoint.x+(GRID_REND_FACTOR/2)) / GRID_REND_FACTOR; TrueGridPoint.y = (GridPoint.y+(GRID_REND_FACTOR/2)) / GRID_REND_FACTOR; // pRender->DrawCross(TrueGridPoint, PIX_CROSSHAIR_SIZE); // Phil says: Don't use DrawPixel because it can't be trusted to plot the // same pixel under GDI as it does under GDraw! // Instead draw two rectangles centered around the required coord. DocRect Horz(TrueGridPoint.x-Length,TrueGridPoint.y,TrueGridPoint.x+Length+Pix,TrueGridPoint.y+Pix); pRender->DrawRect(&Horz); DocRect Vert(TrueGridPoint.x,TrueGridPoint.y-Length,TrueGridPoint.x+Pix,TrueGridPoint.y+Length+Pix); pRender->DrawRect(&Vert); } } #endif }

void NodeGridRect::RenderSubPoints (  RenderRegion *  pRender, DocRect  RendRect, MILLIPOINT  PixelWidth )  [private]

Renders the sub grid points within the given renderable rectangle. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/2/94 Parameters: pRender  = region to render to [INPUTS] RendRect = Rectangle defining the renderable portion of the grid PixelWidth = width of a pixel in millipoints [OUTPUTS]  Returns: Errors: Scope: private Definition at line 1181 of file grid.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Set the fp render step values to be the underlying sub grid step value double fp_RenderXStep = SubXStep; double fp_RenderYStep = SubYStep; // Calculate the step for rendering the grid in relation to the width of a pixel and the // factors of the dominant unit CalcGridRenderSteps(PixelWidth,&fp_RenderXStep,MainXStep,Units); CalcGridRenderSteps(PixelWidth,&fp_RenderYStep,MainYStep,Units); // If the render step is greater than the main step then don't render the sub grid if (fp_RenderXStep >= MainXStep) return; if (fp_RenderYStep >= MainYStep) return; // Snap the render rect to the render steps so we render all points within the renderable // portion of the grid Snap(&RendRect.lo,fp_RenderXStep,fp_RenderYStep); Snap(&RendRect.hi,fp_RenderXStep,fp_RenderYStep); ENSURE(RendRect.IsValid(),"RendRect is invalid in NodeGridRect::RenderSubPoints"); // Get fixed point versions of the fp values for speedy grid rendering MILLIPOINT RenderXStep = (MILLIPOINT)((fp_RenderXStep * GRID_REND_FACTOR)+0.5); MILLIPOINT RenderYStep = (MILLIPOINT)((fp_RenderYStep * GRID_REND_FACTOR)+0.5); // Convert RendRect to fixed point values RendRect.lo.x *= GRID_REND_FACTOR; RendRect.lo.y *= GRID_REND_FACTOR; RendRect.hi.x *= GRID_REND_FACTOR; RendRect.hi.y *= GRID_REND_FACTOR; DocRect ScaledBB = GridBoundingRect; ScaledBB.lo.x *= GRID_REND_FACTOR; ScaledBB.lo.y *= GRID_REND_FACTOR; ScaledBB.hi.x *= GRID_REND_FACTOR; ScaledBB.hi.y *= GRID_REND_FACTOR; // Make sure the render rectangle region doesn't lie outside the bounding rect while (RendRect.lo.x < ScaledBB.lo.x) RendRect.lo.x += RenderXStep; while (RendRect.lo.y < ScaledBB.lo.y) RendRect.lo.y += RenderYStep; while (RendRect.hi.x >= ScaledBB.hi.x) RendRect.hi.x -= RenderXStep; while (RendRect.hi.y >= ScaledBB.hi.y) RendRect.hi.y -= RenderYStep; RendRect.hi.x += GRID_REND_FACTOR; // compensate for errors (i.e. add the bodge factor) RendRect.hi.y += GRID_REND_FACTOR; // compensate for errors // Go ahead punk, render those points DocCoord GridPoint,TrueGridPoint; const MILLIPOINT Pix = pRender->GetScaledPixelWidth(); // const MILLIPOINT PixBy2 = Pix/2; for (GridPoint.x=RendRect.lo.x;GridPoint.x<=RendRect.hi.x;GridPoint.x+=RenderXStep) { for (GridPoint.y=RendRect.lo.y;GridPoint.y<=RendRect.hi.y;GridPoint.y+=RenderYStep) { // Scale the fixed point grid coord down to get the true coord of the grid point TrueGridPoint.x = (GridPoint.x+(GRID_REND_FACTOR/2)) / GRID_REND_FACTOR; TrueGridPoint.y = (GridPoint.y+(GRID_REND_FACTOR/2)) / GRID_REND_FACTOR; // pRender->DrawPixel(TrueGridPoint); // Phil says: Don't use DrawPixel because it can't be trusted to plot the // same pixel under GDI as it does under GDraw! // Instead draw a rectangle 1*1 pixels around the required coord. DocRect Pixel( TrueGridPoint.x, TrueGridPoint.y, TrueGridPoint.x+Pix, TrueGridPoint.y+Pix); pRender->DrawRect(&Pixel); } } #endif }

BOOL NodeGridRect::SetGridParams (  double  Div, UINT32  Subdiv, UnitType  NewUnits, BOOL  Scale = TRUE )  [virtual]

Defines the grid. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: Div  - Number of Units between each main grid point [INPUTS] Subdiv - Number of subdivisions between each main grid point NewUnits - The units the grid is defined in Scale - account for unit scaling (only FALSE when loading for compatibility with old docs) Returns: FALSE if fails Reimplemented from NodeGrid. Definition at line 1533 of file grid.cpp. { if (Div < 0) { ERROR3("NodeGridRect::SetGridParams() - Div < 0!"); Div = 0.0; } if (Subdiv < 1) { ERROR3("NodeGridRect::SetGridParams() - SubDiv < 1!"); Subdiv = 1; } DimScale* pDimScale = DimScale::GetPtrDimScale(this); ERROR2IF(pDimScale==NULL,FALSE,"NodeGridRect::SetGridParams() - pDimScale==NULL"); // set the raw values in the grid - but only set units if scaling turned off // (except if scaling is not to be accounted for - ie during loading for compatibility with old docs - yuk!) Divisions = Div; Subdivisions = Subdiv; if (Scale==FALSE || pDimScale->GetScaleUnits()==NOTYPE) Units = NewUnits; // convert the divisions and units into a millipoint grid spacing (accounting for unit scaling) - yuk! double GridSpacing=0; if (Scale) { BOOL ok = pDimScale->ComponentsToMillipoint(&GridSpacing, Divisions, GetUnits()); if (!ok) return FALSE; } else { DocUnitList* pDocUnitList = DocUnitList::GetCurrentDocUnitList(); ERROR2IF(pDocUnitList==NULL,FALSE,"DimScale::ComponentsToMillipoint() - pDocUnitList==NULL"); Unit* pUnit = pDocUnitList->FindUnit(Units); ERROR2IF(pUnit==NULL,FALSE,"DimScale::ComponentsToMillipoint() - pUnit==NULL"); GridSpacing = Div * pUnit->GetMillipoints(); } if (GridSpacing<1) { ERROR3("NodeGridRect::SetGridParams() - GridSpacing < 1!"); GridSpacing=1; } MainXStep = GridSpacing; SubXStep = MainXStep/Subdivisions; if (SubXStep<1) { ERROR3("NodeGridRect::SetGridParams() - SubXStep < 1!"); SubXStep=1; } MainYStep = MainXStep; SubYStep = SubXStep; return TRUE; }

Node * NodeGridRect::SimpleCopy (  void   )  [virtual]

This method returns a shallow copy of the node with all Node pointers NULL. The function is virtual, and must be defined for all derived classes. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/2/94 Parameters: -  [INPUTS] [OUTPUTS]  Returns: A copy of the node, or NULL if memory runs out Errors: If memory runs out when trying to copy, then ERROR is called with an out of memory error and the function returns NULL. Scope: protected Reimplemented from NodeGrid. Definition at line 1417 of file grid.cpp. { NodeGridRect* NodeCopy = new NodeGridRect(); if (NodeCopy != NULL) CopyNodeContents(NodeCopy); return (NodeCopy); }

BOOL NodeGridRect::Snap (  DocRect *  pDocRect, const DocCoord &  PrevCoord, const DocCoord &  CurCoord )  [virtual]

Snaps the given rect to the nearest position on the grid, preserving its width and height. The coords of the rect used for the snapping are determined by the PrevCoord and CurCoord coords supplied. This is done to allow the user to control how a selection rectangle is snapped to the grid by the direction of his/her last mouse movement. To force the bottom left hand corner of the rect to be snapped, supply PrevCoord=(0,0) and CurCoord(-1,-1). Scope: public. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/2/94 Parameters: pDocCoord  - the rectangle to snap [INPUTS] StartDrag - Start coord of drag EndDrag - End coord of drag [OUTPUTS]  Returns: TRUE - the DocRect been snapped to the grid. FALSE - the DocRect has not been processed. Reimplemented from NodeGrid. Definition at line 1325 of file grid.cpp. { if (IsDisabled()) return FALSE; ENSURE(SubXStep !=0,"SubXStep ==0 in NodeGridRect::Snap"); ENSURE(SubYStep !=0,"SubYStep ==0 in NodeGridRect::Snap"); INT32 xdir = CurCoord.x - PrevCoord.x; INT32 ydir = CurCoord.y - PrevCoord.y; INT32 x,y,prevx, prevy; if (LastXDir == 0) LastXDir = xdir; if (xdir == 0) xdir = LastXDir; LastXDir = xdir; if (xdir <= 0) x = pDocRect->lo.x; else x = pDocRect->hi.x; if (LastYDir == 0) LastYDir = ydir; if (ydir == 0) ydir = LastYDir; LastYDir = ydir; if (ydir <= 0) y = pDocRect->lo.y; else y = pDocRect->hi.y; if (!GridBoundingRect.ContainsCoord(DocCoord(x,y))) return (FALSE); prevx = x; prevy = y; x = SnapOrdinate(x,SubXStep,XOrigin); y = SnapOrdinate(y,SubYStep,YOrigin); if (!GridBoundingRect.ContainsCoord(DocCoord(x,y))) return (FALSE); pDocRect->Translate(x-prevx,y-prevy); return (TRUE); }

BOOL NodeGridRect::Snap (  DocCoord *  pDocCoord, double  XStep, double  YStep )

Same as Snap(pDocCoord), except the coord is snapped to grid points at the given intervals. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/2/94 Parameters: pDocCoord  - the coord to snap [INPUTS] XStep - the x step to use when snapping the point YStep - the y step to use when snapping the point [OUTPUTS]  Returns: TRUE - the DocCoord has been snapped to the grid. FALSE - the DocCoord has not been processed. Errors: Scope: public Definition at line 1382 of file grid.cpp. { if (IsDisabled()) return FALSE; ENSURE(XStep!=0,"XStep==0 in NodeGridRect::Snap(pDocCoord,XStep,YStep"); ENSURE(YStep!=0,"YStep==0 in NodeGridRect::Snap(pDocCoord,XStep,YStep"); pDocCoord->x = SnapOrdinate(pDocCoord->x,XStep,XOrigin); pDocCoord->y = SnapOrdinate(pDocCoord->y,YStep,YOrigin); return (TRUE); }

BOOL NodeGridRect::Snap (  DocCoord *  pDocCoord  )  [virtual]

Snaps to given coord to the nearest grid point. If it is not appropriate to snap the coord to the grid (at the moment this means the coord lies outside the grid object's bounding box), then FALSE is returned. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/2/94 Parameters: pDocCoord  = a coord in Spread coords [INPUTS] [OUTPUTS]  Returns: TRUE - the DocCoord has been snapped to the grid. FALSE - the DocCoord has not been processed. Errors: Scope: public Reimplemented from NodeGrid. Definition at line 1278 of file grid.cpp. { if (IsDisabled()) return FALSE; ENSURE(SubXStep !=0,"SubXStep ==0 in NodeGridRect::Snap"); ENSURE(SubYStep !=0,"SubYStep ==0 in NodeGridRect::Snap"); if (!GridBoundingRect.ContainsCoord(DocCoord(pDocCoord->x,pDocCoord->y))) return (FALSE); MILLIPOINT x = SnapOrdinate(pDocCoord->x,SubXStep,XOrigin); MILLIPOINT y = SnapOrdinate(pDocCoord->y,SubYStep,YOrigin); if (!GridBoundingRect.ContainsCoord(DocCoord(x,y))) return (FALSE); pDocCoord->x = x; pDocCoord->y = y; return (TRUE); }

---

Member Data Documentation

double NodeGridRect::Divisions [private]

Definition at line 359 of file grid.h.

double NodeGridRect::MainXStep [private]

Definition at line 353 of file grid.h.

double NodeGridRect::MainYStep [private]

Definition at line 354 of file grid.h.

UINT32 NodeGridRect::Subdivisions [private]

Definition at line 360 of file grid.h.

double NodeGridRect::SubXStep [private]

Definition at line 355 of file grid.h.

double NodeGridRect::SubYStep [private]

Definition at line 356 of file grid.h.

UnitType NodeGridRect::Units [private]

Definition at line 358 of file grid.h.

---

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

• Kernel/grid.h (r1785/r1282)
• Kernel/grid.cpp (r1785/r1361)

---