OpCombineShapes Class Reference

Base class op that does all the shape combining ops, like add, subtract and intersect,etc. More...

#include <combshps.h>

Inheritance diagram for OpCombineShapes:

List of all members.

Public Member Functions
	OpCombineShapes ()
	Default constructor.
	~OpCombineShapes ()
	Default destructor - does nothing.
virtual void	Do (OpDescriptor *)
	This is it! The routine that gets all the hard work underway.
virtual void	GetOpName (String_256 *)
	The GetOpName fn is overridden so that we return back a description appropriate to the type of attribute that the operation applies.
Static Public Member Functions
static BOOL	Init ()
	Declares a preference that allows you to clear memory in delete().
static OpState	GetState (String_256 *, OpDescriptor *)
	Gives the op an oppertunity to say whether the op is executable or not.
Protected Attributes
CombineReason	Reason
Private Member Functions
BOOL	ConvertToShapes (Range *pRange, BOOL bCombineEffectBitmaps)
	This subtracts all the shapes in all the lists from all the lines in all the lists This subtracts all the shapes in all the lists from pLine This subtracts all the shapes in pSelObjPathList from pLine This generates the data structure that holds all the paths generated by the selected objects. NOTE! Pointers to paths in the tree are stored in the lists (unlike CreateSelObjPathLists).
BOOL	CreateSelObjPathLists (BOOL bCombineEffectBitmaps)
	This generates the data structure that holds all the paths generated by the selected objects.
BOOL	CreateSelObjPathList (Node *pNode, SelObjPathList *pSelObjPathList, BOOL IsFirstNode=TRUE, BOOL bCombineEffectBitmaps=TRUE, BecomeAReason reason=BECOMEA_PASSBACK)
	This generates the data structure that holds all the paths generated by a given selected object.
BOOL	DoAddShapes ()
	This adds all the paths together to form a combined silhouette path of the selection.
BOOL	AddPathsFromList (Path *pPath, SelObjPathList *pSelObjPathList)
	This adds all the paths in the list together to form a combined silhouette path of the selection.
BOOL	AddPaths (Path *pPath1, Path *pPath2)
	This adds the two paths together using ClipPathToPath, storing the result in pPath1.
BOOL	AddOrMergePaths (Path *pPath1, Path *pPath2)
	Helper function for DoAddShapes and AddPathsFromList.
BOOL	DoCombineShapes (ClipStyle Style, BOOL bCombineEffectBitmaps)
	Firstly, this adds all the paths together in the last list to form the clip path. Then all the other paths in the other lists are combined with the clip path, using the method specified in 'Flags'.
BOOL	CombinePathsFromList (ClipStyle Style, Path *pClipPath, Path *pStrokedClipPath, SelObjPathList *pSelObjPathList, BOOL bCombineEffectBitmaps=TRUE)
	This combines pClipPath with all the paths in pSelObjPathList.
BOOL	CombinePaths (ClipStyle Style, Path *pClipPath, Path *pStrokedClipPath, Path *pSrcPath, Path *pDestPath)
	This combines pClipPath from pSrcPath using ClipPathToPath, storing the result in pDestPath.
BOOL	DoHideListedNodes (BOOL bCombineEffectBitmaps)
	This hides all the nodes that were selected when the op was invoked.
BOOL	DoSelectResultNodes (BOOL bCombineEffectBitmaps)
	This selects all the nodes in the results list.
BOOL	ApplyAttributes (NodeRenderableInk *pSrcNode, NodeRenderableInk *pDestNode, CCAttrMap *pAttrMap, SelObjPathListItem *pListItem=NULL)
	This applies attrs pDestNode. If pAttrMap == NULL, the attrs applied to pSrcNode are applied to pDestNode, else the attrs in pAttrMap are applied.
BOOL	ApplyEffects (SelObjPathListItem *pListItem, NodeRenderableInk *pDestNode, NodeRenderableInk *pParentEffect)
	To delete the extra attributes we allocated in AdjustAttributesForStroke This applies attrs pDestNode. If pAttrMap == NULL, the attrs applied to pSrcNode are applied to pDestNode, else the attrs in pAttrMap are applied.
BOOL	StrokePathToPath (Path *pPath, Path *pDest)
	This picks out a subpath from Src and places it into pDest Strokes pPath, and places result in pDest.
BOOL	ConvertClipLineToShape (Path *pClipPath, Path *pSrcPath, Path *pDestPath)
	Only call this if pClipPath is a line.
DocRect	GetBoundingRect (Path *pPath)
	This gets the exact pure path bounds, using GDraw_CalcStrokeBBox.
BOOL	DoInsertNewNode (NodeRenderableBounded *pNewNode)
	High-level interface to UndoableOperation::DoInsertNode().
UINT32	AdjustAttributesForStroke (CCAttrMap *pAttrMap, SelObjPathListItem *pListItem=NULL)
	If we are doing combine shapes on a stroked shape then we need to make the following changes: 1) Do not keep the AttrStrokeType and VariableWidth around, this is because their effects have been achieved via the DoBecomeA so if we keep them then effectively we are stroking our final output twice. 2) Set line width to zero. Once again the line width effect has been extracted from the DoBecomeA 3) Use the current stroke colour for the new fill colour. 4) Ditch the stroke colour?
BOOL	BeginSlowJob ()
	Wrapper around BeginSlowJob() that sets up the hour glass counter correctly.
SelObjPathList *	GetFirstList ()
SelObjPathList *	GetLastList ()
SelObjPathList *	GetNextList (SelObjPathList *pItem)
ListRange *	CopyRange (Range *pRange)
	Copy the specified range of nodes.
Private Attributes
List	ListOfSelObjPathLists
ListRange *	pListOfResults
DocRect	OriginalBoundingRect
SelRange *	pSelRange
INT32	NumPaths
INT32	JobCount
INT32	NodeInsertCount
Node *	pContextNode
AttachNodeDirection	AttachDir

---

Detailed Description

Base class op that does all the shape combining ops, like add, subtract and intersect,etc.

Author:

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

Date:

11/1/95

Definition at line 232 of file combshps.h.

---

Constructor & Destructor Documentation

OpCombineShapes::OpCombineShapes (   )

Default constructor. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 167 of file combshps.cpp. { Reason = COMBINE_NONE; pSelRange = NULL; NumPaths = 0; JobCount = 0; pContextNode = NULL; pListOfResults = NULL; }

OpCombineShapes::~OpCombineShapes (   )

Default destructor - does nothing. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 193 of file combshps.cpp. { ListOfSelObjPathLists.DeleteAll(); if (pListOfResults) { delete pListOfResults; pListOfResults = NULL; }; }

---

Member Function Documentation

BOOL OpCombineShapes::AddOrMergePaths (  Path *  pPath1, Path *  pPath2 )  [private]

