NodeSimpleShape Class Reference

A NodeSimpleShape is the base class for several primitive shapes that are bounded by a Parallelogram. This class contains 2 Pure Virtual functions that need to be re-written in base classes. These should be the only functions that need re-writting in most cases. They build a path for the shape given a bounding parallelogram. More...

#include <nodeshap.h>

Inheritance diagram for NodeSimpleShape:

List of all members.

Public Member Functions
	NodeSimpleShape ()
	This constructor creates a NodeSimpleShape linked to no other with all status flags false and an uninitialized bounding rectangle. Note: SetUpPath() must be called before the NodeSimpleShape is in a state in which it can be used.
	NodeSimpleShape (Node *ContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
BOOL	SetUpPath (INT32 RequiredSize=12, INT32 BlockSize=12)
	To initialise the path used by the shape into a state that can be used, by allocating memory, setting up member variables properly.
virtual Node *	SimpleCopy ()
	Makes a copy of all the data in the node.
void	CopyNodeContents (NodeSimpleShape *NodeCopy)
	Copies the data in the node by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
virtual void	CreateShape (DocRect NewRect)
	Should create a the shape to fit the current parallelogram. This version does nothing as there should always be a derived class version.
virtual void	UpdateShape ()
	Should update the the shape to the current parallelogram. This version does nothing as there should always be a derived class version.
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
	if the bounding rect is valid it is returned, if not, it is recalculated and then returned.
virtual DocRect	GetBlobBoundingRect ()
	This calculates the bounding box of the path and adds in the influence of the selection blobs. It does not consider if the blobs are visible or not, it just gives the bounding box that they would occupy if they were visible.
virtual void	Render (RenderRegion *pRender)
	Will render the path contained within the object to the given render region.
virtual void	RenderEorDrag (RenderRegion *)
	Renders a version of the path for EORed dragging of shapes.
virtual void	RenderObjectBlobs (RenderRegion *pRender)
	Renders the Object blobs for a Node Shape.
virtual void	RenderTinyBlobs (RenderRegion *pRender)
	Renders the Tiny blobs for a Node Shape.
virtual void	Transform (TransformBase &)
	Transforms the shapes parallelogram and then re-builds the shape to fit it.
virtual UINT32	GetNodeSize () const
	For finding the size of the node.
virtual BOOL	CanBecomeA (BecomeA *pBecomeA)
	This function is used by the convert to shapes operation. It determines if the node or any of its children can convert themselves into an InkClass object.
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Transforms the object into another type of object. Note: changed 7/10/94 by MarkN to take the pBecomeA param, so that more data could be passed to these functions in the future without causing massive rebuilds due to the editing of node.h.
void	GetDebugDetails (StringBase *Str)
	Displays debugging info of the tree For obtaining debug information about the Node.
virtual BOOL	OnClick (DocCoord, ClickType, ClickModifiers, Spread *)
	Allows the Node to respond to clicks by selecting its blobs or starting drags etc. This functions should be overridden in the all the NodeRenderableInk classes so that this version never gets called. Eg the NodePath class might claim the click if it happened over one of its unselected blobs.
BOOL	IsNearControlHandle (DocCoord Coord, INT32 *CoordNum)
	This function tests to see if the Coord passed in is close to any of the control points in the Ellipse. If it is, the number of the control point is set in CoordNum and TRUE is returned. If not, the value of CoordNum is left unchanged and FALSE is returned.
virtual void	HandleBlobDrag (DocCoord &, Spread *, INT32)
	This is the base class version of this function, which does nothing. All the work should be done in the derived classes. These should do as follows. When a drag is started on one of the paths blobs this is called. It tries to fire up an operation that will perform a drag of all the selected points, including all the EORing of the relavent parts of the curve. If it fails it will inform the user and not bother.
virtual BOOL	Snap (DocCoord *pDocCoord)
	Snaps to given coord to the nearest point on the path. If it is not appropriate to snap the coord to the path (at the moment this means the coord is too far awawy), then FALSE is returned.
virtual 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.
virtual BOOL	SnapToCoords (DocCoord *pDocCoord)
	This function tries to magnetically snap the supplied coord to the shape. This version of the function tries to snap to coords at the centre of the shape and in the middle of each of the edges.
virtual double	GetRotationAngle ()
	Returns the current angle of rotation of the simple shape. This is calculated as the angle from the midpoint of the upper paralleogram line to the positive x-axis.
virtual BOOL	IsTypeExtendible () const
virtual DocRect	ValidateExtend (const ExtendParams &ExtParams)
	Tests to see whether this shape's centre-point is positioned so as to make an extend operation irreversible.
virtual void	Extend (const ExtendParams &ExtParams)
	Perform an Extend operation on this shape. Behaviour is as follows:.
Public Attributes
Path	InkPath
DocCoord	Parallel [4]
Private Member Functions
	CC_DECLARE_DYNCREATE (NodeSimpleShape)

---

Detailed Description

A NodeSimpleShape is the base class for several primitive shapes that are bounded by a Parallelogram. This class contains 2 Pure Virtual functions that need to be re-written in base classes. These should be the only functions that need re-writting in most cases. They build a path for the shape given a bounding parallelogram.

Author:

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

Date:

22/9/93

Definition at line 129 of file nodeshap.h.

---

Constructor & Destructor Documentation

NodeSimpleShape::NodeSimpleShape (   )

This constructor creates a NodeSimpleShape linked to no other with all status flags false and an uninitialized bounding rectangle. Note: SetUpPath() must be called before the NodeSimpleShape is in a state in which it can be used. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 22/9/93 See also: SetUpPath Definition at line 200 of file nodeshap.cpp. : NodeRenderableInk() { }

NodeSimpleShape::NodeSimpleShape (  Node *  ContextNode, AttachNodeDirection  Direction, BOOL  Locked = FALSE, BOOL  Mangled = FALSE, BOOL  Marked = FALSE, BOOL  Selected = FALSE )

---

Member Function Documentation

BOOL NodeSimpleShape::CanBecomeA (  BecomeA *  pBecomeA  )  [virtual]

This function is used by the convert to shapes operation. It determines if the node or any of its children can convert themselves into an InkClass object. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/94 Parameters: InkClass,:  The class of object [INPUTS] pNumObjects = ptr to place number of objects of type pClass that will be created (Note: can be NULL). pNumObects in undefined on entry Returns: TRUE if the node, or any of its children can transmogrify themselves to become an InkClass object The number you put into pNumObjects (if it's not NULL) should exactly equal the total number of pClass objects you create. It should NOT contain any additional objects you may produce such as group objects for containing the pClass object, or attributes. Also, the entry value of *pNumObjects cannot be assumed to be 0. Reimplemented from Node. Reimplemented in NodeBitmap. Definition at line 828 of file nodeshap.cpp. { // The NodeSimpleShape can become a NodePath if (pBecomeA->BAPath()) { pBecomeA->AddCount(1); return TRUE; } return FALSE; }

NodeSimpleShape::CC_DECLARE_DYNCREATE (  NodeSimpleShape   )  [private]

void NodeSimpleShape::CopyNodeContents (  NodeSimpleShape *  NodeCopy  )

Copies the data in the node by first calling the base class to get it to copy its stuff, and then copying its own stuff Scope: protected. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Parameters: NodeCopy  - The node to copy [INPUTS] See also: NodeRenderableInk::CopyNodeContents Definition at line 241 of file nodeshap.cpp. { NodeRenderableInk::CopyNodeContents(NodeCopy); //Copy contents specific to derived class here if (NodeCopy->InkPath.Initialise(InkPath.GetNumCoords(),12)) { // Copy the path data NodeCopy->InkPath.CopyPathDataFrom(&InkPath); // copy the parralleogram data NodeCopy->Parallel[0] = Parallel[0]; NodeCopy->Parallel[1] = Parallel[1]; NodeCopy->Parallel[2] = Parallel[2]; NodeCopy->Parallel[3] = Parallel[3]; } }

void NodeSimpleShape::CreateShape (  DocRect  NewRect  )  [virtual]

Should create a the shape to fit the current parallelogram. This version does nothing as there should always be a derived class version. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/9/93 Parameters: DocRect  - representing the rectangle to be created. [INPUTS] Reimplemented in NodeEllipse, and NodeRect. Definition at line 425 of file nodeshap.cpp. { // You are not supposed to be calling this. You should have called a // derived classes version of this function ENSURE(FALSE, "NodeSimpleShape::CreateShape - You called the base class version"); }

BOOL NodeSimpleShape::DoBecomeA (  BecomeA *  pBecomeA  )  [virtual]

Transforms the object into another type of object. Note: changed 7/10/94 by MarkN to take the pBecomeA param, so that more data could be passed to these functions in the future without causing massive rebuilds due to the editing of node.h. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 29/4/94 Parameters: pBecomeA  = ptr to a class that contains all the info needed to become a new [INPUTS] type of node. -  [OUTPUTS] Returns: TRUE if the object has been transformed, FALSE if we run out of memory See also: NodeSimpleShape::CanBecomeA Reimplemented from Node. Reimplemented in NodeBitmap. Definition at line 861 of file nodeshap.cpp. { // Check for a NULL entry param ERROR2IF_PF(pBecomeA == NULL,FALSE,("pBecomeA is NULL")); // This lump checks that the Reason is one that we understand // It also makes sure that we don't have a NULL UndoOp ptr BOOL ValidReason = (pBecomeA->GetReason() == BECOMEA_REPLACE || pBecomeA->GetReason() == BECOMEA_PASSBACK); ERROR2IF_PF(!ValidReason,FALSE,("Unkown BecomeA reason %d",pBecomeA->GetReason())); // pBecomeA->Reason is one that we understand. BOOL Success = TRUE; // Our success flag (Important that this defaults to TRUE) NodePath* pNewNodePath = NULL; // Ptr to a new NodePath, if we get to make one. if (pBecomeA->BAPath()) { // We need to create a new NodePath, no matter what the reason. // Allocate a new NodePath node ALLOC_WITH_FAIL(pNewNodePath, (new NodePath), pBecomeA->GetUndoOp()); Success = (pNewNodePath != NULL); // Initialise the path if (Success) CALL_WITH_FAIL(pNewNodePath->InkPath.Initialise(InkPath.GetNumCoords(),12), pBecomeA->GetUndoOp(), Success); if (Success) CALL_WITH_FAIL(pNewNodePath->InkPath.CopyPathDataFrom(&InkPath), pBecomeA->GetUndoOp(), Success); // If Success is TRUE, then we now have a new NodePath object that contains this shape's path if (Success) { switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE : { // It's a BECOMEA_REPLACE, so replace this node with the new NodePath in an undoable way // Can't do it in an undoable way without an Undo Op ERROR2IF_PF(pBecomeA->GetUndoOp() == NULL,FALSE,("GetUndoOp() returned NULL")); // Firstly, hide this node NodeHidden* pNodeHidden; Success = pBecomeA->GetUndoOp()->DoHideNode(this, TRUE, &pNodeHidden); if (Success) { // Insert the new NodePath into the tree, next to the hidden node pNewNodePath->AttachNode(pNodeHidden,NEXT); // Copy the node's attributes CALL_WITH_FAIL(CopyChildrenTo(pNewNodePath), pBecomeA->GetUndoOp(), Success); if (Success) { // Set the bounds pNewNodePath->InvalidateBoundingRect(); pNewNodePath->SetSelected(IsSelected()); // Create a hide node action to hide the node when we undo HideNodeAction* UndoHideNodeAction; Success = (HideNodeAction::Init(pBecomeA->GetUndoOp(), pBecomeA->GetUndoOp()->GetUndoActionList(), pNewNodePath, TRUE, // Include subtree size ( Action**)(&UndoHideNodeAction)) != AC_FAIL); } } if (Success) pBecomeA->PassBack(pNewNodePath, this); } break; case BECOMEA_PASSBACK : Success = pBecomeA->PassBack(pNewNodePath,this); break; default: break; } } } if (!Success) { if (pNewNodePath != NULL) { // Delete all the NodePath's children (if it has any) and unlink it from the tree (if it's linked) // This is all done by CascadeDelete() pNewNodePath->CascadeDelete(); delete pNewNodePath; pNewNodePath = NULL; } } return Success; }

void NodeSimpleShape::Extend (  const ExtendParams &  ExtParams  )  [virtual]

Perform an Extend operation on this shape. Behaviour is as follows:. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 25/11/1999 Parameters: ExtParams  parameters describing the extension. [INPUTS] this  NodeSimpleShape will be extended in accordance with ExtParams. [OUTPUTS] Returns: the shape extends separately along each axis. if the shape is asked to stretch, it scales along the corresponding axes. if the shape is asked to extend, it is translated as a whole, as described by ExtParams. Returns: Errors: See also: class Extender Reimplemented from Node. Definition at line 1179 of file nodeshap.cpp. { // do the extension operations on ourself. TransformStretchObject(ExtParams); TransformTranslateObject(ExtParams); // do the base-class implementation to extend our children. Node::Extend(ExtParams); }

DocRect NodeSimpleShape::GetBlobBoundingRect (   )  [virtual]

This calculates the bounding box of the path and adds in the influence of the selection blobs. It does not consider if the blobs are visible or not, it just gives the bounding box that they would occupy if they were visible. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/02/94 Returns: DocRect - Returns the bounding rect of the path and its blobs Reimplemented from NodeRenderable. Reimplemented in NodeEllipse. Definition at line 617 of file nodeshap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Find the Shapes bounding rectangle DocRect Rect = GetBoundingRect(); // Find the blob manager BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); // And if we can find the current view, add on the size of a selection blob if (pBlobMgr!= NULL) { // Wee need to add in each of the blobs. there is a blob on each corner // of the parallelogram DocRect BlobSize; pBlobMgr->GetBlobRect(Parallel[0], &BlobSize); Rect = Rect.Union(BlobSize); // Next corner of the parallelogram pBlobMgr->GetBlobRect(Parallel[1], &BlobSize); Rect = Rect.Union(BlobSize); // and the next pBlobMgr->GetBlobRect(Parallel[2], &BlobSize); Rect = Rect.Union(BlobSize); // and the last one pBlobMgr->GetBlobRect(Parallel[3], &BlobSize); Rect = Rect.Union(BlobSize); } // Make sure we include the Bounds of our children IncludeChildrensBoundingRects(&Rect); // return the rectangle with the blobs included return Rect; #else return DocRect(0,0,0,0); #endif }

DocRect NodeSimpleShape::GetBoundingRect (  BOOL  DontUseAttrs = FALSE, BOOL  HitTest = FALSE )  [virtual]

if the bounding rect is valid it is returned, if not, it is recalculated and then returned. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 17/02/94 Parameters: DontUseAttrs  - TRUE if we should ignore the nodes attributes. [INPUTS] Defaults to FALSE HitTest - TRUE if being called during HitTest Returns: The nodes bounding rect See also: NodeSimpleShape::GetBlobBoundingRect Reimplemented from NodeRenderableBounded. Definition at line 570 of file nodeshap.cpp. { if (!IsBoundingRectValid || DontUseAttrs) { // Something to put the new bounding rectangle in DocRect NewBoundingRect; // Find out what the paths bounding rect is now if (!CalculatePathBoundingRect(InkPath, DontUseAttrs, &NewBoundingRect)) { // GDraw failed to find out how big the bounding rect // we will have to make do with the bounding rect of the coords NewBoundingRect = InkPath.GetBoundingRect(); } // we have a new bounding rect - decide what to do with it if (DontUseAttrs) { // but it is not the real bounding rect, so just return it return NewBoundingRect; } // Update the Nodes bounding rectangle BoundingRectangle = NewBoundingRect; // Mark the rect as valid IsBoundingRectValid = TRUE; } // return the current state of the bounding rect return BoundingRectangle; }

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

Displays debugging info of the tree For obtaining debug information about the Node. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/93 Parameters: Str,:  String giving debug info about the node [OUTPUTS] Reimplemented from NodeRenderableBounded. Definition at line 315 of file nodeshap.cpp. { #ifdef _DEBUG // Call base class NodeRenderableInk::GetDebugDetails( Str ); InkPath.FindStartOfPath(); String_256 TempStr; (*Str) += TEXT( "\r\nEllipse Path Data Dump\r\n" ); TempStr._MakeMsg( TEXT( "Parallelogram :-\r\n\t#1%ld,\t#2%ld\r\n") TEXT("\t#3%ld,\t#4%ld\r\n") TEXT("\t#5%ld,\t#6%ld\r\n") TEXT("\t#7%ld,\t#8%ld\r\n"), Parallel[0].x, Parallel[0].y, Parallel[1].x, Parallel[1].y, Parallel[2].x, Parallel[2].y, Parallel[3].x, Parallel[3].y ); (*Str) += TempStr; DocRect BlobRect = GetBlobBoundingRect(); TempStr._MakeMsg( TEXT("Blob Bounding Rect :-\r\n\t#1%ld,\t#2%ld\r\n\t#3%ld,\t#4%ld\r\n"), BlobRect.lo.x, BlobRect.lo.y, BlobRect.hi.x, BlobRect.hi.y ); (*Str) += TempStr; if ( InkPath.IsFilled ) (*Str) += TEXT( "The Path is Filled\r\n" ); (*Str) += TEXT( "\r\nNum\tType\tX Coord\tY Coord\r\n" ); PathVerb* Verbs = InkPath.GetVerbArray(); DocCoord* Coords = InkPath.GetCoordArray(); // PathFlags* Flags = InkPath.GetFlagArray(); for (INT32 i=0; i<InkPath.GetNumCoords(); i++) { // Add the info to the string TempStr._MakeMsg( TEXT("#1%d.\t#2%d\t#3%ld,\t#4%ld\r\n"), i, Verbs[i], Coords[i].x, Coords[i].y ); (*Str) += TempStr; } #endif }

UINT32 NodeSimpleShape::GetNodeSize (   )  const [virtual]

For finding the size of the node. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/93 Returns: The size of the node in bytes See also: Node::GetSubtreeSize Reimplemented from Node. Reimplemented in NodeAnimatingBitmap, NodeBitmap, NodeEllipse, and NodeRect. Definition at line 673 of file nodeshap.cpp. { return (sizeof(NodeSimpleShape)); }

double NodeSimpleShape::GetRotationAngle (   )  [virtual]

Returns the current angle of rotation of the simple shape. This is calculated as the angle from the midpoint of the upper paralleogram line to the positive x-axis. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 24/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The rotation angle of this simple shape NodeRenderableInk See also: NodeRenderableBounded::GetRotationAngle Reimplemented from NodeRenderableBounded. Definition at line 1104 of file nodeshap.cpp. { DocCoord MidPoint((Parallel[0].x + Parallel[1].x)/2, (Parallel[0].y + Parallel[1].y)/2); DocRect Bounds(Parallel[0],Parallel[0]); Bounds.IncludePoint(Parallel[1]); Bounds.IncludePoint(Parallel[2]); Bounds.IncludePoint(Parallel[3]); DocCoord Centre((Bounds.LowCorner().x+Bounds.HighCorner().x)/2, (Bounds.LowCorner().y+Bounds.HighCorner().y)/2); DocCoord Offset = MidPoint - Centre; double Angle = atan2((double)Offset.y, (double)Offset.x); if (Angle == HUGE_VAL) Angle = 0.0; return Angle; }

void NodeSimpleShape::HandleBlobDrag (  DocCoord &  PointerPos, Spread *  pSpread, INT32  FixedCorner )  [virtual]

This is the base class version of this function, which does nothing. All the work should be done in the derived classes. These should do as follows. When a drag is started on one of the paths blobs this is called. It tries to fire up an operation that will perform a drag of all the selected points, including all the EORing of the relavent parts of the curve. If it fails it will inform the user and not bother. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 2/6/94 Parameters: PointerPos  - The position the mouse pointer clicked [INPUTS] pSpread - the spread that the click was on FixedCorner - The corner of the parallelogram that will stay fixed during the drag Reimplemented in NodeEllipse, and NodeRect. Definition at line 798 of file nodeshap.cpp. { ENSURE( FALSE, "NodeSimpleShape::HandleBlobDrag() called. Derived class should have been used"); }

BOOL NodeSimpleShape::IsNearControlHandle (  DocCoord  Coord, INT32 *  CoordNum )

This function tests to see if the Coord passed in is close to any of the control points in the Ellipse. If it is, the number of the control point is set in CoordNum and TRUE is returned. If not, the value of CoordNum is left unchanged and FALSE is returned. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 9/11/94 Parameters: Coord  - The Coordinate that we want to test [INPUTS] CoordNum  - The number of the control point that the coord was close to. [OUTPUTS] This parameter is only changed it the function returns TRUE. Returns: TRUE if the Coord was close to one of the control points, FALSE otherwise Definition at line 748 of file nodeshap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Find the blob manager BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr==NULL) return FALSE; // Find out about the size of a blob DocRect BlobRect; pBlobMgr->GetBlobRect(Coord, &BlobRect); // Check to see if it is near any of the blobs for (INT32 i=0; i<4; i++) { // Check for collision with the control points if (BlobRect.ContainsCoord(Parallel[i])) { // Tell them which control point it waas over *CoordNum = i; // we have used that click up, so tell the world return TRUE; } } #endif // was not over any of the control points return FALSE; }

virtual BOOL NodeSimpleShape::IsTypeExtendible (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 205 of file nodeshap.h. { return TRUE; }

BOOL NodeSimpleShape::OnClick (  DocCoord  PointerPos, ClickType  Click, ClickModifiers  ClickMods, Spread *  pSpread )  [virtual]

Allows the Node to respond to clicks by selecting its blobs or starting drags etc. This functions should be overridden in the all the NodeRenderableInk classes so that this version never gets called. Eg the NodePath class might claim the click if it happened over one of its unselected blobs. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 2/6/94 Parameters: PointerPos  - The Location of the mouse pointer at the time of the click [INPUTS] Click - The type of click received (single, double, drag etc) ClickMods - The modifiers to the click (eg shift, control etc ) Returns: BOOL - TRUE if the node claims the click as its own and FALSE if it is not interested in the click Reimplemented from NodeRenderableInk. Reimplemented in NodeBitmap. Definition at line 700 of file nodeshap.cpp. { PORTNOTETRACE("other","NodeSimpleShape::OnClick - do nothing"); #if !defined(EXCLUDE_FROM_RALPH) // we only handle the click if we can confirm that object blobs are being displayed. BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr == NULL) return FALSE; if (!pBlobMgr->GetCurrentInterest().Object) return FALSE; INT32 ClickCorner; if (IsNearControlHandle(PointerPos, &ClickCorner)) { // The click was over a control point, so start the drag and tell it the opposite corner if (Click==CLICKTYPE_DRAG) HandleBlobDrag(Parallel[ClickCorner], pSpread, (ClickCorner+2)%4 ); // we have used that click up, so tell the world return TRUE; } #endif // did not use the click return FALSE; }

void NodeSimpleShape::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 NodeRenderableBounded. Reimplemented in NodeAnimatingBitmap, and NodeBitmap. Definition at line 273 of file nodeshap.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeSimpleShape), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeSimpleShape)) CopyNodeContents((NodeSimpleShape*)pNodeCopy); }

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

Will render the path contained within the object to the given render region. Author: Jim_Lynn (Xara Group Ltd) <camelotdev@xara.com> Date: 31/5/93 Parameters: Pointer  to a render region [INPUTS] Reimplemented from Node. Reimplemented in NodeBitmap. Definition at line 465 of file nodeshap.cpp. { // render the path pRender->DrawPath(&InkPath); }

void NodeSimpleShape::RenderEorDrag (  RenderRegion *  pRender  )  [virtual]

Renders a version of the path for EORed dragging of shapes. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/93 Parameters: pRender  - A Pointer to the current RenderRegion [INPUTS] See also: NodePath::Render; NodeRenderableInk::RenderEorDrag Reimplemented from NodeRenderableInk. Definition at line 485 of file nodeshap.cpp. { // Render an EORed version of the shape. For a simple object such // as this we can render it as normal pRender->DrawPath(&InkPath); }

void NodeSimpleShape::RenderObjectBlobs (  RenderRegion *  pRender  )  [virtual]

Renders the Object blobs for a Node Shape. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/6/94 Parameters: pRender  - the region to render the blobs to [INPUTS] See also: BlobManager Reimplemented from NodeRenderable. Definition at line 507 of file nodeshap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Set the line colours etc as we need them pRender->SetLineColour(COLOUR_NONE); pRender->SetFillColour(COLOUR_UNSELECTEDBLOB); // Render the blobs on the path pRender->DrawBlob(Parallel[0], BT_UNSELECTED); pRender->DrawBlob(Parallel[1], BT_UNSELECTED); pRender->DrawBlob(Parallel[2], BT_UNSELECTED); pRender->DrawBlob(Parallel[3], BT_UNSELECTED); #endif }

void NodeSimpleShape::RenderTinyBlobs (  RenderRegion *  pRender  )  [virtual]

Renders the Tiny blobs for a Node Shape. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 23/6/94 Parameters: pRender  - the region to render the blobs to [INPUTS] See also: BlobManager Reimplemented from NodeRenderable. Definition at line 536 of file nodeshap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Set the line colours etc as we need them pRender->SetLineColour(COLOUR_NONE); pRender->SetFillColour(COLOUR_UNSELECTEDBLOB); // Find out about the path that the shape is made from DocCoord* Coords = InkPath.GetCoordArray(); // Render the blobs on the path if (InkPath.GetNumCoords()>0) pRender->DrawBlob(Coords[0], BT_UNSELECTED); #endif }

BOOL NodeSimpleShape::SetUpPath (  INT32  RequiredSize = 12, INT32  BlockSize = 12 )

To initialise the path used by the shape into a state that can be used, by allocating memory, setting up member variables properly. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 04/5/93 Parameters: RequiredSize  - The size of the initial block of memory to be allocated to the [INPUTS] path. BlockSize - The size of the block asked for by the path object when it runs out of space. Returns: TRUE if the path was init'ed ok, FALSE otherwise Definition at line 376 of file nodeshap.cpp. { return (InkPath.Initialise(RequiredSize, BlockSize)); }

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

Makes a copy of all the data in the node. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 26/5/93 Returns: Pointer to a Node Reimplemented from NodeRenderableInk. Reimplemented in NodeAnimatingBitmap, NodeBitmap, NodeEllipse, and NodeRect. Definition at line 215 of file nodeshap.cpp. { // Make a new NodeSimpleShape and then copy things into it TRACE( _T("NodeSimpleShape::SimpleCopy() - Should not be called\n")); NodeSimpleShape* NodeCopy = new NodeSimpleShape(); if (NodeCopy) CopyNodeContents(NodeCopy); return NodeCopy; }

BOOL NodeSimpleShape::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: 21/9/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 NodeRenderableBounded. Definition at line 1029 of file nodeshap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) TRACEUSER( "MarkN", _T("NodeSimpleShape::Snap(DocRect)\n") ); #endif return FALSE; }

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

Snaps to given coord to the nearest point on the path. If it is not appropriate to snap the coord to the path (at the moment this means the coord is too far awawy), then FALSE is returned. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 20/9/94 Parameters: pDocCoord  = a coord in Spread coords [INPUTS] [OUTPUTS]  Returns: TRUE - the DocCoord has been snapped to the path. FALSE - the DocCoord has not been processed. Errors: Scope: public Reimplemented from NodeRenderableBounded. Definition at line 980 of file nodeshap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) BOOL Snapped = FALSE; MILLIPOINT SnapDist = CSnap::GetSnapDist(); MILLIPOINT SqrSnapDist = SnapDist*SnapDist; INT32 NearEl; double mu; double SqrDist = InkPath.SqrDistanceToPoint(*pDocCoord,&NearEl,&mu); if (SqrDist <= SqrSnapDist) { *pDocCoord = InkPath.ClosestPointTo(mu,NearEl); Snapped = TRUE; } return (Snapped); #else return FALSE; #endif }

BOOL NodeSimpleShape::SnapToCoords (  DocCoord *  pDocCoord  )  [virtual]

This function tries to magnetically snap the supplied coord to the shape. This version of the function tries to snap to coords at the centre of the shape and in the middle of each of the edges. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: pDocCoord  - The Coord to try and snap [INPUTS] pDocCoord  - The snapped verison of the coord [OUTPUTS] Returns: TRUE if the input coord was snapped, FALSE if not See also: NodeRenderableBounded::SnapToCoords Reimplemented from NodeRenderableBounded. Reimplemented in NodeRect. Definition at line 1055 of file nodeshap.cpp. { #if !defined(EXCLUDE_FROM_RALPH) // Work out the coords to snap to DocCoord TestPoint; // Snap to the Centre of the Shape TestPoint.x = (Parallel[0].x + Parallel[2].x) / 2; TestPoint.y = (Parallel[0].y + Parallel[2].y) / 2; // Test to see if the points are close together, and update pDocCoord if they are if (IsMagneticallyClose(&TestPoint, pDocCoord)) return TRUE; // Try and snap to the middle of each of the edges for (INT32 i=0; i<4; i++) { // Find test coord INT32 NextPoint = (i+1) % 4; TestPoint.x = (Parallel[i].x + Parallel[NextPoint].x) / 2; TestPoint.y = (Parallel[i].y + Parallel[NextPoint].y) / 2; // Test to see if the points are close together, and update pDocCoord if they are if (IsMagneticallyClose(&TestPoint, pDocCoord)) return TRUE; } #endif // Did not snap to anything. return FALSE; }

void NodeSimpleShape::Transform (  TransformBase &  Trans  )  [virtual]

Transforms the shapes parallelogram and then re-builds the shape to fit it. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/93 Parameters: Trans  - The transform Object [INPUTS] See also: NodeRenderableInk::Transform() Reimplemented from NodeRenderableBounded. Definition at line 395 of file nodeshap.cpp. { // Transform the Shape Trans.Transform((DocCoord*)Parallel, 4); // re-create the path and update its bounding rectangle UpdateShape(); // Mark the bounding rect as invalid InvalidateBoundingRect(); // Transform all the children... TransformChildren(Trans); }

void NodeSimpleShape::UpdateShape (   )  [virtual]

Should update the the shape to the current parallelogram. This version does nothing as there should always be a derived class version. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 22/9/93 Parameters: DocRect  - representing the rectangle to be created. [INPUTS] Reimplemented in NodeEllipse, and NodeRect. Definition at line 444 of file nodeshap.cpp. { // You are not supposed to be calling this. You should have called a // derived classes version of this function ENSURE(FALSE, "NodeSimpleShape::UpdateShape - You called the base class version"); }

DocRect NodeSimpleShape::ValidateExtend (  const ExtendParams &  ExtParams  )  [virtual]

Tests to see whether this shape's centre-point is positioned so as to make an extend operation irreversible. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 25/11/1999 Parameters: ExtParams  parameters describing the extension. [INPUTS] [OUTPUTS]  Returns: TRUE if this simple shape can be validly extended, FALSE otherwise. Errors: See also: Reimplemented from Node. Definition at line 1142 of file nodeshap.cpp. { DocCoord doccArray[1] = { FindExtendCentre() }; DocRect drMinExtend = Extender::ValidateControlPoints(1, doccArray, ExtParams); // if we didn't invalidate the extension, we must call the base class // implementation, which will validate our children. if (drMinExtend.lo.x == INT32_MAX && drMinExtend.lo.y == INT32_MAX && drMinExtend.hi.x == INT32_MAX && drMinExtend.hi.y == INT32_MAX) drMinExtend = Node::ValidateExtend(ExtParams); return drMinExtend; }

---

Member Data Documentation

Path NodeSimpleShape::InkPath

Definition at line 211 of file nodeshap.h.

DocCoord NodeSimpleShape::Parallel[4]

Definition at line 212 of file nodeshap.h.

---

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

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

---