NodeClipViewController Class Reference

ClipView controller node. This is the node which does all the hard work with respect to clipview functionality. Initially at least, it is really a more-or-less normal group, with special rendering qualities. The bottom-most (in a z-order sense) NodeRenderableInk in the group is rendered, then its path is used to create a clipping region, into which all other members of the group are rendered. More...

#include <ndclpcnt.h>

Inheritance diagram for NodeClipViewController:

List of all members.

Public Member Functions
	NodeClipViewController ()
	Default constructor.
	NodeClipViewController (Node *pContextNode, AttachNodeDirection Direction, BOOL Locked=FALSE, BOOL Mangled=FALSE, BOOL Marked=FALSE, BOOL Selected=FALSE)
	This method initialises the node and links it to pContextNode in the direction specified by Direction. All necessary tree links are updated. Most of the work is carried out by base constructors.
	~NodeClipViewController ()
	Destructor.
virtual void	GetDebugDetails (StringBase *pStr)
	Get Debug-tree details for this node. In the case of NCVC, we output our current clipping-path data. Notes: Only _implemented_ in DEBUG builds.
virtual BOOL	IsANodeClipViewController () const
virtual DocRect	GetBoundingRect (BOOL DontUseAttrs=FALSE, BOOL HitTest=FALSE)
	Find this node's bounding rectangle. If the rectangle is known to be valid then it is simply returned. If IsBoundingRectValid() is FALSE then the rect is recalculated before it is returned and the validity flag reset.
virtual DocRect	GetBlobBoundingRect ()
	Get this NCVC's bounding rectangle when its blobs are drawn. See also: GetBoundingRect();.
virtual DocRect	GetEorDragBoundingRect ()
	The rectangle calculated is the union of EorDragBoundingRect()'s for each of our keyhole nodes.
virtual SubtreeRenderState	RenderSubtree (RenderRegion *pRender, Node **ppNextNode=NULL, BOOL bClip=TRUE)
	Called by the main rendering loop before this node's children are rendered, usually to allow us to muck around with how we want our children to render.
virtual void	RenderEorDrag (RenderRegion *pRender)
	Render this node as eor-blobs into the given render region.
virtual void	RenderEorDragSelectedChildren (Node *pParent, RenderRegion *pRender)
virtual BOOL	ChildrenAreEorDragRenderedByMe ()
	Tells everyone else that I want to be responsible for rendering the drag blobs for my children.
virtual void	RenderTinyBlobs (RenderRegion *pRender)
	Render our tiny-blob. This consists of a solitary blob at the top-left of our bounding rect.
virtual void	RenderToolObjectBlobs (RenderRegion *pRender)
	Render our tool-object blobs.
virtual void	PreExportRender (RenderRegion *pRender)
	Starts exporting a clipview group - basically writes a 'q' token out.
virtual BOOL	ExportRender (RenderRegion *pRender)
	Finishes exporting a clipview group - basically write a 'Q' token out.
virtual BOOL	OnClick (DocCoord dcClickPos, ClickType cType, ClickModifiers cMods, Spread *pSpread)
	Handle any click-messages passed to us from a tool, eg if we want to handle clicks on our object or tool-object blobs. Currently, you can click on an NCVC tool-object blob and either select its keyhole node, or select everything *except* its keyhole node. At some point in future, you will also be able to directly drag everything except the keyhole node (instead of clicking once to select, _then_ dragging).
virtual BOOL	CanBecomeA (BecomeA *pBecomeA)
	This method is used by the convert to shapes operation. It determines whether this node or any of its children can convert themselves into a pClass Node.
virtual BOOL	DoBecomeA (BecomeA *pBecomeA)
	Turn this node into another node of a particular type. This method implements make-shapes functionality, which basically means turning itself and its children into paths. Don't hold your breath if you ask it to turn into anything else...
virtual NodeGroup *	BecomeAGroup (UndoableOperation *pUndoOp)
	We are sometimes required to turn ourself into a normal group node, and that is exactly what this method does. If an UndoOp is supplied then it is done in an undoable fashion but it must also work non-undoably if a NULL op pointer is passed in.
virtual BOOL	GroupCanTransformCached (TransformBase &Trans) const
virtual BOOL	AllowOp (ObjChangeParam *pParam, BOOL SetOpPermissionState=TRUE, BOOL DoPreTriggerEdit=TRUE)
	This is the way to ask a node if you can do an op to it.
virtual ChangeCode	OnChildChange (ObjChangeParam *pParam)
	Used to notify this node of changes to its children, so that if required it can update itself. This forms part of the AllowOp / UpdateChangedNodes mechanism.
virtual String	Describe (BOOL Plural, BOOL Verbose)
	Get a string description, for use in menus and infobar etc.
virtual UINT32	GetNodeSize () const
	Obtain the size of a NodeClipViewController object.
void	Transform (TransformBase &Trans)
	Perform a transformation on this node.
virtual BOOL	WritePreChildrenWeb (BaseCamelotFilter *pFilter)
	Writes this node out to a camelot document.
virtual BOOL	WritePreChildrenNative (BaseCamelotFilter *pFilter)
	Writes this node out to a camelot document.
virtual BOOL	PostImport ()
	Performs any necessary post-processing once the object has been read in from a file.
virtual BOOL	IsController ()
NodeClipView *	GetClipView (BOOL ReportErrors=TRUE)
	Get this controller's clipview node.
Path *	GetKeyholePath ()
BOOL	OwnsAsKeyholeNode (const Node *pTestNode)
	Test whether the given node is a keyhole node for this NCVC.
virtual void	PolyCopyNodeContents (NodeRenderable *pNodeCopy)
	Polymorphically copies the contents of this node to another.
Static Public Member Functions
static INT32	EstimatePathFlatness ()
	Return an estimation of how flat paths need to be for ClipView groups, based on the current document's zoom factor. A default value will be returned if there is no current document.
Static Public Attributes
static const INT32	CLIPVIEW_TOLERANCE
static const INT32	CLIPVIEW_SOURCEFLATNESS
static const INT32	CLIPVIEW_CLIPFLATNESS = 50
Protected Member Functions
virtual void	RenderClipViewBlobs (RenderRegion *pRegion)
	Render the blobs specifically used by ClipView groups. These are currently as follows: 1. A keyhole-selection blob, which is rendered at the top-left of our bounding rectangle. 2. A select-contained-objects blob, which is rendered in the centre of the group's bounding rectangle.
virtual BOOL	HandleKeyholeBlobClick (ClickType cType)
	Handler for what happens when the user clicks on our keyhole-select blob.
virtual BOOL	HandleContentsBlobClick (ClickType cType)
	Handler for what happens when the user clicks on our contents-select blob.
virtual Node *	SimpleCopy ()
	Copy this node.
void	CopyNodeContents (NodeClipViewController *pNodeCopy)
	Copy this node's contents into pNodeCopy.
Private Member Functions
	CC_DECLARE_DYNCREATE (NodeClipViewController)
BOOL	KeyholeDoBecomeA (BecomeA *pBecomeA)
BOOL	MakeShapeAndLine (NodePath *pNodePath, BecomeA *pBecomeA, BOOL bClipToKeyhole)
BOOL	InsertClippedNode (NodePath *pNewNode, NodePath *pDestNode, AttachNodeDirection Direction, UndoableOperation *pUndoOp, BOOL bClipToKeyhole)
BOOL	PassBackClippedNode (NodePath *pNewNode, BecomeA *pBecomeA, BOOL bClipToKeyhole)
BOOL	InkHasClearLineColour (NodeRenderableInk *pInkNode)
	Test whether the line colour of the given NodeRenderableInk is transparent.
BOOL	RemoveInkLineWidth (NodeRenderableInk *pInk)
	Make the outline of the given node transparent and set its line width to 0.
BOOL	CopyInkFillColourFromLine (NodeRenderableInk *pInk)
	Obtain the line colour of the given NodeRenderableInk and re-apply it as its new fill colour.
BOOL	CopyInkTransparencyFromLine (NodeRenderableInk *pInk)
	Obtain the line transparency of the given NodeRenderableInk and re-apply it as a new flat transparency.
BOOL	UpdateKeyholePath ()
	Update our cached outline for our keyhole node. Note that this method only tries to update the keyhole path if it is marked as invalid. If it is already valid, you just get TRUE back. It will also only re-mark the keyhole as valid if it successfully updates the keyhole cache.
BOOL	IsKeyholeValid () const
void	MarkKeyholeValid ()
void	MarkKeyholeInvalid ()
Private Attributes
Path	m_KeyholePath
BOOL	m_fKeyholeValid
DocRect	m_drKeyholeBlobRect
DocRect	m_drContentsBlobRect
Friends
class	NodeClipView
class	UpdateCachedKeyholePathAction
void	OpApplyClipView::Do (OpDescriptor *pOpDesc)

---

Detailed Description

ClipView controller node. This is the node which does all the hard work with respect to clipview functionality. Initially at least, it is really a more-or-less normal group, with special rendering qualities. The bottom-most (in a z-order sense) NodeRenderableInk in the group is rendered, then its path is used to create a clipping region, into which all other members of the group are rendered.

Author:

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

Date:

27/01/2000

Notes: This is how you create a ClipView group in the tree:

1. Set up the tree structure (ignoring attributes):

NCVC | |--{ Keyhole }--{ NCV }--{ Clipped Node N1 }--{ N2 }-- - etc.