Helper function for DoAddShapes and AddPathsFromList. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 08/02/2005 Parameters: pPath1  - pointer to a Path [INPUTS] pPath2 - pointer to a Path Returns: TRUE if ok, FALSE if bother Definition at line 749 of file combshps.cpp. { BOOL ok = TRUE; // if num coords == 0, the path is effectively empty, so just copy this node path's path if (pPath1->GetNumCoords() == 0) ok = pPath1->MergeTwoPaths(*pPath2); else { // Otherwise actually 'add' the paths together, using ClipPathToPath ok = AddPaths(pPath1,pPath2); // If this fails, we can just merge the two paths together as this achieves the desired // silhouette effect if (!ok) ok = pPath1->MergeTwoPaths(*pPath2); } return(ok); }

BOOL OpCombineShapes::AddPaths (  Path *  pPath1, Path *  pPath2 )  [private]

This adds the two paths together using ClipPathToPath, storing the result in pPath1. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: pPath1  = ptr to first path, and also the place to store resultant path [INPUTS] pPath2 = ptr to second path, i.e. the path to add to pPath1 *pPath1  contains the result of adding the two paths (if TRUE returned). [OUTPUTS] Returns: TRUE if OK, FALSE if failed Errors: - See also: OpCombineShapes::AddPathsFromList() Definition at line 785 of file combshps.cpp. { ERROR2IF(pPath1 == NULL,FALSE,"pPath1 == NULL"); ERROR2IF(pPath2 == NULL,FALSE,"pPath2 == NULL"); // check for a zero-bounding box path DocRect dr = pPath2->GetBoundingRect(); if (dr.Width() <= 1 && dr.Height() <= 1) { ERROR3("We have a zero bounding rect path"); return FALSE; } Path StrokedPath2; if (!StrokedPath2.Initialise()) return FALSE; // is path 2 a line? if (pPath2->GetPathType() == PATHTYPE_LINE) { if (!StrokePathToPath(pPath2,&StrokedPath2)) return FALSE; } INT32 len = CombinePaths(CLIP_STYLE_ADD,pPath2,&StrokedPath2,pPath1,pPath1); return (len > 0); }

BOOL OpCombineShapes::AddPathsFromList (  Path *  pPath, SelObjPathList *  pSelObjPathList )  [private]

This adds all the paths in the list together to form a combined silhouette path of the selection. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: pPath  = ptr to path to place the result [INPUTS] pSelObjPathList = ptr to list of paths pPath  contains the union of all the paths in pSelObjPathList [OUTPUTS] Returns: TRUE if OK, FALSE if failed This can be thought of as a logical OR of the paths Returns: Errors: - See also: OpCombineShapes::Do() Definition at line 671 of file combshps.cpp. { // Check our input params ERROR3IF(pPath == NULL,"pPath == NULL"); ERROR3IF(pSelObjPathList == NULL,"pSelObjPathList== NULL"); if (pPath == NULL || pSelObjPathList == NULL) return FALSE; NodePath* pTempPath = new NodePath; if (pTempPath == NULL) return FALSE; if (!pTempPath->SetUpPath()) return FALSE; // Get the first path in this list SelObjPathListItem* pSelObjPathListItem = pSelObjPathList->GetFirstItem(); BOOL ok = TRUE; while (ok && pSelObjPathListItem != NULL) { // Get a pointer to the actual node path in this list item Path* pSrcPath = pSelObjPathListItem->GetPath(); if (pSrcPath != NULL) { // Add this path into the TempPath ok = AddOrMergePaths(&(pTempPath->InkPath), pSrcPath); // If the TempPath is now too large if (ok && pTempPath->InkPath.GetNumCoords() > AddPathGranularity) { // Combine the TempPath with the output path ok = AddOrMergePaths(pPath, &(pTempPath->InkPath)); // And clear the TempPath if (ok) ok = pTempPath->InkPath.ClearPath(FALSE); } if (ok) pSelObjPathList->SetProducedPaths(TRUE); } else { // What? No Src path? Surely not! ERROR3("pSrcPath == NULL"); ok = FALSE; } if (ok) ok = ::ContinueSlowJob(++JobCount); // Get the next item in the selected object path list. pSelObjPathListItem = pSelObjPathList->GetNextItem(pSelObjPathListItem); } // If the TempPath has anything in if (ok && pTempPath->InkPath.GetNumCoords() > 0) { // Combine the TempPath with the output path ok = AddOrMergePaths(pPath, &(pTempPath->InkPath)); } delete pTempPath; return (ok); }

UINT32 OpCombineShapes::AdjustAttributesForStroke (  CCAttrMap *  pAttrMap, SelObjPathListItem *  pListItem = NULL )  [private]

If we are doing combine shapes on a stroked shape then we need to make the following changes: 1) Do not keep the AttrStrokeType and VariableWidth around, this is because their effects have been achieved via the DoBecomeA so if we keep them then effectively we are stroking our final output twice. 2) Set line width to zero. Once again the line width effect has been extracted from the DoBecomeA 3) Use the current stroke colour for the new fill colour. 4) Ditch the stroke colour? Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 4/9/2000 Parameters: pAttrMap  - the attribute map that we are about to apply to our combined node [INPUTS] swaps  a few things around in the map [OUTPUTS] Returns: 0 - if we do not have an active stroke attribute (therefore do nothing) 1 - if we do have an active stroke and everything went well 2 - if we have an active stroke and something went wrong (e.g. out of memory) We must actually make new nodes for these attributes as changing the existing ones will mess up our undo. These attributes must be deleted after they are applied by calling DeleteExtraAttributesForStroke() Returns: Errors: - See also: - Notes: Phil, 16/11/2005 We know that we own the attributes referred to by the Atrtibute Map so we can party on them without worrying about affecting other data structures. This allows us to remove attributes from the map completely, leaving it in a consistent state. Definition at line 2135 of file combshps.cpp. { if (pAttrMap == NULL) return 0; // first see if we have an active stroke, if not we can just quit already AttrStrokeType* pStroke = NULL; pAttrMap->Lookup(CC_RUNTIME_CLASS(AttrStrokeType), (void*&)pStroke); if (pStroke == NULL || !pStroke->HasPathProcessor()) return 0; AttrVariableWidth* pVarWidth = NULL; pAttrMap->Lookup(CC_RUNTIME_CLASS(AttrVariableWidth), (void*&)pVarWidth); // CGS: we should only really continue IF we have an active value function! Otherwise, we seem to run // into problems when we have give new objects most recent attributes turned on .... if ((pVarWidth == NULL) || !pVarWidth->HasActiveValueFunction ()) return (0); // right so we want to set the line width to zero AttrLineWidth* pLineWidth = new AttrLineWidth; if (pLineWidth != NULL) { pAttrMap->RemoveAttribute(CC_RUNTIME_CLASS(AttrLineWidth)); pLineWidth->Value.LineWidth = 0; pAttrMap->SetAt(CC_RUNTIME_CLASS(AttrLineWidth), (void*)pLineWidth); } // now get the stroke colour and use it to make a fill colour AttrStrokeColour * pColour = NULL; // look up the stroke colour attribute pAttrMap->Lookup(CC_RUNTIME_CLASS(AttrStrokeColour), (void *&)pColour); // make a new flat fill attribute and apply this to the node if (pColour) { if (!pListItem || pListItem->GetStrokeCreatedPassbackPath ()) { StrokeColourAttribute * pAttrVal = (StrokeColourAttribute *)pColour->GetAttributeValue(); if (pAttrVal) { AttrFlatColourFill* pFill = new AttrFlatColourFill; if (pFill) { DocColour Col = pAttrVal->Colour; pFill->SetStartColour(&Col); // set back in the map pAttrMap->RemoveAttribute(CC_RUNTIME_CLASS(AttrFillGeometry)); pAttrMap->SetAt(CC_RUNTIME_CLASS(AttrFillGeometry), (void*)pFill); } else return 2; } } // now make a new stroke colour and set it transparent AttrStrokeColour* pNewStrokeCol = new AttrStrokeColour; if (pNewStrokeCol) { pNewStrokeCol->Value.Colour = DocColour(COLOUR_NONE); pAttrMap->RemoveAttribute(CC_RUNTIME_CLASS(AttrStrokeColour)); pAttrMap->SetAt(CC_RUNTIME_CLASS(AttrStrokeColour), (void*)pNewStrokeCol); } } // now remove the stroke and var width attributes, and any brushes whilst we're here pAttrMap->RemoveAttribute(CC_RUNTIME_CLASS(AttrVariableWidth)); pAttrMap->RemoveAttribute(CC_RUNTIME_CLASS(AttrStrokeType)); pAttrMap->RemoveAttribute(CC_RUNTIME_CLASS(AttrBrushType)); return 1; }

BOOL OpCombineShapes::ApplyAttributes (  NodeRenderableInk *  pSrcNode, NodeRenderableInk *  pDestNode, CCAttrMap *  pAttrMap, SelObjPathListItem *  pListItem = NULL )  [private]

This applies attrs pDestNode. If pAttrMap == NULL, the attrs applied to pSrcNode are applied to pDestNode, else the attrs in pAttrMap are applied. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: pSrcNode  = ptr to node to get attrs from [INPUTS] pDestNode = ptr to node to apply pSrcNode's attrs to pAttrMap = ptr to attr map (NULL means get attrs applied to pSrcNode) pListItem = so that the can control processing based upon the values of this -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed Errors: - See also: - Definition at line 2063 of file combshps.cpp. { ERROR3IF(pSrcNode == NULL,"pSrcNode == NULL"); ERROR3IF(pDestNode == NULL,"pDestNode == NULL"); if (pSrcNode == NULL || pDestNode == NULL) return FALSE; BOOL ok = TRUE; // Set to TRUE if we successfully apply attrs to pDestNode BOOL DeleteAttrs = FALSE; // TRUE if we need to delete attr map before returning if (pAttrMap == NULL) { // Find the currently applied attributes and make a local copy of the map (like most // passback functions do) CCAttrMap AppliedMap(30); ok = pSrcNode->FindAppliedAttributes(&AppliedMap); pAttrMap = AppliedMap.Copy(); DeleteAttrs = TRUE; } // if we have a stroked object we need to do some attribute juggling if (AdjustAttributesForStroke(pAttrMap, pListItem) == 2) return FALSE; // If all's OK, apply attrs to pDestNode ok = pDestNode->ApplyAttributes(pAttrMap,TRUE); // Delete the copied attr map if we have to if (DeleteAttrs) { pAttrMap->DeleteAttributes(); delete pAttrMap; } return ok; }

BOOL OpCombineShapes::ApplyEffects (  SelObjPathListItem *  pListItem, NodeRenderableInk *  pDestNode, NodeRenderableInk *  pParentEffect )  [private]

To delete the extra attributes we allocated in AdjustAttributesForStroke This applies attrs pDestNode. If pAttrMap == NULL, the attrs applied to pSrcNode are applied to pDestNode, else the attrs in pAttrMap are applied. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 04/02/2005 Parameters: pListItem  = so that the can control processing based upon the values of this [INPUTS] pDestNode = ptr to node to apply pSrcNode's attrs to -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed Errors: - See also: - Definition at line 2297 of file combshps.cpp. { BOOL ok = TRUE; PORTNOTE("other", "Removed OpCombineShapes::ApplyEffects"); #ifndef EXCLUDE_FROM_XARALX ERROR3IF(pListItem == NULL, "pListItem == NULL"); ERROR3IF(pDestNode == NULL, "pDestNode == NULL"); NodeRenderableInk* pSrcNode = pListItem->GetCreatedByNode(); ERROR3IF(pSrcNode == NULL, "pSrcNode == NULL"); // Get the effect stack for the object which produced this path (pSrcNode) // If the source node had effects applied to it // And that stack is different than the stack above the context node // Then we must copy the effect stack onto the destination node ListRange* pStack = pListItem->GetEffectStack(); Node* pEffect = NULL; if (pStack) pEffect = pStack->FindFirst(); if (pEffect) { if (pParentEffect==NULL || pParentEffect!=pEffect) { // We need to copy the effect stack onto this object OpLiveEffect::DoCopyEffectsStack(this, pDestNode, pStack, GetWorkingDoc(), GetWorkingDoc()); } } #endif return ok; }

BOOL OpCombineShapes::BeginSlowJob (   )  [private]

Wrapper around BeginSlowJob() that sets up the hour glass counter correctly. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 25/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK Errors: - See also: - Definition at line 382 of file combshps.cpp. { NumPaths = 0; JobCount = 0; SelObjPathList* pList = GetFirstList(); while (pList != NULL) { NumPaths += pList->GetCount(); pList = GetNextList(pList); } INT32 SlowJobCount = NumPaths; if (Reason == COMBINE_SLICE) SlowJobCount *= 2; String_64 Str(_R(IDS_COMBINE_SLOWJOB)); return (::BeginSlowJob(SlowJobCount,FALSE,&Str)); }

BOOL OpCombineShapes::CombinePaths (  ClipStyle  Style, Path *  pClipPath, Path *  pStrokedClipPath, Path *  pSrcPath, Path *  pDestPath )  [private]

This combines pClipPath from pSrcPath using ClipPathToPath, storing the result in pDestPath. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: Style  = High level style of clipping [INPUTS] pClipPath = ptr to the path to combine with pSrcPath pStrokedClipPath = ptr to stroked version of pClipPath ONLY if pClipPath is a line pSrcPath = ptr to path that will be combined with pClipPath pDestPath = ptr to path to place the result in *pDestPath  contains the result of combining pCliPath with pSrcPath(if TRUE returned). [OUTPUTS] Returns: TRUE if OK, FALSE if failed Errors: - See also: OpCombineShapes::CombinePathsFromList() Definition at line 1136 of file combshps.cpp. { // Check those entry params ERROR2IF(pClipPath == NULL,FALSE,"pClipPath == NULL"); ERROR2IF(pStrokedClipPath == NULL,FALSE,"pStrokedClipPath == NULL"); ERROR2IF(pSrcPath == NULL,FALSE,"pSrcPath == NULL"); ERROR2IF(pDestPath == NULL,FALSE,"pDestPath == NULL"); UINT32 Flags = 0; // Flags passed to ClipPathToPath() BOOL Clip = TRUE; // If this is TRUE, ClipPathToPath() is called at the end of this func INT32 len = -1; // This is the length of the path produced by ClipPathToPath BOOL SrcIsLine = (pSrcPath->GetPathType() == PATHTYPE_LINE); // TRUE if src path is a line BOOL ClipIsLine = (pClipPath->GetPathType() == PATHTYPE_LINE); // TRUE if clip path is a line Path DestPath; // Used when using a line to slice the source path up // If the clip path is a line and the op is slice, try and make a closed path using pClipPath // and the bounding rect of pSrcPath if (ClipIsLine && Reason == COMBINE_SLICE) { if (DestPath.Initialise() && ConvertClipLineToShape(pClipPath,pSrcPath,&DestPath)) { // If successfully created a closed path, then pretend func was entered with the new path // by pointing pClipPath to it. Also the clip path is no longer a line pClipPath = &DestPath; ClipIsLine = FALSE; } } switch (Style) { case CLIP_STYLE_SUBTRACT: Flags = 1; // 1 is Source AND NOT Clip if (SrcIsLine) Flags |= CLIPPING_IS_STROKED; // If source is a line, set the stroked flag if (ClipIsLine) { // If slicing with a line, don't bother doing the subtraction stage if (Reason == COMBINE_SLICE) Clip = FALSE; else // Otherwise subtract with a stroked version of the line. // If the user's mad enough to try it, then we'd better try our best { pClipPath = pStrokedClipPath; Flags |= CLIPPING_CLIP_WINDING; } } break; case CLIP_STYLE_INTERSECT: // If src is a line, Flags = 0 | stroked flag, else Flags = Source AND Clip if (SrcIsLine) Flags = CLIPPING_IS_STROKED; else Flags = 2; if (ClipIsLine) { // If slicing with a line, don't bother doing the intersection stage if (Reason == COMBINE_SLICE) Clip = FALSE; else // Otherwise intersect with a stroked version of the line. // If the user's mad enough to try it, then we'd better try our best { pClipPath = pStrokedClipPath; Flags |= CLIPPING_CLIP_WINDING; } } break; case CLIP_STYLE_ADD: Flags = 7; // 7 is Source OR Clip // convert lines into paths by stroking them // Also we must use a Non-zero winding rule to avoid cross segment lines taking effect if (SrcIsLine) { StrokePathToPath(pSrcPath,pSrcPath); Flags |= CLIPPING_SOURCE_WINDING; } if (ClipIsLine) { pClipPath = pStrokedClipPath; Flags |= CLIPPING_CLIP_WINDING; } break; } if (Clip) { // Clip those paths together // Mark Howitt 31/10/00 // I`ve removed the ClipPathToPathWithAutoFlatness function and replaced it with // the function that returns you a flatness value to use with the ClipPath function double ClippingFlatness = pClipPath->CalculateFlatnessValueFromPath(750.0, 2.0, 375.0); double SourceFlatness = pSrcPath->CalculateFlatnessValueFromPath(750.0, 2.0, 375.0); len = pClipPath->ClipPathToPath(*pSrcPath, pDestPath, Flags, DefaultTolerance, ClippingFlatness, SourceFlatness); /* // show debugging info about the path we have clipped INT32 NumCoords = pDestPath->GetNumCoords(); PathVerb * pVerbs = pDestPath->GetVerbArray(); DocCoord * pCoord = pDestPath->GetCoordArray(); for (INT32 i = 0; i < NumCoords; i++) { if (pVerbs[i] == PT_MOVETO) TRACE( _T("MOVE TO ")); else if (pVerbs[i] == PT_BEZIERTO) TRACE( _T("BEZIER TO ")); else if (pVerbs[i] == PT_LINETO) TRACE( _T("LINE TO ")); TRACE( _T("%d, %d\n"), pCoord[i].x, pCoord[i].y); } TRACE( _T("end line\n")); */ } return (len > 0); }

BOOL OpCombineShapes::CombinePathsFromList (  ClipStyle  Style, Path *  pClipPath, Path *  pStrokedClipPath, SelObjPathList *  pSelObjPathList, BOOL  bCombineEffectBitmaps = TRUE )  [private]

This combines pClipPath with all the paths in pSelObjPathList. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: Style  = High level style of clipping [INPUTS] pClipPath = ptr to path to combine with the paths in pSelObjPathList pStrokedClipPath= ptr to stroked version of pClipPath ONLY if pClipPath is a line pSelObjPathList = ptr to list of paths -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed For each path it tries to combine it with pClipPath. A new NodePath is generated and placed in the tree at the place the selected object lives. Returns: Errors: - See also: OpCombineShapes::DoCombineShapes() Definition at line 1009 of file combshps.cpp. { // Check our input params ERROR3IF(pClipPath == NULL,"pClipPath == NULL"); ERROR3IF(pSelObjPathList == NULL,"pSelObjPathList == NULL"); if (pClipPath == NULL || pSelObjPathList == NULL) return FALSE; // Get the first path in this list SelObjPathListItem* pFirstItem = pSelObjPathList->GetFirstItem(); SelObjPathListItem* pSelObjPathListItem = pFirstItem; BOOL ok = TRUE; while (ok && pSelObjPathListItem != NULL) { // Get a pointer to the actual node path in this list item NodePath* pNodePath = pSelObjPathListItem->GetNodePath(); NodePath* pNewNodePath = new NodePath; NodeRenderableInk* pCreatedByNode = pSelObjPathListItem->GetCreatedByNode(); if (pNodePath != NULL && pNewNodePath != NULL && pNewNodePath->SetUpPath()) { //pNewNodePath->InkPath.Initialise(pNodePath->InkPath.GetNumCoords(), 64); //if (pNewNodePath->InkPath.CopyPathDataFrom(&(pNodePath->InkPath))) if (CombinePaths(Style, pClipPath, pStrokedClipPath, &(pNodePath->InkPath), &(pNewNodePath->InkPath))) { if (bCombineEffectBitmaps) ok = DoInsertNewNode(pNewNodePath); else { if (pSelObjPathListItem==pFirstItem) { // The first path produced can live where it's originating node lived // inside whatever Effect stack was in place ok = UndoableOperation::DoInsertNewNode(pNewNodePath, pNodePath, NEXT, TRUE, FALSE, FALSE, TRUE); } else { // If more than one path is produced under an Effect node // Then we must make a new Effect Stack for it // // BUT NOTE! I don't think any multiple set of nodes are produced outside // a group at the moment - so the effect applciation code found here // has never yet been tested! Node* pInsertNode = pNodePath; ListRange* pStack = EffectsStack::GetEffectsStackFromNode(pNodePath, FALSE, TRUE, TRUE); // Include locked effects if (pStack) pInsertNode = pStack->FindLast(); ok = UndoableOperation::DoInsertNewNode(pNewNodePath, pInsertNode, NEXT, TRUE, FALSE, FALSE, TRUE); pInsertNode = pNewNodePath; delete pStack; // Now copy the effects stack for this new child... if (ok) ok = ApplyEffects(pSelObjPathListItem, pNewNodePath, NULL); } // Select the resulting path now if (ok && pCreatedByNode->IsSelected()) pNewNodePath->Select(FALSE); if (ok) { pListOfResults->AddNode(pNewNodePath); NodeInsertCount++; } } // Find out who created the path, and apply its attrs to the new NodePath CCAttrMap* pAttrMap = pSelObjPathListItem->GetAttrMap(); if (ok) ok = ApplyAttributes(pCreatedByNode, pNewNodePath, pAttrMap, pSelObjPathListItem); // Set up a set of default path flags to enable the bezier tool to edit this node if (ok) pNewNodePath->InkPath.InitialiseFlags(); if (ok) pSelObjPathList->SetProducedPaths(TRUE); } else { if (pNewNodePath!=NULL) { delete pNewNodePath; pNewNodePath = NULL; } // Don't worry if the actual combine fails. We'll just not put anything in the tree // because, hmmm, I wonder.... } } else { // What? Error? Surely not! ERROR3("pNodePath == NULL || pNewNodePath == NULL || !pNewNodePath->SetUpPath())"); ok = FALSE; if (pNewNodePath!=NULL) { delete pNewNodePath; pNewNodePath = NULL; } } if (ok) ok = ::ContinueSlowJob(++JobCount); // Get the next item in the selected object path list. pSelObjPathListItem = pSelObjPathList->GetNextItem(pSelObjPathListItem); } return (ok); }

BOOL OpCombineShapes::ConvertClipLineToShape (  Path *  pClipPath, Path *  pSrcPath, Path *  pDestPath )  [private]

Only call this if pClipPath is a line. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: pClipPath  = ptr to the path to convert [INPUTS] pSrcPath = ptr to path that will be combined with pClipPath pDestPath = ptr to path to place the result in *pDestPath  contains the result of converting pCliPath with regards to pSrcPath (if TRUE returned). [OUTPUTS] Returns: TRUE if OK, FALSE if failed This creates a shape out of pClipPath such that the path from the start point of pClipPath to the end point of pClipPath does NOT intersect with pSrcPath. It can only do this if the start and end point of pClipPath are outside the coord bounds of pSrcPath. If either pClipPath ends are inside pSrcPath's bounds, FALSE is returned. The shape is created by tacking on parts of the bounding rectangle to pClipPath, then closing the resultant path. Note: pDestPath must not point to pClipPath OR pSrcPath (i.e. you'll need three paths) Returns: Errors: - See also: OpCombineShapes::CombinePaths() Definition at line 1272 of file combshps.cpp. { // Check for stupid entry parama ERROR2IF(pClipPath == NULL,FALSE,"pClipPath == NULL"); ERROR2IF(pSrcPath == NULL,FALSE,"pSrcPath == NULL"); ERROR2IF(pDestPath == NULL,FALSE,"pClipPath == NULL"); // Get the coord bounds of the source path. Inflate it slightly so that we don't run into tolerance // problems when calling ClipPathToPath() //DocRect Rect = GetBoundingRect(pSrcPath); // we must be consistant as to the rect we use to get a consistant shape // otherwise some items will all get cut along the line but it is luck // which side of the cut the shapes appear in (sjk 15/11/00) // DocRect Rect = GetApplication()->FindSelection()->GetBoundingRect(); // use a consistant rect for all the shapes DocRect Rect = OriginalBoundingRect; // use a consistant rect for all the shapes Rect.Inflate((DefaultTolerance*2)+10); INT32 NumClipCoords = pClipPath->GetNumCoords(); DocCoord* pClipCoords = pClipPath->GetCoordArray(); DocCoord ClipStart = pClipCoords[0]; // Start point of pClipPath DocCoord ClipEnd = pClipCoords[NumClipCoords-1]; // End point of pClipPath DocCoord ExtraClipStart= pClipCoords[0]; // Start point of pClipPath DocCoord ExtraClipEnd = pClipCoords[NumClipCoords-1]; // End point of pClipPath BOOL NeedExtraClipStart = FALSE; BOOL NeedExtraClipEnd = FALSE; Path FlatPath; // BOOL SetFlatPath = FALSE; // double FLATTNESS = 1024; // arbitry figure of how flattened the curve will be // only used for test for extra cuts // We have to choose a corner point of the bounding rect for both the start and end points // of pClipPath. DocCoord ClipCornerStart,ClipCornerEnd; DocCoord mid = Rect.Centre(); if (ClipStart.x < mid.x) ClipCornerStart.x = Rect.lo.x; else ClipCornerStart.x = Rect.hi.x; if (ClipStart.y < mid.y) ClipCornerStart.y = Rect.lo.y; else ClipCornerStart.y = Rect.hi.y; if (ClipEnd.x < mid.x) ClipCornerEnd.x = Rect.lo.x; else ClipCornerEnd.x = Rect.hi.x; if (ClipEnd.y < mid.y) ClipCornerEnd.y = Rect.lo.y; else ClipCornerEnd.y = Rect.hi.y; // start clip point in the rect? // move it to the nearest edge if (Rect.ContainsCoord(ClipStart)) { NeedExtraClipStart = TRUE; DocCoord v = ClipStart - pClipCoords[1]; INT32 giveup = 250; // number of times to try // extrapperlate the last part of the line until it breaks out of the bounding rect // give up if it fails to break out after an arbitry number of goes while (Rect.ContainsCoord(ExtraClipStart) && giveup > 0) { ExtraClipStart.x += v.x * 10; ExtraClipStart.y += v.y * 10; giveup--; } // failled to leave the shape if (giveup == 0) return FALSE; // moving the start may change which is the nearest corner to go for DocCoord mid = Rect.Centre(); if (ExtraClipStart.x < mid.x) ClipCornerStart.x = Rect.lo.x; else ClipCornerStart.x = Rect.hi.x; if (ExtraClipStart.y < mid.y) ClipCornerStart.y = Rect.lo.y; else ClipCornerStart.y = Rect.hi.y; } // perform all the same calcualtions for the other end of the clip line if (Rect.ContainsCoord(ClipEnd)) { NeedExtraClipEnd = TRUE; DocCoord v = ClipEnd - pClipCoords[NumClipCoords-2]; INT32 giveup = 250; // number of times to try // extrapperlate the last part of the line until it breaks out of the bounding rect // give up if it fails to break out after an arbitry number of goes while (Rect.ContainsCoord(ExtraClipEnd) && giveup > 0) { ExtraClipEnd.x += v.x * 10; ExtraClipEnd.y += v.y * 10; giveup--; } // failled to leave the shape if (giveup == 0) return FALSE; // moving the end may change which is the nearest corner to go for DocCoord mid = Rect.Centre(); if (ExtraClipEnd.x < mid.x) ClipCornerEnd.x = Rect.lo.x; else ClipCornerEnd.x = Rect.hi.x; if (ExtraClipEnd.y < mid.y) ClipCornerEnd.y = Rect.lo.y; else ClipCornerEnd.y = Rect.hi.y; } // We now have two sensible corners of Rect to connect pClipPath's end points to // and if required also optimal points on this Rect boundry to that are // in direct line with the ends of the cutting line // Firstly, copy pClipPath to pDestPath pDestPath->ClearPath(FALSE); if (!pDestPath->MergeTwoPaths(*pClipPath)) return FALSE; // add on an extra end part to make this end of the clip path outside the bounds of the selection if (NeedExtraClipEnd) { if (!pDestPath->AddLineTo(ExtraClipEnd)) return FALSE; } // Connect the end of the line to the end corner point if (!pDestPath->AddLineTo(ClipCornerEnd)) return FALSE; // add in the corner nearest the end // If end corner x != start corner x, we need to connect these up if (ClipCornerEnd.x != ClipCornerStart.x) { ClipCornerEnd.x = ClipCornerStart.x; if (!pDestPath->AddLineTo(ClipCornerEnd)) return FALSE; } // if the start and end corners are opposing we need to use an intermediate corner to avoid the selection // If end corner y != start corner y, we need to connect these up if (ClipCornerEnd.y != ClipCornerStart.y) { ClipCornerEnd.y = ClipCornerStart.y; if (!pDestPath->AddLineTo(ClipCornerEnd)) return FALSE; } // add in the corner nearest the start // add on an extra end part to make this end of the clip path outside the bounds of the selection if (NeedExtraClipStart) { if (!pDestPath->AddLineTo(ExtraClipStart)) return FALSE; } // Finally, close the path up by connecting the start corner point to the start of the line // and setting PT_CLOSEFIGURE in the last verb if (!pDestPath->AddLineTo(ClipStart)) return FALSE; INT32 n = pDestPath->GetNumCoords(); PathVerb* pVerbs = pDestPath->GetVerbArray(); pVerbs[n-1] |= PT_CLOSEFIGURE; return TRUE; }

BOOL OpCombineShapes::ConvertToShapes (  Range *  pRange, BOOL  bCombineEffectBitmaps )  [private]

This subtracts all the shapes in all the lists from all the lines in all the lists This subtracts all the shapes in all the lists from pLine This subtracts all the shapes in pSelObjPathList from pLine This generates the data structure that holds all the paths generated by the selected objects. NOTE! Pointers to paths in the tree are stored in the lists (unlike CreateSelObjPathLists). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 06/04/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed This consists of a top level list than contains a series of secondary lists of paths. There is one instance of a secondary list per selected object. List Of Selected Object Path lists List of paths made by first selected object SelObjPathListItem SelObjPathListItem SelObjPathListItem ... List of paths made by second selected object ... Returns: Errors: - See also: CreateSelObjPathList() Definition at line 1642 of file combshps.cpp. { CombineBecomeA BecomePath(BECOMEA_REPLACE, this, NULL, NULL, FALSE); BecomePath.SetInsertComplexBlendStepsAsPaths (TRUE); // compound nodes MUST be inserted as paths! BecomePath.SetResultsStayInPlace(!bCombineEffectBitmaps); // Only stay in place if notcaptruing effect bitmaps Node* pNode = pRange->FindFirst(FALSE); Node* pNextNode = NULL; BOOL ok = TRUE; while (pNode!=NULL && ok) { pNextNode = pRange->FindNext(pNode, FALSE); // Make a path list for this selected object if it can become a NodePath SelObjPathList* pSelObjPathList = new SelObjPathList(pNode); ok = (pSelObjPathList!=NULL); if (ok) { ListOfSelObjPathLists.AddTail(pSelObjPathList); // --- This code ripped from CreateSelObjPathList - looks suspect! --- // Check to see if this is the Top most visible object. This is used by the // Cached Compound Nodes to help determine whether or not to use the Cached nodes or BMP! BOOL IsTopObject = (pNextNode == NULL); // --- ! --- if (pNode->CanBecomeA(&BecomePath)) ok = CreateSelObjPathList(pNode, pSelObjPathList, IsTopObject, bCombineEffectBitmaps, BECOMEA_REPLACE); // Tidy up if things have gone wrong if (!ok) { ListOfSelObjPathLists.RemoveTail(); delete pSelObjPathList; } if (pNode->IsAnObject()) ((NodeRenderableInk*)pNode)->ReleaseCached(); } pNode = pNextNode; if (ok) ok = ::ContinueSlowJob(++JobCount); } return ok; }

ListRange * OpCombineShapes::CopyRange (  Range *  pRange  )  [private]

Copy the specified range of nodes. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 06/05/2005 Parameters: pRange  = ptr to the range to copy [INPUTS] -  [OUTPUTS] Returns: ptr to ListRange if OK, NULL otherwise See also: - Definition at line 2501 of file combshps.cpp. { BOOL ok = TRUE; Node* pNode = pRange->FindFirst(); ListRange* pNewRange = new ListRange(); while (pNode && ok && pNewRange) { Node* pNext = pRange->FindNext(pNode); // Make a copy of the current node and all its children Node* TheCopy; BOOL CopiedOK; CALL_WITH_FAIL(pNode->NodeCopy(&TheCopy), this, CopiedOK); if (CopiedOK) { // make sure that it is bounded ERROR2IF(!TheCopy->IsBounded(), FALSE, "Object being copied is not a NodeRenderableBounded"); NodeRenderableBounded* BoundCopy = (NodeRenderableBounded*)TheCopy; // Insert the copied node next to it's originator ok = UndoableOperation::DoInsertNewNode(BoundCopy, pNode, NEXT, FALSE, // Don't Invalidate region FALSE, // Don't Clear the selections FALSE, // Don't select new node FALSE // Don't normalise attributes ); if (!ok) { // Failed, so tidy up before returning TheCopy->CascadeDelete(); delete TheCopy; } else { // Record the copied node in the ListRange pNewRange->AddNode(TheCopy); // Call PostDuplicate on the copied node and all it's children Node* pCurrent = BoundCopy->FindFirstDepthFirst(); while (pCurrent!=NULL && ok) { ok = pCurrent->PostDuplicate(this); pCurrent = pCurrent->FindNextDepthFirst(BoundCopy); } } } pNode = pNext; } if (!ok) { delete pNewRange; pNewRange = NULL; } return pNewRange; }

BOOL OpCombineShapes::CreateSelObjPathList (  Node *  pNode, SelObjPathList *  pSelObjPathList, BOOL  IsFirstNode = TRUE, BOOL  bCombineEffectBitmaps = TRUE, BecomeAReason  reason = BECOMEA_PASSBACK )  [private]

This generates the data structure that holds all the paths generated by a given selected object. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: pNode  = ptr to the node that will generate one or more NodePaths [INPUTS] pSelObjPathList = the list to add the paths to using SelObjPathListItems -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed It uses a derived BecomeA class to receive the paths and generate SelObjPathListItems to add to pSelObjPathList Returns: Errors: - See also: CreateSelObjPathLists() Definition at line 1806 of file combshps.cpp. { ERROR2IF(pNode == NULL || pSelObjPathList == NULL,FALSE,"One or more params are NULL"); // Set up a BecomeA derived object, so that we can receive all the paths generated by pNode. CombineBecomeA ParamBecomeA(reason, this,pSelObjPathList,pNode,IsFirstNode); ParamBecomeA.SetInsertComplexBlendStepsAsPaths(TRUE); // compound nodes MUST be inserted as paths! ParamBecomeA.SetResultsStayInPlace(!bCombineEffectBitmaps); // if we have a brush attribute we have to do it independently (ugh) AttrBrushType* pBrush = NULL; ((NodeRenderableInk*)pNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrBrushType), (NodeAttribute **)&pBrush); BOOL gotAValidBrush = FALSE; if (pBrush != NULL && pBrush->GetBrushHandle() != BrushHandle_NoBrush) { gotAValidBrush = TRUE; BOOL useBrush = FALSE; // CGS: decide whether to use the brush for DoBecomeA or pNode .... if (Reason == COMBINE_ADD) { useBrush = TRUE; } /*else // put this back in if you want the slicing of lines to be sliced accurately in two. // if you want two new lines with brushes applied, leave like this { if (IS_A (pNode, NodePath)) { NodePath* pPath = (NodePath*) pNode; if (!pPath->InkPath.IsClosed ()) { useBrush = TRUE; // its a nodepath thats filled } } }*/ if (useBrush) { return (pBrush->DoBecomeA(&ParamBecomeA, (NodeRenderableInk*)pNode)); } } // if we haven't got a brush then see if we have a stroke BOOL ok = TRUE; AttrStrokeType* pStroke = NULL; ((NodeRenderableInk*)pNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrStrokeType), (NodeAttribute**)&pStroke); AttrVariableWidth* pVarWidth = NULL; ((NodeRenderableInk*)pNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrVariableWidth), (NodeAttribute**)&pVarWidth); if (pStroke && pStroke->HasPathProcessor() && pVarWidth && pVarWidth->HasActiveValueFunction()) { if (!gotAValidBrush) { // Convert stroke to paths first, allow it to place any nodes it creates // after the original but without deleting the original if (pStroke) { ParamBecomeA.SetSecondary(); // Tell the pathprocessor that it doesn't own the node ok = pStroke->DoBecomeA(&ParamBecomeA, pNode); ParamBecomeA.SetSecondary(FALSE); } // Now convert the node to paths, placing nodes after the original (before stroke paths) // and deleting the original if (ok) ok = pNode->DoBecomeA(&ParamBecomeA); // Attributes will be shuffled return ok; } else { // We've got a brush and a stroke on the same node! // The brush already knows about the stroke, so let that handle it .... // // Convert stroke to paths first, allow it to place any nodes it creates // after the original but without deleting the original if (pBrush) { ParamBecomeA.SetSecondary(); // Tell the pathprocessor that it doesn't own the node ok = pBrush->DoBecomeA(&ParamBecomeA, (NodeRenderableInk*)pNode); ParamBecomeA.SetSecondary(FALSE); } // Now convert the node to paths, placing nodes after the original (before stroke paths) // and deleting the original if (ok) ok = pNode->DoBecomeA(&ParamBecomeA); // Attributes will be shuffled return ok; } } // Get pNode to generate its paths for us return (pNode->DoBecomeA(&ParamBecomeA)); }

BOOL OpCombineShapes::CreateSelObjPathLists (  BOOL  bCombineEffectBitmaps  )  [private]

This generates the data structure that holds all the paths generated by the selected objects. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed This consists of a top level list than contains a series of secondary lists of paths. There is one instance of a secondary list per selected object. List Of Selected Object Path lists List of paths made by first selected object SelObjPathListItem SelObjPathListItem SelObjPathListItem ... List of paths made by second selected object ... Returns: Errors: - See also: CreateSelObjPathList() Definition at line 1718 of file combshps.cpp. { ERROR2IF(pSelRange == NULL,FALSE,"pSelRange == NULL"); Node* pSelNode = pSelRange->FindFirst(); UINT32 Count = 0; // Used for a check made at end of routine BOOL ok = TRUE; BOOL IsTopObject = TRUE; ::BeginSlowJob(); BecomeA BecomePath(BECOMEA_REPLACE, CC_RUNTIME_CLASS(NodePath)); BecomePath.SetResultsStayInPlace(!bCombineEffectBitmaps); while (ok && pSelNode != NULL) { if (pSelNode->CanBecomeA(&BecomePath)) { Count++; // Count num objs that can become a NodePath // Make a path list for this selected object if it can become a NodePath SelObjPathList* pSelObjPathList = new SelObjPathList(pSelNode); if (pSelObjPathList != NULL) { // Check to see if this is the Top most visable object. This is used by the // Cached Compound Nodes to help determine wether or not to use the Cached nodes or BMP! IsTopObject = (pSelRange->FindNext(pSelNode) == NULL); // Get the selected object to create the actual NodePath objects // and if successful, stuff the list on our list of sel obj path lists if (CreateSelObjPathList(pSelNode, pSelObjPathList, IsTopObject, bCombineEffectBitmaps)) { ListOfSelObjPathLists.AddTail(pSelObjPathList); } else { ok = FALSE; } } else ok = FALSE; } if (ok) ok = ::ContinueSlowJob(++JobCount); // Get the next selected object pSelNode = pSelRange->FindNext(pSelNode); } ::EndSlowJob(); if (ok) { UINT32 MinCount = 2; if (Reason == COMBINE_ADD) MinCount = 1; if (Count < MinCount) { ERROR3_PF(("Less than %d of the selected objects could become paths",MinCount)); return FALSE; } } return ok; }

void OpCombineShapes::Do (  OpDescriptor *   )  [virtual]

This is it! The routine that gets all the hard work underway. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - It acts upon the value in member var 'Reason', performing the shape-combining op specified by that value Returns: Errors: - See also: - Reimplemented from Operation. Definition at line 419 of file combshps.cpp. { BeginSlowJob(); DoStartSelOp(TRUE, FALSE); BOOL ok = TRUE; NodeInsertCount = 0; pListOfResults = new ListRange(); BOOL bCombineEffectBitmaps = CombineEffectBitmaps; // If shift key is pressed toggle the effect handling method ClickModifiers ClickMods = ClickModifiers::GetClickModifiers(); if (ClickMods.Adjust) bCombineEffectBitmaps = !bCombineEffectBitmaps; // --------------------------------------------------------- // Phil's new version: Scan the selection and call DoBecomeA once only! // // Convert all shapes in the selection in-place into paths. // NOTE! this allows all compound nodes to become groups in place // (which doesn't happen with the passback method). This is important // for retaining the tree structure that the paths are found in so that // paths remain in place inside groups and effects subtrees. // pSelRange = GetApplication()->FindSelection(); Range OldRange(*pSelRange); RangeControl rg = OldRange.GetRangeControlFlags(); rg.PromoteToParent = TRUE; OldRange.SetRangeControl(rg); ::BeginSlowJob(); switch (Reason) { // act upon the reason case COMBINE_ADD: ok = ConvertToShapes(&OldRange, bCombineEffectBitmaps); if (ok) ok = DoAddShapes(); if (ok && NodeInsertCount==0) {ok=FALSE; InformWarning(_R(IDS_COMBINE_NORESULT));} if (ok) ok = DoHideListedNodes(bCombineEffectBitmaps); // if (ok) ok = DoSelectResultNodes(bCombineEffectBitmaps); break; case COMBINE_SUBTRACT: ok = ConvertToShapes(&OldRange, bCombineEffectBitmaps); if (ok) ok = DoCombineShapes(CLIP_STYLE_SUBTRACT, bCombineEffectBitmaps); if (ok && NodeInsertCount==0) {ok=FALSE; InformWarning(_R(IDS_COMBINE_NORESULT));} if (ok) ok = DoHideListedNodes(bCombineEffectBitmaps); // if (ok) ok = DoSelectResultNodes(bCombineEffectBitmaps); break; case COMBINE_INTERSECT: ok = ConvertToShapes(&OldRange, bCombineEffectBitmaps); if (ok) ok = DoCombineShapes(CLIP_STYLE_INTERSECT, bCombineEffectBitmaps); if (ok && NodeInsertCount==0) {ok=FALSE; InformWarning(_R(IDS_COMBINE_NORESULT));} if (ok) ok = DoHideListedNodes(bCombineEffectBitmaps); // if (ok) ok = DoSelectResultNodes(bCombineEffectBitmaps); break; case COMBINE_SLICE: { // Slice = Subtract + Intersect // Make a copy of the selection before we do anything else Range* pNewRange = CopyRange(&OldRange); OriginalBoundingRect = pSelRange->GetBoundingRect(TRUE); // Use PromoteToParent to get TRUE bounds! // Subtract on the original selection ok = ConvertToShapes(&OldRange, bCombineEffectBitmaps); if (ok) ok = DoCombineShapes(CLIP_STYLE_SUBTRACT, bCombineEffectBitmaps); if (ok) ok = DoHideListedNodes(bCombineEffectBitmaps); // Have to delete lists because they are global! Argh! ListOfSelObjPathLists.DeleteAll(); pListOfResults->Clear(); // Intersect on the copy if (ok) ok = ConvertToShapes(pNewRange, bCombineEffectBitmaps); if (ok) ok = DoCombineShapes(CLIP_STYLE_INTERSECT, bCombineEffectBitmaps); if (ok) ok = DoHideListedNodes(bCombineEffectBitmaps); if (ok && NodeInsertCount==0) {ok=FALSE; InformWarning(_R(IDS_COMBINE_SLICE_NORESULT));} // if (ok) ok = DoSelectResultNodes(bCombineEffectBitmaps); delete pNewRange; pNewRange = NULL; } break; default: ERROR3_PF(("Unknown combine reason : %d",Reason)); ok = FALSE; break; } ::EndSlowJob(); if (!ok) { FailAndExecute(); // Get ptr to selected doc Document* pDoc = Document::GetSelected(); Spread* pSpread = Document::GetSelectedSpread(); // If there's a selected docview, redraw the selection if (pDoc != NULL && pSelRange != NULL && pSpread != NULL) pDoc->ForceRedraw(pSpread, pSelRange->GetBlobBoundingRect()); } else pSelRange->Update(TRUE); // Destroy our lists of selected object paths ListOfSelObjPathLists.DeleteAll(); if (pListOfResults) { delete pListOfResults; pListOfResults = NULL; }; GetApplication()->UpdateSelection(); // ::EndSlowJob(); End(); }

BOOL OpCombineShapes::DoAddShapes (   )  [private]

This adds all the paths together to form a combined silhouette path of the selection. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed This can be thought of as a logical OR of the paths Returns: Errors: - See also: OpCombineShapes::Do() Definition at line 565 of file combshps.cpp. { // We'll need a new NodePath to put in the tree NodePath* pNodePath = new NodePath; // If we have trouble setting up the NodePath, return FALSE if (pNodePath == NULL) return FALSE; if (!pNodePath->SetUpPath()) return FALSE; // if (!SubtractAllShapesFromAllLines()) return FALSE; // Get the list of paths produced by the first selected object SelObjPathList* pSelObjPathList = GetFirstList(); // This algorithm was very inefficient for large numbers of nodes // as it adds each node to the output path in turn. As the output path // grows it takes longer and longer to add each successive object. // To avoid this we add each path to a temporary path and when // it grows too large we add the temporary path into the output path // and clear the temporary one. NodePath* pTempPath = new NodePath; if (pTempPath == NULL) return FALSE; if (!pTempPath->SetUpPath()) return FALSE; while (pSelObjPathList != NULL) { // Add all the paths in this list to the path inside pNodePath if (!AddPathsFromList(&(pTempPath->InkPath),pSelObjPathList)) return FALSE; if (pTempPath->InkPath.GetNumCoords() > AddPathGranularity) { // Combine the TempPath with the output path if (!AddOrMergePaths(&(pNodePath->InkPath), &(pTempPath->InkPath))) return(FALSE); // And clear out the TempPath if (!pTempPath->InkPath.ClearPath(FALSE)) return(FALSE); } // Get the next list of paths generated by the next selected object pSelObjPathList = GetNextList(pSelObjPathList); } // If the TempPath has anything in if (pTempPath->InkPath.GetNumCoords() > 0) { // Combine the TempPath with the output path if (!AddOrMergePaths(&(pNodePath->InkPath), &(pTempPath->InkPath))) return(FALSE); } delete pTempPath; // We have successfully added all the paths together to form the union inside pNodePath // Find the last path item in the last list (i.e. the top-most path in the selection) pSelObjPathList = GetLastList(); SelObjPathListItem* pSelObjPathListItem = pSelObjPathList->GetLastItem(); NodeRenderableInk* pCreatedByNode = pSelObjPathListItem->GetCreatedByNode(); // Get ptr to last selected object because that is where we're going to put the new node path // pContextNode = pSelRange->FindLast(); pContextNode = pSelObjPathListItem->GetNodePath(); if (pContextNode==NULL) pContextNode = pCreatedByNode; AttachDir = NEXT; if (!DoInsertNewNode(pNodePath)) return FALSE; // Set up a set of default path flags to enable the bezier tool to edit this node (Naughty gavin!) pNodePath->InkPath.InitialiseFlags(); // Select the new node path (and don't redraw - this will be done due to DoInsertNewNode()) pNodePath->Select(FALSE); // Apply the attrs of the node that created the last path to the new NodePath CCAttrMap* pAttrMap = pSelObjPathListItem->GetAttrMap(); if (!ApplyAttributes(pCreatedByNode,pNodePath,pAttrMap)) return FALSE; return TRUE; }

BOOL OpCombineShapes::DoCombineShapes (  ClipStyle  Style, BOOL  bCombineEffectBitmaps )  [private]

Firstly, this adds all the paths together in the last list to form the clip path. Then all the other paths in the other lists are combined with the clip path, using the method specified in 'Flags'. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: Style  = High level style of clipping [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed Errors: - See also: OpCombineShapes::Do() Definition at line 833 of file combshps.cpp. { Path ClipPath; Path StrokedClipPath; if (!ClipPath.Initialise()) return FALSE; if (!StrokedClipPath.Initialise()) return FALSE; // Get the list of paths produced by the top selected object SelObjPathList* pLastSelObjPathList = GetLastList(); // Add all the paths in the last list to form the clip path to combine with if (!AddPathsFromList(&ClipPath,pLastSelObjPathList)) return FALSE; // is the clip path is a line? if (ClipPath.GetPathType() == PATHTYPE_LINE) { if (!StrokePathToPath(&ClipPath,&StrokedClipPath)) return FALSE; } // Get the list of paths produced by the first selected object SelObjPathList* pSelObjPathList = GetFirstList(); ERROR2IF(pSelObjPathList == NULL,FALSE,"ptr to First list is NULL"); ERROR2IF(pSelObjPathList->GetSelNode() == NULL,FALSE,"First list has no sel node"); if (bCombineEffectBitmaps) { //----------------------------------------------- // Effects stacks will not be retained - the topmost effect will turn itself into // a bitmap // // All paths the op will produce will be placed into a group for convenience. // We don't know how many paths will be produced until after the op has done its stuff, so we // stick everything in a group, and if only one path is produced, we take it out and hide the group. // So, firstly create a group to put the paths in. pContextNode = new NodeGroup; if (pContextNode == NULL) return FALSE; // Insert the group into the tree if (!UndoableOperation::DoInsertNewNode((NodeGroup*)pContextNode,pSelObjPathList->GetSelNode(),NEXT,FALSE,FALSE,FALSE,FALSE)) return FALSE; // We want all new paths to be inserted as children of the group AttachDir = LASTCHILD; // Make a note of how many paths have been inserted into the tree so far, so we can tell after the main // loop how many paths have been produced INT32 PrevInsertCount = NodeInsertCount; // This will point to a node to select, if indeed we want to select the node (see later) NodeRenderable* pSelectNode = NULL; // Main loop. This produces all the paths and places them into the group while (pSelObjPathList != NULL && pSelObjPathList != pLastSelObjPathList) { // Combine all the paths in this list with the ClipPath // pContextNode is static! Argh! if (!CombinePathsFromList(Style,&ClipPath,&StrokedClipPath,pSelObjPathList)) return FALSE; // Get the next list of paths generated by the next selected object pSelObjPathList = GetNextList(pSelObjPathList); } // We now need to decide what to do based on the number of paths produced. if (NodeInsertCount == (PrevInsertCount+1)) { // Only one path was produced, so localise the attrs (just in case), move the path out of the // group, and hide the unneeded group if (!DoLocaliseCommonAttributes((NodeGroup*)pContextNode)) return FALSE; Node* pNode = pContextNode->FindFirstChild(); while (pNode != NULL && !pNode->IsAnObject()) pNode = pNode->FindNext(); if (pNode != NULL) { if (!DoMoveNode(pNode,pContextNode,NEXT)) return FALSE; } if (!DoHideNode(pContextNode,TRUE)) return FALSE; pSelectNode = (NodeRenderable*)pNode; pListOfResults->AddNode(pSelectNode); } else if (NodeInsertCount > (PrevInsertCount+1)) { // More than one path was produced, so keep the group and factor out any common attributes. if (!DoFactorOutCommonChildAttributes((NodeGroup*)pContextNode)) return FALSE; pSelectNode = (NodeGroup*)pContextNode; pListOfResults->AddNode(pSelectNode); } else { // The op produced not paths so just hide the empty group if (!DoHideNode(pContextNode,TRUE)) return FALSE; } // Select the new node (and don't redraw - this will be done due to DoInsertNewNode()) // // When slicing, only select the objects produced on the intersection stage // if (pSelectNode != NULL && (Reason != COMBINE_SLICE || Style != CLIP_STYLE_SUBTRACT)) // pSelectNode->Select(FALSE); } else { //----------------------------------------------- // Effects stacks will be retained // So all shape combination must be done within the effects stack structure // // Make a note of how many paths have been inserted into the tree so far, so we can tell after the main // loop how many paths have been produced // INT32 PrevInsertCount = NodeInsertCount; // Main loop. This produces all the paths while (pSelObjPathList != NULL && pSelObjPathList != pLastSelObjPathList) { // Combine all the paths in this list with the ClipPath // pContextNode is static! Argh! if (!CombinePathsFromList(Style, &ClipPath, &StrokedClipPath, pSelObjPathList, bCombineEffectBitmaps)) return FALSE; // Factor out any common attributes. Node* pSelNode = pSelObjPathList->GetSelNode(); if (pSelNode && pSelNode->IsCompoundClass()) if (!DoFactorOutCommonChildAttributes((NodeCompound*)pSelNode, TRUE)) return FALSE; // Get the next list of paths generated by the next selected object pSelObjPathList = GetNextList(pSelObjPathList); } } // We have successfully combined all the paths return TRUE; }

BOOL OpCombineShapes::DoHideListedNodes (  BOOL  bCombineEffectBitmaps  )  [private]

This hides all the nodes that were selected when the op was invoked. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed Errors: - See also: - Definition at line 1917 of file combshps.cpp. { // Get the list of paths produced by the first selected object SelObjPathList* pSelObjPathList = GetFirstList(); BOOL ok = TRUE; while (pSelObjPathList != NULL) { if (bCombineEffectBitmaps) { Node* pSelNode = pSelObjPathList->GetSelNode(); ERROR3IF(pSelNode == NULL,"pSelNode == NULL"); if (pSelNode == NULL) return FALSE; if (pSelNode->IsAnObject()) { // Invalidate the region if (!DoInvalidateNodeRegion((NodeRenderableInk*)pSelNode,TRUE,FALSE)) return FALSE; if (pSelObjPathList->HasProducedPaths()) { // Hide the node that generated the list if (!DoHideNode(pSelNode,TRUE)) return FALSE; } else pSelNode->SetSelected(FALSE); // If it didn't contribute, just deselect it } } else { // Hide the individual path-producing nodes, leaving the // tree structure around them intact // // Get the first path in this list SelObjPathListItem* pFirstItem = pSelObjPathList->GetFirstItem(); SelObjPathListItem* pListItem = pFirstItem; while (ok && pListItem != NULL) { // Always hide the creator node NodeRenderableInk* pCreator = pListItem->GetCreatedByNode(); Node* pParent = pCreator->FindParent(); if (pParent) { if (ok) ok = DoInvalidateNodeRegion(pCreator, TRUE, FALSE); if (ok) ok = DoHideNode(pCreator, TRUE); } // Hide the created path node if its in the tree NodePath* pPathNode = pListItem->GetNodePath(); if (pPathNode->FindParent()) { if (pParent==NULL) pParent = pPathNode->FindParent(); if (ok) ok = DoInvalidateNodeRegion(pPathNode, TRUE, FALSE); if (ok) ok = DoHideNode(pPathNode, TRUE); } // If this hide has resulted in our parent becoming empty // Then hide that too... while (pParent && pParent->IsCompoundClass() && !((NodeCompound*)pParent)->HasVisibleChildren()) { Node* pNextParent = pParent->FindParent(); if (ok) ok = DoInvalidateNodeRegion((NodeCompound*)pParent, TRUE, FALSE); if (ok) ok = DoHideNode((NodeCompound*)pParent, TRUE); pParent = pNextParent; } // Get the next item in the selected object path list. pListItem = pSelObjPathList->GetNextItem(pListItem); } } // Get the next list of paths generated by the next selected object pSelObjPathList = GetNextList(pSelObjPathList); } // it all went well return ok; }

BOOL OpCombineShapes::DoInsertNewNode (  NodeRenderableBounded *  pNewNode  )  [private]

High-level interface to UndoableOperation::DoInsertNode(). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 30/1/95 Parameters: pNewNode  = ptr to the node to insert [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE if it goes bang Every time this call is successful, it incs a counter so that the op can tell how many new nodes have been placed in the tree as a result of the shape combining operation. Uses member vars pContextNode & AttachDir If no new nodes are created, the op can then fail, rather than just giving the effect of deleting the selection See also: - Definition at line 2469 of file combshps.cpp. { ERROR2IF(pNewNode == NULL,FALSE,"Given NULL node ptr"); ERROR2IF(pContextNode == NULL,FALSE,"Context node is NULL"); if (UndoableOperation::DoInsertNewNode(pNewNode,pContextNode,AttachDir,TRUE,FALSE,FALSE,TRUE)) { NodeInsertCount++; return TRUE; } else return FALSE; }

BOOL OpCombineShapes::DoSelectResultNodes (  BOOL  bCombineEffectBitmaps  )  [private]

This selects all the nodes in the results list. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 07/04/2005 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE if failed Errors: - See also: - Definition at line 2020 of file combshps.cpp. { // Get the list of paths produced by the first selected object BOOL ok = TRUE; NodeRenderableInk::DeselectAll(FALSE, FALSE); Node* pNode = pListOfResults->FindFirst(); while (pNode) { if (pNode->IsNodeRenderableClass()) ((NodeRenderable*)pNode)->Select(FALSE); pNode = pListOfResults->FindNext(pNode); } // it all went well return ok; }

DocRect OpCombineShapes::GetBoundingRect (  Path *  pPath  )  [private]

This gets the exact pure path bounds, using GDraw_CalcStrokeBBox. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 17/2/95 Parameters: pPath  = ptr to path [INPUTS] -  [OUTPUTS] Returns: The stroked bounding rect of this path, disregarding attributes Errors: - See also: OpCombineShapes::DoCombineShapes() Definition at line 1468 of file combshps.cpp. { DocRect Rect; if (pPath != NULL) { #if REAL_GDRAW // Get GDraw to get the stroked bounds for this path GDrawContext *GD = GRenderRegion::GetStaticDrawContext(); if (GD != NULL) { GD->CalcStrokeBBox((POINT*)pPath->GetCoordArray(),pPath->GetVerbArray(),pPath->GetNumCoords(), (tagRECT*)(&Rect),pPath->IsFilled, 0, CAPS_ROUND, JOIN_ROUND, NULL); } #else Rect = pPath->GetBoundingRect(); #endif } if (!Rect.IsValid()) Rect.MakeEmpty(); return Rect; }

SelObjPathList* OpCombineShapes::GetFirstList (   )  [inline, private]

Definition at line 287 of file combshps.h. { return (SelObjPathList*) ListOfSelObjPathLists.GetHead(); }

SelObjPathList* OpCombineShapes::GetLastList (   )  [inline, private]

Definition at line 288 of file combshps.h. { return (SelObjPathList*) ListOfSelObjPathLists.GetTail(); }

SelObjPathList* OpCombineShapes::GetNextList (  SelObjPathList *  pItem  )  [inline, private]

Definition at line 289 of file combshps.h. { return (SelObjPathList*) ListOfSelObjPathLists.GetNext(pItem); }

void OpCombineShapes::GetOpName (  String_256 *  OpName  )  [virtual]

The GetOpName fn is overridden so that we return back a description appropriate to the type of attribute that the operation applies. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/1/95 Parameters: OpName  = ptr to str to place op name in [INPUTS] The  undo string for the operation [OUTPUTS] Returns: Errors: - See also: - Reimplemented from Operation. Definition at line 348 of file combshps.cpp. { UINT32 IDS = 0; switch (Reason) { case COMBINE_ADD: IDS = _R(IDBBL_COMBINE_ADD); break; case COMBINE_SUBTRACT: IDS = _R(IDBBL_COMBINE_SUBTRACT); break; case COMBINE_INTERSECT: IDS = _R(IDBBL_COMBINE_INTERSECT); break; case COMBINE_SLICE: IDS = _R(IDBBL_COMBINE_SLICE); break; default: ERROR3_PF(("Unknown combine reason : %d",Reason)); break; } if (IDS > 0) *OpName = String_256(IDS); }

OpState OpCombineShapes::GetState (  String_256 *  pStr, OpDescriptor *  pOpDesc )  [static]

Gives the op an oppertunity to say whether the op is executable or not. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/1/95 Parameters: pStr  = string to place messages in [INPUTS] -  [OUTPUTS] Returns: The op state, i.e. the ticked and greyed state of the op A combine op is only available if there are more than one selected nodes that are or can become paths. Returns: Errors: - See also: - Definition at line 284 of file combshps.cpp. { OpState OpSt; UINT32 Count = 0; UINT32 MinCount = 2; String Str(OPTOKEN_ADDSHAPES); if (pOpDesc->Token == Str) MinCount = 1; // Get the selected range SelRange* pSelRange = GetApplication()->FindSelection(); BOOL bRestorePromote = pSelRange->SetPromoteToParent(TRUE); BecomeA BecomePath(BECOMEA_REPLACE, CC_RUNTIME_CLASS(NodePath)); BecomePath.SetInsertComplexBlendStepsAsPaths (TRUE); // compound nodes MUST be inserted as paths! // Count the number of selected nodes that are or can become NodePaths if (pSelRange != NULL) { Node* pNode = pSelRange->FindFirst(); while (pNode != NULL) { if (pNode->CanBecomeA(&BecomePath)) Count++; pNode = pSelRange->FindNext(pNode); } } pSelRange->SetPromoteToParent(bRestorePromote); // if at least 'MinCount' objects of the selection can be combined, ungrey the op if (Count >= MinCount) OpSt.Greyed = FALSE; else { // The op can't be done, so put an explanation in the string provided OpSt.Greyed = TRUE; String_256 Str(_R(IDS_COMBINE_SEL_ERROR)); *pStr = Str; } return OpSt; }

BOOL OpCombineShapes::Init (  void   )  [static]

Declares a preference that allows you to clear memory in delete(). Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 19/4/94 Returns: TRUE if it worked OK, FALSE if not Reimplemented from SimpleCCObject. Definition at line 247 of file combshps.cpp. { REG_COMBINE_OP(ADD, Add); REG_COMBINE_OP(SUBTRACT, Subtract); REG_COMBINE_OP(INTERSECT, Intersect); REG_COMBINE_OP(SLICE, Slice); if (Camelot.DeclareSection(_T("CombineShapes"),5)) { Camelot.DeclarePref(_T("CombineShapes"), _T("DefaultTolerance"), &DefaultTolerance, 1,1000); Camelot.DeclarePref(_T("CombineShapes"), _T("DefaultFlatness"), &DefaultFlatness, 10,2000); Camelot.DeclarePref(_T("CombineShapes"), _T("DefaultStrokeWidth"), &DefaultStrokeWidth,10,72000); Camelot.DeclarePref(_T("CombineShapes"), _T("AddPathGranularity"), &AddPathGranularity,1,1024*1024); Camelot.DeclarePref(_T("CombineShapes"), _T("CombineEffectsBitmaps"), &CombineEffectBitmaps, FALSE, TRUE); } return TRUE; }

BOOL OpCombineShapes::StrokePathToPath (  Path *  pPath, Path *  pDest )  [private]

This picks out a subpath from Src and places it into pDest Strokes pPath, and places result in pDest. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/1/95 Parameters: pPath  = ptr to path [INPUTS] pDest = ptr to path to place result in -  [OUTPUTS] Returns: TRUE if OK, FALSE if it goes bang See also: - Definition at line 2397 of file combshps.cpp. { ERROR2IF(pPath == NULL,FALSE,"pPath == NULL"); ERROR2IF(pDest == NULL,FALSE,"pDest == NULL"); return pPath->StrokePathToPath(DefaultStrokeWidth,LineCapButt,MitreJoin,NULL,pDest,200); /* INT32 NumCoords = pPath->GetNumCoords(); INT32 OutputSize = (NumCoords*40)+1000; Path OutputPath; if (!OutputPath.Initialise(OutputSize)) return FALSE; DocCoord* IPoints = pPath->GetCoordArray(); BYTE* ITypes = (BYTE*) pPath->GetVerbArray(); DWORD ILength = (DWORD) NumCoords; DocCoord* OPoints = OutputPath.GetCoordArray(); BYTE* OTypes = (BYTE*) OutputPath.GetVerbArray(); DWORD OLength = (DWORD) OutputSize; DashType Dash; Dash.Length = 0; INT32 len = GRenderRegion::StrokePathToPath(IPoints,ITypes,ILength, OPoints,OTypes,OLength, FALSE,(TOLERANCE*5)/2,200,LineCapButt,MitreJoin,&Dash); if (!OutputPath.MergeTwoPaths(OutputPath.GetCoordArray(),OutputPath.GetVerbArray(),OutputPath.GetFlagArray(), len,TRUE)) return FALSE; if (len > 0) { pDest->ClearPath(FALSE); if (!pDest->MakeSpaceInPath(len)) return FALSE; if (!pDest->MergeTwoPaths( OutputPath.GetCoordArray(),OutputPath.GetVerbArray(),OutputPath.GetFlagArray(), len,TRUE)) return FALSE; pDest->InitialiseFlags(); RemoveBogusCloseFigures(pDest); INT32 n = pDest->GetNumCoords(); PathVerb* pVerbs = pDest->GetVerbArray(); pVerbs[n-1] |= PT_CLOSEFIGURE; } return TRUE; */ }

---

Member Data Documentation

AttachNodeDirection OpCombineShapes::AttachDir [private]

Definition at line 302 of file combshps.h.

INT32 OpCombineShapes::JobCount [private]

Definition at line 298 of file combshps.h.

List OpCombineShapes::ListOfSelObjPathLists [private]

Definition at line 293 of file combshps.h.

INT32 OpCombineShapes::NodeInsertCount [private]

Definition at line 299 of file combshps.h.

INT32 OpCombineShapes::NumPaths [private]

Definition at line 297 of file combshps.h.

DocRect OpCombineShapes::OriginalBoundingRect [private]

Definition at line 295 of file combshps.h.

Node* OpCombineShapes::pContextNode [private]

Definition at line 301 of file combshps.h.

ListRange* OpCombineShapes::pListOfResults [private]

Definition at line 294 of file combshps.h.

SelRange* OpCombineShapes::pSelRange [private]

Definition at line 296 of file combshps.h.

CombineReason OpCombineShapes::Reason [protected]

Definition at line 247 of file combshps.h.

---

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

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

---