2. Call the NCVC's UpdateKeyholePath() method. This method should really be public, but is not, to emphasize that you shouldn't just call it from anywhere, as it also marks the cached keyhole path as valid. To invalidate the cache (you shouldn't usually need to), you must call MarkKeyholeValid(), or if you need update on undo/redo, invoke an UpdateCachedKeyholePathAction.

3. Call the NCVC's InvalidateBoundingRect() method. See also:

Definition at line 146 of file ndclpcnt.h.

---

Constructor & Destructor Documentation

NodeClipViewController::NodeClipViewController (   )

Default constructor. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 28 January 2000 Returns: Errors: See also: Definition at line 170 of file ndclpcnt.cpp. : NodeGroup() { // state initialisation. m_KeyholePath.Initialise(); MarkKeyholeInvalid(); }

NodeClipViewController::NodeClipViewController (  Node *  pContextNode, AttachNodeDirection  Direction, BOOL  Locked = FALSE, BOOL  Mangled = FALSE, BOOL  Marked = FALSE, BOOL  Selected = FALSE )

This method initialises the node and links it to pContextNode in the direction specified by Direction. All necessary tree links are updated. Most of the work is carried out by base constructors. PREV Attach node as a previous sibling of the context node. NEXT Attach node as a next sibling of the context node. FIRSTCHILD Attach node as the first child of the context node. LASTCHILD Attach node as a last child of the context node. Locked is node locked? Mangled is node mangled? Marked is node marked? Selected is node selected? Returns: Errors: An ENSURE error will occur if pContextNode is NULL. See also: Definition at line 211 of file ndclpcnt.cpp. : NodeGroup(pContextNode, Direction, Locked, Mangled, Marked, Selected) { // state initialisation. m_KeyholePath.Initialise(); MarkKeyholeInvalid(); }

NodeClipViewController::~NodeClipViewController (   )

Destructor. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 28 January 2000 Returns: Errors: See also: Definition at line 238 of file ndclpcnt.cpp. { m_KeyholePath.ClearPath(); }

---

Member Function Documentation

BOOL NodeClipViewController::AllowOp (  ObjChangeParam *  pParam, BOOL  SetOpPermissionState = TRUE, BOOL  DoPreTriggerEdit = TRUE )  [virtual]

This is the way to ask a node if you can do an op to it. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> 19/01/2000 Date: 3/02/95 Parameters: pParam  = describes the way an op wants to change the node [INPUTS] SetOpPermissionState = if TRUE the Op permission state of this node will be set according to the outcome of the call DoPreTriggerEdit = if TRUE then calls NameGallery::PreTriggerEdit. Must* be TRUE if the calling Op may make any nodes change their bounds, eg move, line width, cut. Use TRUE if unsure. -  [OUTPUTS] Returns: TRUE means the node and all its parents are happy with this op, FALSE means don't do it The ObjChangeParam class contains flags that describe how it will change the node For example, the op could change the node's appearence (e.g. attr application, editing a path), replace the node with another node (e.g. because it uses hidden nodes to hide the original and put another node in its place, or "make shapes"), delete the node (e.g. the delete and cut ops), etc. This function gives the node a chance to say NO. It also gives the parents a chance to say no too. E.g. a blend node will allow itself to be deleted, but it will NOT allow a child of itself to be deleted). This call should only be made on selected, or parents of selected, nodes. It makes a decision as a straight node if it is selected. It makes a decision as a parent if it has selected children. E.g. NodeBlend::AllowOp(...op delete...) if the node is selected, then it will return TRUE (parents permitting), i.e. I can be deleted if the node is a parent of selected it will return FALSE (i.e. can't delete children of blends). So when the node is selected, you are asking the node if you can do the op to it. When the node is a parent of a selected node, you are asking if you can do the op to one of its children. If the 'SetOpPermissionState' param is TRUE, the following indented lines applies: The node's op permission state is set according to the result of this function. If TRUE is returned, then the node's op permission state will be left unchanged. AND the parent's op permission state will be set to PERMISSION_ALLOWED if FALSE is returned, then the node's op permission state will be PERMISSION_DENIED, AND all it's parents (up to the layer) will be set to PERMISSION_DENIED Also, all parents of this node are called via their AllowOp() func with the same state as this node. This means that after this call, you can guarantee that all of its parents will have either a PERMISSION_DENIED or PERMISSION_ALLOWED state. Note: Even if this node tries to set all it's parents to have a PERMISSION_DENIED state, if any of its parents have previously been set to PERMISSION_ALLOWED they will remain in that state (see SetOpPermission()). Why? Well, it is possible for a parent node to have one child with a PERMISSION_DENIED and another child with a PERMISSION_ALLOWED. It this state the parent MUST be in state PERMISSION_ALLOWED, because at least one of its children will allow the op to happen to it. So, after this call: The op permission state for this node will be either left unchanged (and therefore remain PERMISSION_UNDEFINED), or PERMISSION_DENIED. The parent's op permission state will be either PERMISSION_ALLOWED, or PERMISSION_DENIED. This is so UndoableOperation::UpdateChangedNodes() will only call OnChildChange() on parent nodes, because it only calls that func for nodes that have an op permission state of PERMISSION_ALLOWED. See also: GetOpPermission(),SetOpPermission(); Reimplemented from Node. Definition at line 2073 of file ndclpcnt.cpp. { // input validation. ERROR2IF(pParam == NULL, FALSE, "NULL pParam"); // call our base class' AllowOp(). BOOL allowed = NodeGroup::AllowOp(pParam, SetOpPermissionState, DoPreTriggerEdit); // Slight misuse of the AllowOp/OnChildChange system, as that says that only our // children are meant to set our permission to PERMISSION_ALLOWED. // This will ensure that our OnChildChange() method is called after the op has finished, // allowing us to update our keyhole path after any changes. if (allowed && SetOpPermissionState) SetOpPermission(PERMISSION_ALLOWED, TRUE); return allowed; }

NodeGroup * NodeClipViewController::BecomeAGroup (  UndoableOperation *  pUndoOp  )  [virtual]

We are sometimes required to turn ourself into a normal group node, and that is exactly what this method does. If an UndoOp is supplied then it is done in an undoable fashion but it must also work non-undoably if a NULL op pointer is passed in. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 07 March 2000 Parameters: pUndoOp  pointer to an UndoableOperation [INPUTS] [OUTPUTS]  Returns: TRUE if successful, FALSE otherwise. Reimplemented from NodeCompound. Definition at line 1891 of file ndclpcnt.cpp. { // ok! BOOL ok = TRUE; NodeGroup* pGroup = NULL; NodeClipView* pClipView = GetClipView(FALSE); // hide our clipview node if it exists. if (ok) ok = (pClipView != NULL); if (ok) { if (pUndoOp) ok = pUndoOp->DoHideNode(pClipView, TRUE); else { pClipView->CascadeDelete(); delete pClipView; // Scary! } } // call our base class to turn into a group. if (ok) pGroup = NodeGroup::BecomeAGroup(pUndoOp); return pGroup; }

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

This method is used by the convert to shapes operation. It determines whether this node or any of its children can convert themselves into a pClass Node. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 28 January 2000 Parameters: pClass  pointer to the runtime class of the node type to convert to. [INPUTS] pNumObjects pointer in which to return the number of objects of type pClass which would be created under a DoBecomeA(). Can be NULL, in which case we only return success or failure. Returns: TRUE if we can change ourself or our children into a pClass type of node, FALSE otherwise. The number returned in pNumObjects (if it's not NULL) should exactly equal the total number of pClass objects which would be created by the appropriate call to DoBecomeA on this node. It should NOT contain any additional objects produced, such as group objects or attributes created by the conversion. Unfortunately, in the case of NodeClipViewController this is impossible without changing the CanBecomeA mechanism or the rules by which NCVC converts its children to shapes. The function for number of shapes is recursive: SetOfKidPaths = {all paths which our children return under DoBecomeA} NumObjects = SetOfKidPaths + #(members of SetOfKidPaths with non-zero line width) , which would require CanBecomeA to return numbers of objects returned with and without zero-width outlines. We _can_ set upper and lower bounds on the number of objects we'll return - either all of our children will have line widths, or none of them will, so NodeGroup::CanBecomeA will return a lower bound and twice that number will give an upper bound. We choose to return the upper bound, for ease of use with DMc's code. Returns: Errors: See also: Reimplemented from NodeCompound. Definition at line 993 of file ndclpcnt.cpp. { // to convert to paths we'll need to convert each of our children. // we cannot return an accurate number of created objects unless we DoBecomeA on our // children. we _can_ however return a minimum or maximum number of objects. // David Mc's contour/bevel code does not like being passed a minimum, so we'll // give him a maximum instead. // minimum = number of paths our children will return. // maximum = twice the number of paths our children will return. UINT32 GroupNumObjects = pBecomeA->GetCount(); BOOL bCanDo = NodeGroup::CanBecomeA(pBecomeA); pBecomeA->AddCount(pBecomeA->GetCount()-GroupNumObjects); // Add the same count again to double it return bCanDo; }

NodeClipViewController::CC_DECLARE_DYNCREATE (  NodeClipViewController   )  [private]

BOOL NodeClipViewController::ChildrenAreEorDragRenderedByMe (   )  [virtual]

Tells everyone else that I want to be responsible for rendering the drag blobs for my children. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 04 April 2000 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE. Errors: See also: Reimplemented from NodeRenderableInk. Definition at line 646 of file ndclpcnt.cpp. { return TRUE; }

BOOL NodeClipViewController::CopyInkFillColourFromLine (  NodeRenderableInk *  pInk  )  [private]

Obtain the line colour of the given NodeRenderableInk and re-apply it as its new fill colour. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 09 March 2000 Parameters: pInk  pointer to the NodeRenderableInk to work on. [INPUTS] pInk's  fill colour should match its line colour. [OUTPUTS] Returns: TRUE if successful, FALSE otherwise. NOTE: This method is *not* undoable! Returns: Errors: ERROR2 returning FALSE if pInk is NULL. See also: Definition at line 1707 of file ndclpcnt.cpp. { ERROR2IF(pInk == NULL, FALSE, "NULL parameter(s)"); NodeAttribute *pLineColourAttr = NULL; DocColour* pLineColour = NULL; // DocColour* pFillColour = NULL; Node* pOldFill = NULL; AttrFlatColourFill* pNewFlatFill = NULL; // obtain the line-colour attribute and its actual colour value. pInk->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), &pLineColourAttr); // DY: bodge to solve problem of creating brushes from clipview objects. The problem was // that we are using an inknode that is not located in a document so it sometimes does // not have an applied stroke colour, so just return true BOOL ok = (pLineColourAttr != NULL); if (ok) { pLineColour = ((AttrStrokeColour*)pLineColourAttr)->GetStartColour(); ok = (pLineColour != NULL); } else return TRUE; // safe return // search the children of the object node for its current colour fill attribute. if (ok) { BOOL bFoundFill = FALSE; pOldFill = pInk->FindFirstChild(); while (!bFoundFill && pOldFill != NULL) { if ( pOldFill->IsAFillAttr() && ((NodeAttribute*)pOldFill)->IsAColourFill() ) bFoundFill = TRUE; else pOldFill = pOldFill->FindNext(); } } // create a new fill attribute. if (ok) { pNewFlatFill = new AttrFlatColourFill(); ok = (pNewFlatFill != NULL); } // if we were successful, then put it all into the tree and remove any // previous fill applied. if (ok) { pNewFlatFill->SetStartColour(pLineColour); pNewFlatFill->AttachNode(pInk, LASTCHILD); if (pOldFill != NULL) { pOldFill->UnlinkNodeFromTree(); delete pOldFill; } } // ensure we free allocated memory if unsuccessful. else { if (pNewFlatFill != NULL) { delete pNewFlatFill; pNewFlatFill = NULL; } } return ok; }

BOOL NodeClipViewController::CopyInkTransparencyFromLine (  NodeRenderableInk *  pInk  )  [private]

Obtain the line transparency of the given NodeRenderableInk and re-apply it as a new flat transparency. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 20 March 2000 Parameters: pInk  pointer to the NodeRenderableInk to work on. [INPUTS] pInk  should be given the same transparency as its outline. [OUTPUTS] Returns: TRUE if successful, FALSE otherwise. NOTE: This method is *not* undoable! Returns: Errors: ERROR2 returning FALSE if pInk is NULL. See also: Definition at line 1800 of file ndclpcnt.cpp. { ERROR2IF(pInk == NULL, FALSE, "NULL parameter(s)"); NodeAttribute *pLineTranspAttr = NULL; UINT32* pLineTransp = NULL; // UINT32* pFillTransp = NULL; Node* pOldFill = NULL; AttrFlatTranspFill* pNewFlatFill = NULL; // obtain the line-transparency attribute and its actual transparency value. pInk->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeTransp), &pLineTranspAttr); // DY: bodge to solve problem of creating brushes from clipview objects. The problem was // that we are using an inknode that is not located in a document so it sometimes does // not have an applied stroke transparency, so just return true BOOL ok = (pLineTranspAttr != NULL); if (ok) { pLineTransp = ((AttrStrokeTransp*)pLineTranspAttr)->GetStartTransp(); ok = (pLineTransp != NULL); } else return TRUE; // search the children of the object node for its current transparency fill attribute. if (ok) { BOOL bFoundFill = FALSE; pOldFill = pInk->FindFirstChild(); while (!bFoundFill && pOldFill != NULL) { if ( pOldFill->IsAFillAttr() && ((NodeAttribute*)pOldFill)->IsATranspFill() ) bFoundFill = TRUE; else pOldFill = pOldFill->FindNext(); } } // create a new transparency fill attribute. if (ok) { pNewFlatFill = new AttrFlatTranspFill(); ok = (pNewFlatFill != NULL); } // if we were successful, then put it all into the tree and remove any // previous fill applied. if (ok) { pNewFlatFill->SetStartTransp(pLineTransp); pNewFlatFill->AttachNode(pInk, LASTCHILD); if (pOldFill != NULL) { pOldFill->UnlinkNodeFromTree(); delete pOldFill; } } // ensure we free allocated memory if unsuccessful. else { if (pNewFlatFill != NULL) { delete pNewFlatFill; pNewFlatFill = NULL; } } return ok; }

void NodeClipViewController::CopyNodeContents (  NodeClipViewController *  pNodeCopy  )  [protected]

Copy this node's contents into pNodeCopy. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 09 February 2000 Parameters: pNodeCopy  the node to copy our contents into. [INPUTS] Returns: Errors: See also: Node::CopyNodeContents() Definition at line 2497 of file ndclpcnt.cpp. { // call base-class implementation; this will also perform necessary validation for us. NodeGroup::CopyNodeContents(pNodeCopy); }

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

Get a string description, for use in menus and infobar etc. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 28 January 2000 Parameters: Plural  whether to pluralise the description. [INPUTS] Verbose short or long version. Returns: A string description of this node. Errors: See also: Reimplemented from NodeGroup. Definition at line 2319 of file ndclpcnt.cpp. { if (Plural) return(String(_R(IDS_CLIPVIEW_CONTROLLER_DESCRP))); else return(String(_R(IDS_CLIPVIEW_CONTROLLER_DESCRS))); }

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

Turn this node into another node of a particular type. This method implements make-shapes functionality, which basically means turning itself and its children into paths. Don't hold your breath if you ask it to turn into anything else... Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 28 January 2000 Parameters: pBecomeA  pointer to a BecomeA structure containing information about the [INPUTS] required transformation. This  node and its children may be hidden and replaced with other node types [OUTPUTS] representing a similar scene, eg a group of paths. Returns: TRUE if successful, FALSE otherwise. Defined behaviour for ClipView DoBecomeA is that the keyhole nodes will have the DoBecomeA call passed directly on to them. Any nodes which are clipped behave differently. If these nodes have an outline, then it is first split off from them, into a separate, new shape. Both outline shape and original shape are then clipped to the keyhole path and left in the tree or passed back. These nodes will also all have their line width set to zero and their line colour set to transparent. Notes: If this node cannot locate a full set of attributes (eg it is hidden), you may get strange results from this method. Karim 14/06/2000 Just added Silhouette functionality to BecomeA. This means that for PASSBACK, the BecomeA object can flag that a silhouette is all that's required, which should hopefully lead to better contouring/bevelling with ClipView. If we're silhouetting, then we pass the BecomeA on to our our keyhole nodes. Returns: Errors: ERROR2 if pBecomeA is NULL. See also: Reimplemented from NodeCompound. Definition at line 1052 of file ndclpcnt.cpp. { // validate input parameter. ERROR2IF(pBecomeA == NULL, FALSE, "NULL pBecomeA"); // quit unless we're converting to paths. ERROR2IF(!pBecomeA->BAPath(), FALSE, "Attempt to convert to other than a path"); // ensure our keyhole path is up to date. if (!UpdateKeyholePath()) return FALSE; // ok, we do different things depending on what type of BecomeA we are. switch (pBecomeA->GetReason()) { case BECOMEA_REPLACE: // DEBUG // TRACEUSER( "Karim", _T("NCVC::DoBecomeA; BECOMEA_REPLACE\n")); { // if we're doing a BECOMEA_REPLACE, we need an op. UndoableOperation* pUndoOp = pBecomeA->GetUndoOp(); // ERROR2IF(pUndoOp == NULL, FALSE, "Need an UndoOp with BECOMEA_REPLACE"); // local variables. Node* pKid = NULL; Node* pNextKid = NULL; // Node* pAfterKey = NULL; // NodeHidden* pHiddenKey = NULL; Node* pClipView = GetClipView(); BOOL ok = (pClipView != NULL); // localise attributes. if (ok) { if (pUndoOp) ok = pUndoOp->DoLocaliseCommonAttributes(this); else LocaliseCommonAttributes(); } // first, DoBecomeA on our children. if (ok) { // if we only have to get a silhouette, then DoBecomeA on our keyhole nodes, // and hide the rest of the children. if (pBecomeA->DoSilhouette()) { pKid = FindFirstChild(); while (ok && pKid != pClipView) { if (pKid->IsAnObject()) ok = pKid->DoBecomeA(pBecomeA); pKid = pKid->FindNext(); } pKid = pClipView->FindNext(); while (ok && pKid != NULL) { pNextKid = pKid->FindNext(); if (pUndoOp) ok = pUndoOp->DoHideNode(pKid, TRUE); else { pKid->CascadeDelete(); delete pKid; } pKid = pNextKid; } } // otherwise, DoBecomeA on all of our children. else { pKid = FindFirstChild(); while (ok && pKid != NULL) { pNextKid = pKid->FindNext(); ok = pKid->DoBecomeA(pBecomeA); pKid = pNextKid; } } } // now separate the outline and fill of each of our non-keyhole children out into // new ink-nodes, clipped to our keyhole path. non-keyhole means all nodes to the // right of our NodeClipView, and we do this depth-first, so we don't miss paths // hidden underneath group hierarchies. // unfortunately, paths can sometimes be completely clipped out of the tree. if // this happens then we could end up with empty groups (not ideal behaviour), so // we need to check for these and if we find any then we hide them. if (ok && !pBecomeA->DoSilhouette()) { BOOL bFinishedAGroup = FALSE; pKid = pClipView->FindNextDepthFirst(this); while (ok && pKid != NULL && pKid != this) { pNextKid = pKid->FindNextDepthFirst(this); // if we're about to do the last kid in a group, remember this for later. if (IS_A(pNextKid, NodeGroup)/*->IsAGroup()*/ && pNextKid == pKid->FindParent()) bFinishedAGroup = TRUE; else bFinishedAGroup = FALSE; // if this one's a NodePath, process it. if (pKid->IsNodePath()) ok = MakeShapeAndLine((NodePath*)pKid, pBecomeA, TRUE); // if we've just finished a group, we need to check whether we left it // containing any ink-children - if not, we need to hide it. if (ok && bFinishedAGroup) { BOOL bFoundInkKids = FALSE; Node* pInkKid = pNextKid->FindFirstChild(); while (!bFoundInkKids && pInkKid != NULL) { bFoundInkKids = pInkKid->IsAnObject(); pInkKid = pInkKid->FindNext(); } if (!bFoundInkKids) { // move to the next depth-first node and hide the group. pKid = pNextKid; pNextKid = pKid->FindNextDepthFirst(this); if (pUndoOp) ok = pUndoOp->DoHideNode(pKid, TRUE); else { pKid->CascadeDelete(); delete pKid; } } } pKid = pNextKid; } } // make sure that all remaining common attributes are factored back out. if (ok) { if (pUndoOp) ok = pUndoOp->DoFactorOutCommonChildAttributes(this); else FactorOutCommonChildAttributes(); } // mighty-morph into a group (ClipView nodes hidden and replaced by a group node). if (ok) ok = (BecomeAGroup(pUndoOp) != NULL); // return the result of our deliberations. return ok; } break; case BECOMEA_PASSBACK: // DEBUG // TRACEUSER( "Karim", _T("NCVC::DoBecomeA; BECOMEA_PASSBACK\n")); { // local variables. Node * pKid = NULL; NodeGroup * pContainer = NULL; // NodeHidden * pHiddenKey = NULL; NodeClipView * pClipView = GetClipView(); BOOL ok = (pClipView != NULL); // passback all our keyhole nodes directly. if (ok) { pKid = FindFirstChild(); while (ok && pKid != pClipView) { if (pKid->IsAnObject()) ok = pKid->DoBecomeA(pBecomeA); pKid = pKid->FindNext(); } } // quit now if all that is required is our silhouette, // as that is fully defined by our keyhole nodes. if (pBecomeA->DoSilhouette()) return ok; // make shape copies of all our non-keyhole kids (which are right-siblings // of our clipview node) and put the result into a container node. if (ok) { pContainer = new NodeGroup(); ok = (pContainer != NULL); } if (ok) { CopyBecomeA refCopyBecomeA(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL); refCopyBecomeA.SetContextNode(pContainer); pKid = pClipView->FindNext(); while (ok && pKid != NULL) { if (pKid->CanBecomeA(&refCopyBecomeA)) ok = pKid->DoBecomeA(&refCopyBecomeA); pKid = pKid->FindNext(); } } // convert the outlines of these shapes into independent shapes, // clip the output to our keyhole path and pass it all back. if (ok) { pKid = pContainer->FindFirstDepthFirst(); while (ok && pKid != NULL) { if (pKid->IsNodePath()) ok = MakeShapeAndLine((NodePath*)pKid, pBecomeA, TRUE); pKid = pKid->FindNextDepthFirst(pContainer); } } // dispose of our child-shapes when we've finished with them. if (pContainer != NULL) { pContainer->CascadeDelete(); delete pContainer; pContainer = NULL; } return ok; } break; default: ERROR2(FALSE, "Unrecognised reason in convert-to-shapes"); break; } return FALSE; }

INT32 NodeClipViewController::EstimatePathFlatness (   )  [static]

Return an estimation of how flat paths need to be for ClipView groups, based on the current document's zoom factor. A default value will be returned if there is no current document. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 09 March 2000 Returns: Flatness required for paths used by ClipView. According to DMc, flatness is the max straight line length when a curve is approximated - smaller is smoother. We should aim for a flatness of ~0.1 pixels. Returns: Errors: See also: Definition at line 2039 of file ndclpcnt.cpp. { // we use a default flatness of 75 millipoints, as this is 0.1 pixels at 100% zoom. // (100% zoom = 96 dpi @ 72000 mp per inch ==> 750 mp per dot) static const double DefaultFlatness = 75.0; DocView* pView = DocView::GetCurrent(); double ZoomFactor = (pView == NULL) ? 1 : pView->GetZoomFactor(); INT32 Flatness = (INT32)(ZoomFactor * DefaultFlatness); return (Flatness == 0) ? 1 : Flatness; }

BOOL NodeClipViewController::ExportRender (  RenderRegion *  pRegion  )  [virtual]

Finishes exporting a clipview group - basically write a 'Q' token out. Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 8th November 2000 Parameters: pRegion  - the RenderRegion we're exporting to. [INPUTS] Returns: Errors: See also: Node::ExportRender() Reimplemented from NodeGroup. Definition at line 2576 of file ndclpcnt.cpp. { #ifdef DO_EXPORT if (pRegion->IsKindOf(CC_RUNTIME_CLASS(EPSRenderRegion))) { // Output "end group" token EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); pDC->OutputToken(_T("Q")); pDC->OutputNewLine(); // Tell caller we rendered ourselves ok return TRUE; } PORTNOTE("epsfilter", "Removed use of CMXRenderRegion") #ifndef EXCLUDE_FROM_XARALX else if(pRegion->IsKindOf(CC_RUNTIME_CLASS(CMXRenderRegion))) { // mark start of a group... CMXExportDC *pDC = (CMXExportDC *) pRegion->GetRenderDC(); pDC->EndGroup(); return TRUE; } #endif #endif // Render this node in the normal way return FALSE; }

DocRect NodeClipViewController::GetBlobBoundingRect (   )  [virtual]

Get this NCVC's bounding rectangle when its blobs are drawn. See also: GetBoundingRect();. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 28 January 2000 Returns: The bounding rectangle of this node with its blobs drawn. Reimplemented from NodeGroup. Definition at line 409 of file ndclpcnt.cpp. { // we return our bounding rectangle, inflated to account for whichever blobs we're // currently showing. DocRect drBounds = GetBoundingRect(); BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); if (pBlobMgr != NULL) { DocCoord Low = drBounds.LowCorner(); DocCoord High = drBounds.HighCorner(); BlobStyle bsBlobs = pBlobMgr->GetCurrentInterest(TRUE); if (bsBlobs.Object) { DocRect drBlobSize; pBlobMgr->GetBlobRect(Low, &drBlobSize); drBounds = drBounds.Union(drBlobSize); pBlobMgr->GetBlobRect(High, &drBlobSize); drBounds = drBounds.Union(drBlobSize); pBlobMgr->GetBlobRect(DocCoord(Low.x, High.y), &drBlobSize); drBounds = drBounds.Union(drBlobSize); pBlobMgr->GetBlobRect(DocCoord(High.x, Low.y), &drBlobSize); drBounds = drBounds.Union(drBlobSize); } if (bsBlobs.Tiny) { DocRect drBlobSize; pBlobMgr->GetBlobRect(DocCoord(Low.x, High.y), &drBlobSize); drBounds = drBounds.Union(drBlobSize); } if (bsBlobs.ToolObject) { DocRect drBlobSize; pBlobMgr->GetBlobRect(DocCoord(0, 0), &drBlobSize); drBounds.Inflate(drBlobSize.Width(), drBlobSize.Height()); } } // this well-named method includes the blob-bounds of any child-attrs, // but only if we're showing fill blobs (!!?!?). IncludeChildrensBoundingRects(&drBounds); return drBounds; }

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

Find this node's bounding rectangle. If the rectangle is known to be valid then it is simply returned. If IsBoundingRectValid() is FALSE then the rect is recalculated before it is returned and the validity flag reset. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 28 January 2000 Parameters: DontUseAttrs  TRUE of you want to ignore all the node's attributes. [INPUTS] HitTest TRUE if being called during a hit-test. Returns: The bounding rectangle of this node. The bounding rect of a NCVC is the union of the bounds of all its keyhole nodes. See also: GetBlobBoundingRect(). Reimplemented from NodeGroup. Definition at line 367 of file ndclpcnt.cpp. { // DEBUG: // TRACEUSER( "Karim", _T("NCVC::GetBoundingRect\n")); // ensure our cached keyhole path is up to date. // UpdateKeyholePath(); // start off with a zeroed bounding rect, and union it with the bounds of all keyhole // nodes, ie ink-nodes to the left of our NodeClipView. BoundingRectangle = DocRect(0, 0, 0, 0); NodeClipView* pClipView = GetClipView(); if (pClipView != NULL) { Node* pKeyhole = pClipView->FindPrevious(); while (pKeyhole != NULL) { if (pKeyhole->IsAnObject()) { IsBoundingRectValid = TRUE; BoundingRectangle = BoundingRectangle.Union(((NodeRenderableInk*)pKeyhole)->GetBoundingRect(DontUseAttrs, HitTest)); } pKeyhole = pKeyhole->FindPrevious(); } } return BoundingRectangle; }

NodeClipView * NodeClipViewController::GetClipView (  BOOL  ReportErrors = TRUE  )

Get this controller's clipview node. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 18 February 2000 Parameters: ReportErrors  if set to FALSE then this method will not ERROR3 if it [INPUTS] cannot find the clipview node. Returns: The ClipView node which is associated with this NodeClipViewController, or NULL if unsuccessful. Errors: ERROR3 if no relevant NodeClipView is found. See also: Definition at line 288 of file ndclpcnt.cpp. { Node* pClipView = FindFirstChild(); while (pClipView != NULL && !pClipView->IsANodeClipView()) pClipView = pClipView->FindNext(); ERROR3IF(ReportErrors && pClipView == NULL, "NCVC has no ClipView node!"); return (NodeClipView*)pClipView; }

void NodeClipViewController::GetDebugDetails (  StringBase *  pStr  )  [virtual]

Get Debug-tree details for this node. In the case of NCVC, we output our current clipping-path data. Notes: Only _implemented_ in DEBUG builds. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 5/25/00 Parameters: pStr  ptr to the string to hold the debug output. [INPUTS] pStr  gets our debug output put in it. [OUTPUTS] Reimplemented from NodeRenderableBounded. Definition at line 258 of file ndclpcnt.cpp. { #ifdef _DEBUG // Get base class debug info. NodeGroup::GetDebugDetails(pStr); // output the data for our keyhole path. String_256 TempStr; (*pStr) += TEXT( "\r\nClipping Path Data\r\n" ); m_KeyholePath.GetDebugDetails(pStr); #endif }

DocRect NodeClipViewController::GetEorDragBoundingRect (   )  [virtual]

The rectangle calculated is the union of EorDragBoundingRect()'s for each of our keyhole nodes. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 03 April 2000 Returns: The bounding rect of this ClipView group to draw when dragging it around, or a zeroed DocRect if we have no keyhole nodes (a *bad* thing). Errors: See also: Reimplemented from NodeGroup. Definition at line 472 of file ndclpcnt.cpp. { // start off with a zeroed bounding rect, and union it with the bounds of all keyhole // nodes, ie ink-nodes to the left of our NodeClipView. DocRect drBounds(0, 0, 0, 0); NodeClipView* pClipView = GetClipView(); if (pClipView != NULL) { Node* pKeyhole = pClipView->FindPrevious(); while (pKeyhole != NULL) { if (pKeyhole->IsAnObject()) drBounds = drBounds.Union(((NodeRenderableInk*)pKeyhole)->GetEorDragBoundingRect()); pKeyhole = pKeyhole->FindPrevious(); } } return drBounds; }

Path* NodeClipViewController::GetKeyholePath (   )  [inline]

Definition at line 268 of file ndclpcnt.h. { return &m_KeyholePath; }

UINT32 NodeClipViewController::GetNodeSize (   )  const [virtual]

Obtain the size of a NodeClipViewController object. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 02 February 2000 Returns: The size of the node in bytes. See also: Node::GetSubtreeSize Reimplemented from NodeGroup. Definition at line 2341 of file ndclpcnt.cpp. { return sizeof(NodeClipViewController); }

virtual BOOL NodeClipViewController::GroupCanTransformCached (  TransformBase &  Trans  )  const [inline, virtual]

Reimplemented from NodeGroup. Definition at line 209 of file ndclpcnt.h. {return TRUE;}

BOOL NodeClipViewController::HandleContentsBlobClick (  ClickType  cType  )  [protected, virtual]

Handler for what happens when the user clicks on our contents-select blob. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 23 March 2000 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if we handled the click, FALSE if we passed. We select all our NodeRenderableInk children *except* for our keyhole node. Returns: Errors: See also: Definition at line 895 of file ndclpcnt.cpp. { // DEBUG // TRACEUSER( "Karim", _T("NCVC::HandleContentsBlobClick; cType %s\n"), // (cType == CLICKTYPE_DRAG) ? "DRAG" : // (cType == CLICKTYPE_UP) ? "UP" : ""); // quit immediately unless it's the selector tool. Tool* pTool = Tool::GetCurrent(); if (pTool == NULL || pTool->GetID() != TOOLID_SELECTOR) return FALSE; // also quit if we don't like the click type. if (cType != CLICKTYPE_DRAG && cType != CLICKTYPE_UP) return FALSE; // deselect everything, then select all non-keyhole nodes, // ie all nodes which are right-siblings of our clipview node. BOOL bChangedSelection = FALSE; Node* pFirstKid = NULL; NodeClipView* pClipView = GetClipView(); if (pClipView != NULL) { Node* pKid = pClipView->FindNext(); while (pKid != NULL) { if (pKid->IsAnObject()) { if (!bChangedSelection) { DeselectAll(); pFirstKid = pKid; bChangedSelection = TRUE; } ((NodeRenderableInk*)pKid)->Select(TRUE); } pKid = pKid->FindNext(); } } if (bChangedSelection) { SelRange* pSel = GetApplication()->FindSelection(); if (pSel != NULL) pSel->Update(TRUE, pFirstKid); } // ok, if we successfully changed the selection, we // may need to start a drag with the selector tool. if (bChangedSelection && cType == CLICKTYPE_DRAG) ((SelectorTool*)pTool)->PublicDoTranslate(); return bChangedSelection; }

BOOL NodeClipViewController::HandleKeyholeBlobClick (  ClickType  cType  )  [protected, virtual]

Handler for what happens when the user clicks on our keyhole-select blob. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 23 March 2000 Parameters: [INPUTS]  [OUTPUTS]  Returns: TRUE if we handled the click, FALSE if we passed. All we do is try to select our keyhole nodes. Returns: Errors: See also: Definition at line 831 of file ndclpcnt.cpp. { // DEBUG // TRACEUSER( "Karim", _T("NCVC::HandleKeyholeBlobClick!\n")); // quit immediately unless it's a button-up click with the selector tool. Tool* pTool = Tool::GetCurrent(); if (cType != CLICKTYPE_UP || pTool == NULL || pTool->GetID() != TOOLID_SELECTOR) return FALSE; // select all our keyhole nodes, which are those nodes to the left of our NodeClipView. // if for some reason we can't select any nodes, we'll return FALSE. BOOL bChangedSelection = FALSE; Node* pFirstKeyhole = NULL; NodeClipView* pClipView = GetClipView(); if (pClipView != NULL) { Node* pKeyhole = pClipView->FindPrevious(); while (pKeyhole != NULL) { if (pKeyhole->IsAnObject()) { if (!bChangedSelection) { DeselectAll(); pFirstKeyhole = pKeyhole; bChangedSelection = TRUE; } ((NodeRenderableInk*)pKeyhole)->Select(TRUE); } pKeyhole = pKeyhole->FindPrevious(); } } if (bChangedSelection) { SelRange* pSel = GetApplication()->FindSelection(); if (pSel != NULL) pSel->Update(TRUE, pFirstKeyhole); } return bChangedSelection; }

BOOL NodeClipViewController::InkHasClearLineColour (  NodeRenderableInk *  pInkNode  )  [private]

Test whether the line colour of the given NodeRenderableInk is transparent. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 08 March 2000 Parameters: InkNode  const reference to a NodeRenderableInk. [INPUTS] Returns: TRUE if we can definitely confirm the node has a transparent line width, FALSE for any other result. Errors: See also: Definition at line 1622 of file ndclpcnt.cpp. { NodeAttribute *pAppliedAttr = NULL; pInkNode->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), &pAppliedAttr); if (pAppliedAttr != NULL) { DocColour* pLineColour = ((AttrStrokeColour*)pAppliedAttr)->GetStartColour(); if (pLineColour != NULL) return pLineColour->IsTransparent(); } return FALSE; }

BOOL NodeClipViewController::InsertClippedNode (  NodePath *  pNewNode, NodePath *  pDestNode, AttachNodeDirection  Direction, UndoableOperation *  pUndoOp, BOOL  bClipToKeyhole )  [private]

Definition at line 1455 of file ndclpcnt.cpp. { // input validation. if (pNewNode == NULL /*|| pUndoOp == NULL*/) { ERROR3("NCVC::InsertClippedNode; NULL parameters"); return FALSE; } // make the node's line transparent, if necessary clip to the keyhole node, // and then undoably insert it into the tree. // note that we *don't* abort the whole operation if clipping the // path went badly, we just don't insert it into the tree. BOOL clipok = TRUE; BOOL ok = RemoveInkLineWidth(pNewNode); if (ok) { if (bClipToKeyhole) { Path* pWorkPath = &(pNewNode->InkPath); m_KeyholePath.ClipPathToPath(*pWorkPath, pWorkPath, 2, CLIPVIEW_TOLERANCE, CLIPVIEW_SOURCEFLATNESS, CLIPVIEW_CLIPFLATNESS); if (pWorkPath->GetNumCoords() < 2) clipok = FALSE; else pWorkPath->InitialiseFlags(); } if (clipok) { if (pUndoOp) ok = pUndoOp->DoInsertNewNode( pNewNode, pDestNode, Direction, FALSE, FALSE, pDestNode->IsSelected(), TRUE ); else pNewNode->AttachNode(pDestNode, Direction); } } // tidy up if necessary. if ((!clipok || !ok) && pNewNode != NULL) { pNewNode->CascadeDelete(); delete pNewNode; } pNewNode = NULL; return ok; }

virtual BOOL NodeClipViewController::IsANodeClipViewController (   )  const [inline, virtual]

Reimplemented from Node. Definition at line 171 of file ndclpcnt.h. { return TRUE; }

virtual BOOL NodeClipViewController::IsController (   )  [inline, virtual]

Reimplemented from Node. Definition at line 260 of file ndclpcnt.h. { return TRUE; }

BOOL NodeClipViewController::IsKeyholeValid (   )  const [inline, private]

Definition at line 228 of file ndclpcnt.h. { return m_fKeyholeValid; }

BOOL NodeClipViewController::KeyholeDoBecomeA (  BecomeA *  pBecomeA  )  [private]

BOOL NodeClipViewController::MakeShapeAndLine (  NodePath *  pNodePath, BecomeA *  pBecomeA, BOOL  bClipToKeyhole )  [private]

Definition at line 1313 of file ndclpcnt.cpp. { // DEBUG // TRACEUSER( "Karim", _T("NCVC::MakeShapeAndLine\n")); // validate inputs. if (pNodePath == NULL || pBecomeA == NULL) { ERROR3("NCVC::MakeShapeAndLine; NULL parameters"); return FALSE; } BecomeAReason Reason = pBecomeA->GetReason(); if (Reason != BECOMEA_REPLACE && Reason != BECOMEA_PASSBACK) { ERROR3("NCVC::MakeShapeAndLine; Invalid parameters"); return FALSE; } UndoableOperation* pUndoOp = pBecomeA->GetUndoOp(); // if (Reason == BECOMEA_REPLACE && pUndoOp == NULL) // { // ERROR3("NCVC::MakeShapeAndLine; Invalid parameters"); // return FALSE; // } // local variables. BOOL ok = TRUE; NodePath* pNewNode = NULL; CCAttrMap* pAttrMap = NULL; // if the path is filled then insert/passback a doctored copy of it, // complete with attached copies of all the node's attributes. // note that we don't want to find indirectly applied GLAs here (eg feathers). if (pNodePath->InkPath.IsFilled) { if (ok) { pNewNode = (NodePath*)pNodePath->SimpleCopy(); ok = (pNewNode != NULL); } if (ok) { pAttrMap = NULL; ALLOC_WITH_FAIL(pAttrMap, new CCAttrMap, pUndoOp); ok = (pAttrMap != NULL); } if (ok) ok = pNodePath->FindAppliedAttributes(pAttrMap, 5000, NULL, TRUE); if (ok) ok = pNewNode->ApplyAttributes(pAttrMap); if (ok) { if (Reason == BECOMEA_REPLACE) { ok = InsertClippedNode(pNewNode, pNodePath, PREV, pUndoOp, bClipToKeyhole); if (ok) pBecomeA->PassBack(pNewNode, this, pAttrMap->Copy()); } else ok = PassBackClippedNode(pNewNode, pBecomeA, bClipToKeyhole); } if (pAttrMap != NULL) { delete pAttrMap; pAttrMap = NULL; } } // if the path has an outline, then stroke its outline and pass it back/insert it, // complete with copies of the node's attributes. if (ok && !InkHasClearLineColour(pNodePath)) { if (ok) { INT32 Flatness = EstimatePathFlatness(); pNewNode = pNodePath->MakeNodePathFromAttributes(Flatness, NULL, TRUE); ok = (pNewNode != NULL); } if (ok) { pAttrMap = NULL; ALLOC_WITH_FAIL(pAttrMap, new CCAttrMap, pUndoOp); ok = (pAttrMap != NULL); } if (ok) ok = pNodePath->FindAppliedAttributes(pAttrMap, 5000, NULL, TRUE); if (ok) ok = pNewNode->ApplyAttributes(pAttrMap); if (ok) ok = CopyInkFillColourFromLine(pNewNode); if (ok) ok = CopyInkTransparencyFromLine(pNewNode); if (ok) { if (Reason == BECOMEA_REPLACE) { ok = InsertClippedNode(pNewNode, pNodePath, PREV, pUndoOp, bClipToKeyhole); if (ok) pBecomeA->PassBack(pNewNode, this, pAttrMap->Copy()); } else ok = PassBackClippedNode(pNewNode, pBecomeA, bClipToKeyhole); } if (pAttrMap != NULL) { delete pAttrMap; pAttrMap = NULL; } } // if we're replacing, and things are ok, then hide the NodePath. if (ok && Reason == BECOMEA_REPLACE) { if (pUndoOp) ok = pUndoOp->DoHideNode(pNodePath, FALSE); else { pNodePath->CascadeDelete(); delete pNodePath; } } return ok; }

void NodeClipViewController::MarkKeyholeInvalid (   )  [inline, private]

Definition at line 230 of file ndclpcnt.h. { m_fKeyholeValid = FALSE; }

void NodeClipViewController::MarkKeyholeValid (   )  [inline, private]

Definition at line 229 of file ndclpcnt.h. { m_fKeyholeValid = TRUE; }

ChangeCode NodeClipViewController::OnChildChange (  ObjChangeParam *  pParam  )  [virtual]

Used to notify this node of changes to its children, so that if required it can update itself. This forms part of the AllowOp / UpdateChangedNodes mechanism. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 28 January 2000 Parameters: pParam  describes the change which occurred. [INPUTS] This  node may regenerate itself to accomodate the change. [OUTPUTS] Returns: CC_OK if we have successfully processed the change. CC_FAIL if we cannot handle this particular change and must prevent the child from continuing. Errors: ERROR2 if pParam is NULL. See also: Node::WarnParentOfChange(), Node::AllowOp() Reimplemented from NodeGroup. Definition at line 2112 of file ndclpcnt.cpp. { // validate input. ERROR2IF(pParam == NULL, CC_FAIL, "NULL pParam"); // we'll need pointers to our ClipView and Keyhole nodes later on. NodeClipView* pClipView = GetClipView(FALSE); // we need to deal with circumstances which may put us into an inconsistent state. // these are: // // * No ink-children, or only a ClipView node ==> hide ourself. // * No keyhole nodes => // * No clipped nodes ==> turn ourself into a group. // * No ClipView node => // UndoableOperation* pUndoOp = pParam->GetOpPointer(); ObjChangeType cType = pParam->GetChangeType(); if (cType == OBJCHANGE_FINISHED) { // count our kids. UINT32 NumKeyhole = 0; UINT32 NumClipped = 0; UINT32 NumKids = 0; BOOL fCountingKeyholes = TRUE; Node* pKid = FindFirstChild(); while (pKid != NULL) { if (pKid->IsAnObject()) { if (pKid == pClipView) { fCountingKeyholes = FALSE; } else { if (fCountingKeyholes) NumKeyhole ++; else NumClipped ++; } } pKid = pKid->FindNext(); } NumKids = NumKeyhole + NumClipped; // ok, we hide ourself if we have no ink-kids (ignoring the clipview node). if (NumKids == 0) { // we need an Op in order to do tree manipulations. BOOL ok = (pUndoOp != NULL); // hide ourself - find our parent before we do though. Node* pParent = FindParent(); if (ok) ok = pUndoOp->DoHideNode(this,TRUE); // now we're hidden, factor out all attributes on our parent. if (ok) if (pParent != NULL && pParent->IsCompound()) ok = pUndoOp->DoFactorOutCommonChildAttributes(((NodeRenderableInk*)pParent),TRUE); // TODO: rewind any actions here? if (!ok) return CC_FAIL; } // if we're missing any one of our three magic ingredients, we mighty-morph into a group. if (pClipView == NULL || NumKeyhole == 0 || NumClipped == 0) { // we need a valid UndoOp ptr with which to perform the conversion. if (pUndoOp != NULL) if (BecomeAGroup(pUndoOp)) return CC_OK; return CC_FAIL; } // the last case is where we have all three ingredients, in which case we // invalidate our keyhole path and make a 'mental' note that note that it // will need invalidating again whenever the user performs an undo or redo. else if (pUndoOp != NULL) { // DEBUG /* TRACEUSER( "Karim", _T("NCVC::OnCC;")); // direction of change. ObjChangeDirection cDirection = pParam->GetDirection(); switch (cDirection) { case OBJCHANGE_CALLEDBYCHILD: TRACEUSER( "Karim", _T(" OBJCHANGE_CALLEDBYCHILD")); break; case OBJCHANGE_CALLEDBYPARENT: TRACEUSER( "Karim", _T(" OBJCHANGE_CALLEDBYPARENT")); break; case OBJCHANGE_CALLEDBYOP: TRACEUSER( "Karim", _T(" OBJCHANGE_CALLEDBYOP")); break; default: break; } // type of change. TRACEUSER( "Karim", _T(" ;")); switch (cType) { case OBJCHANGE_UNDEFINED: TRACEUSER( "Karim", _T(" OBJCHANGE_UNDEFINED")); break; case OBJCHANGE_STARTING: TRACEUSER( "Karim", _T(" OBJCHANGE_STARTING")); break; case OBJCHANGE_RENDERCURRENTBLOBS: TRACEUSER( "Karim", _T(" OBJCHANGE_RENDERCURRENTBLOBS")); break; case OBJCHANGE_RENDERCHANGEDBLOBS: TRACEUSER( "Karim", _T(" OBJCHANGE_RENDERCHANGEDBLOBS")); break; case OBJCHANGE_FINISHED: TRACEUSER( "Karim", _T(" OBJCHANGE_FINISHED")); break; case OBJCHANGE_IGNORE: TRACEUSER( "Karim", _T(" OBJCHANGE_IGNORE")); break; case OBJCHANGE_FAILED: TRACEUSER( "Karim", _T(" OBJCHANGE_FAILED")); break; default: break; } // set change-flags. TRACEUSER( "Karim", _T("; Flags {")); ObjChangeFlags cFlags = pParam->GetChangeFlags(); if (cFlags.Attribute) TRACEUSER( "Karim", _T(" Attribute")); if (cFlags.CopyNode) TRACEUSER( "Karim", _T(" CopyNode")); if (cFlags.DeleteNode) TRACEUSER( "Karim", _T(" DeleteNode")); if (cFlags.MoveNode) TRACEUSER( "Karim", _T(" MoveNode")); if (cFlags.MultiReplaceNode) TRACEUSER( "Karim", _T(" MultiReplaceNode")); if (cFlags.RegenerateNode) TRACEUSER( "Karim", _T(" RegenerateNode")); if (cFlags.ReplaceNode) TRACEUSER( "Karim", _T(" ReplaceNode")); if (cFlags.TransformNode) TRACEUSER( "Karim", _T(" TransformNode")); TRACEUSER( "Karim", _T(" }\n")); */ // mark the cached keyhole path for update. UpdateCachedKeyholePathAction::Init( pUndoOp, pUndoOp->GetUndoActions(), this ); } else if (!pUndoOp) { Document * pDoc = Document::GetCurrent(); if (pDoc) { if (pParam->GetChangeFlags ().RegenerateNode) { MarkKeyholeInvalid (); // CGS: it is now legitimate for us to do this } Spread * pSpread = (Spread *)FindParent(CC_RUNTIME_CLASS(Spread)); pDoc->ForceRedraw(pSpread, GetBoundingRect(FALSE, FALSE), FALSE, this); } } } // call the base class version for the normal group checks, which will also deal with the // case where we have no kids at all. return NodeGroup::OnChildChange(pParam); }

BOOL NodeClipViewController::OnClick (  DocCoord  dcClickPos, ClickType  cType, ClickModifiers  cMods, Spread *  pSpread )  [virtual]

Handle any click-messages passed to us from a tool, eg if we want to handle clicks on our object or tool-object blobs. Currently, you can click on an NCVC tool-object blob and either select its keyhole node, or select everything *except* its keyhole node. At some point in future, you will also be able to directly drag everything except the keyhole node (instead of clicking once to select, _then_ dragging). Reimplemented from NodeGroup. Definition at line 760 of file ndclpcnt.cpp. { // DEBUG // TRACEUSER( "Karim", _T("NCVC::OnClick\n"), (DWORD)cType); // determine what to do with the click. // note that we can't do anything unless we have valid pointers to view and blob manager. BlobManager* pBlobMgr = GetApplication()->GetBlobManager(); DocView* pDocView = DocView::GetSelected(); if (pBlobMgr == NULL || pDocView == NULL) return FALSE; // currently we only specifically handle ToolObject blobs. BlobStyle bsCurrentInterest = pBlobMgr->GetCurrentInterest(); if (bsCurrentInterest.ToolObject) { // get bounds rects for the appropriate blobs. DocRect drKeyholeBlobRect; DocRect drContentsBlobRect; DocRect drBounds = GetBoundingRect(); pBlobMgr->GetBlobRect(DocCoord(drBounds.lo.x, drBounds.hi.y), &drKeyholeBlobRect, FALSE, BT_CLIPVIEW); pBlobMgr->GetBlobRect(drBounds.Centre(), &drContentsBlobRect, FALSE, BT_CLIPVIEW); // inflate the rects, so the user doesn't need to be pin-point accurate. MILLIPOINT nNearRadius = OSRenderRegion::GetHitTestRadius(pDocView); drKeyholeBlobRect.Inflate(nNearRadius); drContentsBlobRect.Inflate(nNearRadius); // ok, lets test! if (drKeyholeBlobRect.ContainsCoord(dcClickPos)) { if (HandleKeyholeBlobClick(cType)) return TRUE; } else if (drContentsBlobRect.ContainsCoord(dcClickPos)) { if (HandleContentsBlobClick(cType)) return TRUE; } } // if we haven't handled the click and we're displaying object blobs, // hand over to our base implementation. if (bsCurrentInterest.Object) return NodeGroup::OnClick(dcClickPos, cType, cMods, pSpread); // we couldn't handle the click. return FALSE; }

BOOL NodeClipViewController::OwnsAsKeyholeNode (  const Node *  pTestNode  )

Test whether the given node is a keyhole node for this NCVC. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 09/05/2000 Parameters: pTestNode  the possible keyhole node. [INPUTS] Returns: TRUE if pTestNode is a keyhole node for us, FALSE otherwise. Errors: In debug, ERROR3 if pTestNode is NULL. In release, just return with FALSE. See also: Definition at line 316 of file ndclpcnt.cpp. { // input validation. if (pTestNode == NULL) { ERROR3("NCVC::OwnsAsKeyholeNode; NULL entry parameter!"); return FALSE; } // Ensure keyhole path is valid (helps hit-detection) UpdateKeyholePath(); // ok, any ink-node to the left of our NodeClipView is a keyhole node. Node* pKeyhole = NULL; Node* pClipView = GetClipView(); BOOL bFoundKeyhole = FALSE; if (pClipView != NULL) { pKeyhole = pClipView->FindPrevious(); while (!bFoundKeyhole && pKeyhole != NULL) { bFoundKeyhole = (pKeyhole->IsAnObject() && pTestNode == pKeyhole); pKeyhole = pKeyhole->FindPrevious(); } } return bFoundKeyhole; }

BOOL NodeClipViewController::PassBackClippedNode (  NodePath *  pNewNode, BecomeA *  pBecomeA, BOOL  bClipToKeyhole )  [private]

Returns: Errors: ERROR3 returning FALSE if invalid parameters. See also: Definition at line 1533 of file ndclpcnt.cpp. { // validate inputs. if (pNewNode == NULL || pBecomeA == NULL) { ERROR3("NCVC::PassBackClippedNode; NULL parameters"); return FALSE; } // local variables. BOOL clipok = TRUE; BOOL ok = TRUE; CCAttrMap* pAttrMap = NULL; CCAttrMap* pCopiedAttrs = NULL; // remove line width, copy its attribute map, try to clip to the keyhole // node and then pass back the path. // NB although we usually abort if anything goes wrong, we do *not* abort // if we failed to clip to the keyhole path - we just don't pass it back. if (ok) ok = RemoveInkLineWidth(pNewNode); if (ok) { pAttrMap = new CCAttrMap(); ok = (pAttrMap != NULL); } if (ok) ok = pNewNode->FindAppliedAttributes(pAttrMap); if (ok) { pCopiedAttrs = pAttrMap->Copy(); ok = (pCopiedAttrs != NULL); } if (ok) { pNewNode->CascadeDelete(); if (bClipToKeyhole) { Path* pWorkPath = &(pNewNode->InkPath); m_KeyholePath.ClipPathToPath(*pWorkPath, pWorkPath, 2, CLIPVIEW_TOLERANCE, CLIPVIEW_SOURCEFLATNESS, CLIPVIEW_CLIPFLATNESS); if (pWorkPath->GetNumCoords() < 2) clipok = FALSE; else pWorkPath->InitialiseFlags(); } if (clipok) ok = pBecomeA->PassBack(pNewNode, this, pCopiedAttrs); } // tidy up if everything didn't go according to plan. if (!ok || !clipok) { if (pNewNode != NULL) { pNewNode->CascadeDelete(); delete pNewNode; } if (pCopiedAttrs != NULL) { pCopiedAttrs->DeleteAttributes(); delete pCopiedAttrs; } } if (pAttrMap != NULL) delete pAttrMap; return ok; }

void NodeClipViewController::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 NodeGroup. Definition at line 2517 of file ndclpcnt.cpp. { ENSURE(pNodeCopy, "Trying to copy a node's contents into a NULL node"); ENSURE(IS_A(pNodeCopy, NodeClipViewController), "PolyCopyNodeContents given wrong dest node type"); if (IS_A(pNodeCopy, NodeClipViewController)) CopyNodeContents((NodeClipViewController*)pNodeCopy); }

BOOL NodeClipViewController::PostImport (  void   )  [virtual]

Performs any necessary post-processing once the object has been read in from a file. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 31 January 2000 Returns: TRUE if success, FALSE if unsuccessful. Errors: See also: Reimplemented from Node. Definition at line 2454 of file ndclpcnt.cpp. { return UpdateKeyholePath(); }

void NodeClipViewController::PreExportRender (  RenderRegion *  pRegion  )  [virtual]

Starts exporting a clipview group - basically writes a 'q' token out. Author: Chris_Gallimore (Xara Group Ltd) <camelotdev@xara.com> Date: 8th November 2000 Parameters: pRegion  - the RenderRegion we're exporting to. [INPUTS] Returns: Errors: See also: Node::PreExportRender() Reimplemented from NodeGroup. Definition at line 2541 of file ndclpcnt.cpp. { #ifdef DO_EXPORT if (pRegion->IsKindOf(CC_RUNTIME_CLASS(EPSRenderRegion))) { // Output "start group" token EPSExportDC *pDC = (EPSExportDC *) pRegion->GetRenderDC(); pDC->OutputToken(_T("q")); pDC->OutputNewLine(); } PORTNOTE("cmx", "Removed use of CMXRenderRegion") #ifndef EXCLUDE_FROM_XARALX else if(pRegion->IsKindOf(CC_RUNTIME_CLASS(CMXRenderRegion))) { // mark start of a group... CMXExportDC *pDC = (CMXExportDC *) pRegion->GetRenderDC(); DocRect BBox = GetBoundingRect(); pDC->StartGroup(&BBox); } #endif #endif }

BOOL NodeClipViewController::RemoveInkLineWidth (  NodeRenderableInk *  pInk  )  [private]

Make the outline of the given node transparent and set its line width to 0. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 09 March 2000 Parameters: pInk  pointer to the NodeRenderableInk to work on. [INPUTS] pInk's  line colour should become transparent. [OUTPUTS] Returns: TRUE if successful, FALSE otherwise. NOTE: This method does *not* record undo information, and it expects attributes to have been localised beforehand. Returns: Errors: ERROR3 and returns FALSE if pInk is NULL. See also: Definition at line 1655 of file ndclpcnt.cpp. { if (pInk == NULL) { ERROR3("NCVC::RemoveInkLineWidth; NULL parameter(s)"); return FALSE; } NodeAttribute* pAppliedAttr = NULL; DocColour* pLineColour = NULL; LineWidthAttribute* pLineWidth = NULL; pInk->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeColour), &pAppliedAttr); if (pAppliedAttr != NULL) pLineColour = ((AttrStrokeColour*)pAppliedAttr)->GetStartColour(); pAppliedAttr = NULL; pInk->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrLineWidth), &pAppliedAttr); if (pAppliedAttr != NULL) pLineWidth = (LineWidthAttribute*)pAppliedAttr->GetAttributeValue(); if (pLineColour != NULL && pLineWidth != NULL) { *pLineColour = DocColour(COLOUR_TRANS); pLineWidth->LineWidth = 0; return TRUE; } return FALSE; }

void NodeClipViewController::RenderClipViewBlobs (  RenderRegion *  pRender  )  [protected, virtual]

Render the blobs specifically used by ClipView groups. These are currently as follows: 1. A keyhole-selection blob, which is rendered at the top-left of our bounding rectangle. 2. A select-contained-objects blob, which is rendered in the centre of the group's bounding rectangle. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 23 March 2000 Parameters: pRender  the region to render to. [INPUTS] Returns: Errors: See also: Definition at line 710 of file ndclpcnt.cpp. { // quit immediately unless the current tool is the selector tool. Tool* pTool = Tool::GetCurrent(); if (pTool == NULL || pTool->GetID() != TOOLID_SELECTOR) return; // get the blob manager and set the colours we'll be using. // BlobManager* pBlobManager = GetApplication()->GetBlobManager(); pRender->SetLineColour(COLOUR_NONE); pRender->SetFillColour(COLOUR_UNSELECTEDBLOB); // plot the keyhole blob at the top-left of our bounding rectangle. DocRect drBounds = GetBoundingRect(); DocCoord dcKeyhole(drBounds.lo.x, drBounds.hi.y); pRender->DrawBitmapBlob(dcKeyhole, _R(IDBMP_KEYHOLE)); // plot the select-inside blob at the centre of our bounding rectangle. pRender->DrawBitmapBlob(drBounds.Centre(), _R(IDBMP_CLIPVIEW_SELECT_CONTENTS)); // BODGE CODE! // some of the ClipView blobs are rendered in the same position as our tiny blobs. // we don't want the tiny blobs to interfere with these blobs, so we double-render // them off the picture (double XOR = 0) whenever these blobs are rendered. // this relies on Tiny blobs always being rendered whenever these blobs // are rendered (which they have always been up till 06/04/2000) RenderTinyBlobs(pRender); }

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

Render this node as eor-blobs into the given render region. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 28 January 2000 Parameters: pRender  pointer to the render region to render into. [INPUTS] What we probably want to do is clip the outlines of all our children, and render those outlines into the given render region, however for now we'll just render our keyhole node's outline. Returns: Errors: See also: See Render() for info. Reimplemented from NodeRenderableInk. Definition at line 548 of file ndclpcnt.cpp. { // <RANT> // unfortunately, if we opt to do eor-drag-rendering for our kids (and we do), // then as well as getting to render for them when we're dragged around, we also // get lumbered with rendering for them when *they* get dragged around. // this is annoying and the solution should *not* be to do their rendering // for them if we're not selected, but that's what we're gonna do. // </RANT> // determine whether myself or one of my ancestors is selected. BOOL fMeOrMyAncestorIsSelected = IsSelected(); Node* pParent = FindParent(); while (!fMeOrMyAncestorIsSelected && pParent != NULL) { fMeOrMyAncestorIsSelected = pParent->IsSelected(); pParent = pParent->FindParent(); } // do normal eor-drag-rendering for myself (eor-rendering our keyhole path.) if (fMeOrMyAncestorIsSelected) { UpdateKeyholePath(); pRender->DrawPath(&m_KeyholePath); } // do eor-drag-rendering for those of my lazy children which are selected. RenderEorDragSelectedChildren(this, pRender); }

void NodeClipViewController::RenderEorDragSelectedChildren (  Node *  pParent, RenderRegion *  pRender )  [virtual]

Notes: I get the feeling this vfn should really live in NodeRenderableInk, so if things work out then I'll put it there. Returns: Errors: See also: RenderEorDragChildren() for something similar... Definition at line 599 of file ndclpcnt.cpp. { NodeRenderableInk* pInkKid = NULL; Node* pKid = pParent->FindFirstChild(); while (pKid != NULL) { if (pKid->IsAnObject()) { pInkKid = (NodeRenderableInk*)pKid; // ok, is it selected? if so, render its drag blobs, taking account of bossy // controller nodes who want to render their children themselves. if (pInkKid->IsSelected()) { pInkKid->RenderEorDrag(pRender); if (!pInkKid->ChildrenAreEorDragRenderedByMe()) pInkKid->RenderEorDragChildren(pRender); } // nope, not selected - recurse down into it if possible. else { RenderEorDragSelectedChildren(pInkKid, pRender); } } pKid = pKid->FindNext(); } }

SubtreeRenderState NodeClipViewController::RenderSubtree (  RenderRegion *  pRender, Node **  ppNextNode = NULL, BOOL  bClip = TRUE )  [virtual]

Called by the main rendering loop before this node's children are rendered, usually to allow us to muck around with how we want our children to render. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 15 February 2000 Parameters: [INPUTS]  [OUTPUTS]  Returns: PRE_RENDER_CHILDREN. It is used here to clear up any debris left over from an unfinished hit-test render-loop. Returns: Errors: See also: Reimplemented from NodeGroup. Definition at line 513 of file ndclpcnt.cpp. { if (pRender && !pRender->IsPrinting()) { // ensure our cached keyhole path is up to date. UpdateKeyholePath(); // return SUBTREE_ROOTANDCHILDREN; return NodeGroup::RenderSubtree(pRender, ppNextNode, bClip); } else // return SUBTREE_ROOTANDCHILDREN; return NodeGroup::RenderSubtree(pRender, ppNextNode, bClip); // return SUBTREE_ROOTANDCHILDREN; }

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

Render our tiny-blob. This consists of a solitary blob at the top-left of our bounding rect. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 06 April 2000 Parameters: pRender  the render-region to render into. [INPUTS] Reimplemented from NodeGroup. Definition at line 664 of file ndclpcnt.cpp. { // Get our bounding rect, and from it the position of our tiny blob. DocRect drBounds = GetBoundingRect(); DocCoord dcTinyPos = DocCoord(drBounds.lo.x, drBounds.hi.y); // Set our blob's colours and render it. pRender->SetFillColour(COLOUR_UNSELECTEDBLOB); pRender->SetLineColour(COLOUR_NONE); pRender->DrawBlob(dcTinyPos, BT_UNSELECTED); }

void NodeClipViewController::RenderToolObjectBlobs (  RenderRegion *  pRender  )  [virtual]

Render our tool-object blobs. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 23 March 2000 Parameters: pRender  ptr to the region to render into. [INPUTS] Reimplemented from NodeRenderable. Definition at line 686 of file ndclpcnt.cpp. { RenderClipViewBlobs(pRender); }

Node * NodeClipViewController::SimpleCopy (  void   )  [protected, virtual]

Copy this node. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 09 February 2000 Returns: A copy of this node, or NULL if unsuccessful. Errors: ERROR1 returning NULL if we couldn't allocate memory for the new node. See also: Node::SimpleCopy() Reimplemented from NodeGroup. Definition at line 2474 of file ndclpcnt.cpp. { NodeClipViewController* pNodeCopy = new NodeClipViewController;; ERROR1IF(pNodeCopy == NULL, NULL, _R(IDE_NOMORE_MEMORY)); CopyNodeContents(pNodeCopy); return pNodeCopy; }

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

Perform a transformation on this node. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 31 January 2000 Parameters: Trans  non-const reference to a description of the transformation. [INPUTS] This  node will be transformed appropriately. [OUTPUTS] Returns: Errors: See also: Reimplemented from NodeGroup. Definition at line 2361 of file ndclpcnt.cpp. { // required because certain processes which transform nodes do not fire off my // OnChildChange method (haven't investigated why) MarkKeyholeInvalid(); // ClipViews can't just transform their cached data - they have to // also transform their children because clipview's GetBoundingRect // always calculates - never returns cached rectangle. Trans.bTransformYourChildren = TRUE; // ClipViews can't just transform their cached data - they have to // also transform their children because clipview's GetBoundingRect // always calculates - never returns cached rectangle. Trans.bTransformYourChildren = TRUE; // ClipViews can't just transform their cached data - they have to // also transform their children because clipview's GetBoundingRect // always calculates - never returns cached rectangle. Trans.bTransformYourChildren = TRUE; // transform our children etc, in the same way a normal group would. NodeGroup::Transform(Trans); }

BOOL NodeClipViewController::UpdateKeyholePath (   )  [private]

Update our cached outline for our keyhole node. Note that this method only tries to update the keyhole path if it is marked as invalid. If it is already valid, you just get TRUE back. It will also only re-mark the keyhole as valid if it successfully updates the keyhole cache. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 13 March 2000 Parameters: [INPUTS]  [OUTPUTS]  Returns: Errors: See also: InvalidateKeyhole(). Definition at line 1938 of file ndclpcnt.cpp. { // DEBUG // TRACEUSER( "Karim", _T("NCVC::UpdateKeyholePath; %s.\n"), // IsKeyholeValid() ? "valid" : "invalid"); if (IsKeyholeValid()) return TRUE; NodeClipView* pClipView = GetClipView(); if (pClipView == NULL) return FALSE; // DoBecomeA on all our keyhole nodes (nodes to the left of our clipview node), and // add the resulting paths up to get one big keyhole-path. // in the interests of accuracy, and because most of the time we expect only to have // one keyhole path, we're going to do as little clip-path-to-path'ing as possible. BOOL bAddedFirstPath = FALSE; Node* pKeyhole = pClipView->FindPrevious(); while (!bAddedFirstPath && pKeyhole != NULL) { if (pKeyhole->IsAnObject()) { m_KeyholePath.ClearPath(); PathBecomeA baInfo(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL, FALSE, &m_KeyholePath, PathBecomeA::STRIP_OUTLINES ); baInfo.SetPathsOnly(); if (pKeyhole->DoBecomeA(&baInfo)) bAddedFirstPath = TRUE; } pKeyhole = pKeyhole->FindPrevious(); } // ok, now add any other keyholes which are kicking around. BOOL ok = TRUE; if (pKeyhole != NULL) { INT32 Flatness = EstimatePathFlatness(); Path m_WorkPath; m_WorkPath.Initialise(); while (ok && pKeyhole != NULL) { if (pKeyhole->IsAnObject()) { m_WorkPath.ClearPath(); PathBecomeA baInfo(BECOMEA_PASSBACK, CC_RUNTIME_CLASS(NodePath), NULL, FALSE, &m_WorkPath, PathBecomeA::STRIP_OUTLINES); baInfo.SetPathsOnly(); if (ok && pKeyhole->DoBecomeA(&baInfo)) ok = (m_KeyholePath.ClipPathToPath( m_WorkPath, &m_KeyholePath, 7, CLIPVIEW_TOLERANCE, Flatness, Flatness) != -1); } pKeyhole = pKeyhole->FindPrevious(); } } // if our keyhole path is empty, then we need to hide everything which we're clipping. // we'll do this by building an empty keyhole path out of our bounding rect. if (m_KeyholePath.GetNumCoords() == 0) { DocRect drBounds = GetBoundingRect(); DocCoord drLeft(drBounds.lo.x, (drBounds.lo.y + drBounds.hi.y) / 2); DocCoord drRight(drBounds.hi.x, (drBounds.lo.y + drBounds.hi.y) / 2); m_KeyholePath.Initialise(3); m_KeyholePath.AddMoveTo(drLeft); m_KeyholePath.AddLineTo(drRight); m_KeyholePath.AddLineTo(drLeft); m_KeyholePath.IsFilled = TRUE; } // ok, setup with the new keyhole path. pClipView->SetClipPath(&m_KeyholePath); if (ok) MarkKeyholeValid(); return ok; }

BOOL NodeClipViewController::WritePreChildrenNative (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes this node out to a camelot document. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 31 January 2000 Parameters: pFilter  pointer to a camelot file filter. [INPUTS] Returns: TRUE if successful, FALSE otherwise. Errors: See also: Reimplemented from NodeGroup. Definition at line 2433 of file ndclpcnt.cpp. { return WritePreChildrenWeb(pFilter); }

BOOL NodeClipViewController::WritePreChildrenWeb (  BaseCamelotFilter *  pFilter  )  [virtual]

Writes this node out to a camelot document. Author: Karim_MacDonald (Xara Group Ltd) <camelotdev@xara.com> Date: 31 January 2000 Parameters: pFilter  pointer to a camelot file filter. [INPUTS] Returns: TRUE if successful, FALSE otherwise. Errors: ERROR2 if pFilter is NULL. See also: Reimplemented from NodeGroup. Definition at line 2403 of file ndclpcnt.cpp. { // validate input. ERROR2IF(pFilter == NULL, FALSE, "NULL parameter"); CXaraFileRecord Rec(TAG_CLIPVIEWCONTROLLER, TAG_CLIPVIEW_CONTROLLER_SIZE); BOOL ok = Rec.Init(); if (ok) ok = (pFilter->Write(&Rec) != 0); return ok; }

---

Friends And Related Function Documentation

friend class NodeClipView [friend]

Definition at line 152 of file ndclpcnt.h.

void OpApplyClipView::Do (  OpDescriptor *  pOpDesc  )  [friend]

friend class UpdateCachedKeyholePathAction [friend]

Definition at line 154 of file ndclpcnt.h.

---

Member Data Documentation

const INT32 NodeClipViewController::CLIPVIEW_CLIPFLATNESS = 50 [static]

Definition at line 276 of file ndclpcnt.h.

const INT32 NodeClipViewController::CLIPVIEW_SOURCEFLATNESS [static]

Definition at line 275 of file ndclpcnt.h.

const INT32 NodeClipViewController::CLIPVIEW_TOLERANCE [static]

Definition at line 274 of file ndclpcnt.h.

DocRect NodeClipViewController::m_drContentsBlobRect [private]

Definition at line 299 of file ndclpcnt.h.

DocRect NodeClipViewController::m_drKeyholeBlobRect [private]

Definition at line 298 of file ndclpcnt.h.

BOOL NodeClipViewController::m_fKeyholeValid [private]

Definition at line 295 of file ndclpcnt.h.

Path NodeClipViewController::m_KeyholePath [private]

Definition at line 294 of file ndclpcnt.h.

---

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

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

---