DocRect ArrowRec::FindBoundsAt(const DocCoord& ArrowCentre, const DocCoord& Direction,
INT32 ParentLineWidth)
{
DocRect Bounds(0,0,0,0);
// Find a matrix to transform the ArrowHead to this Position.
Trans2DMatrix Trans;
GetArrowMatrix(ArrowCentre, Direction, ParentLineWidth, &Trans);
// Note:
// We should really be able to ask Gavin to Calculate the Bounds,
// and pass him this Transform Matrix, but he can't do this at the
// moment, so we'll have to actually transform the path into
// a tempory path, and then ask him to calc the bounds of that.
// Make a tempory path to transform
Path* TransPath = new Path();
if (TransPath == NULL)
return Bounds;
// Copy the path data from the ArrorHead into our tempory path.
BOOL ok = TransPath->Initialise(ArrowShape->GetNumCoords());
if (ok) ok = TransPath->CopyPathDataFrom(ArrowShape);
if (!ok)
{
// Tidy up if we failed
delete TransPath;
return Bounds;
}
// Go transform the Tempory path
Trans.Transform(TransPath->GetCoordArray(),
TransPath->GetNumCoords() );
BOOL GDrawResult = FALSE;
// Find out what the paths bounding rect is, taking into account
// any bezier curve thingies.
GDrawContext *GD = GRenderRegion::GetStaticDrawContext();
if (GD != NULL)
GDrawResult = GD->CalcStrokeBBox((POINT*)TransPath->GetCoordArray(),
TransPath->GetVerbArray(), TransPath->GetNumCoords(),
(RECT *)(&Bounds),
TRUE, 0, CAPS_ROUND, JOIN_ROUND, NULL) == 0;
// If Gavin failed, then use backup technique of getting coord array bounds
if (!GDrawResult)
Bounds = TransPath->GetBoundingRect();
// Delete the temporary transformed path
delete TransPath;
return Bounds;
}
/********************************************************************************************
> OpState OpBaseConvertPathSegment::BaseGetState(INT32 PathType)
Author: Peter_Arnold (Xara Group Ltd) <*****@*****.**>
Created: 16/8/95
Inputs: Type of the path that ends a segment
Returns: The tick/grey state of OpBaseConvertPathSegment and derived classes
Purpose: For finding the state of this op
SeeAlso: OpState
********************************************************************************************/
OpState OpBaseConvertPathSegment::BaseGetState(INT32 PathType)
{
OpState OpSt;
#ifndef STANDALONE
SelRange* Selected = GetApplication()->FindSelection();
if ((Document::GetSelected() == NULL) || (Selected == NULL) )
{ // There is no selected document or selrange is invalid
OpSt.Greyed = TRUE;
return OpSt;
}
Node* pNode = Selected->FindFirst();
BOOL FoundSegment = FALSE;
BOOL AllConverted = TRUE;
BOOL PrevSelected = FALSE;
while ((pNode != NULL) && AllConverted)
{
if (pNode->IsNodePath() && ((NodePath*)pNode)->IsPathAllowable())
{
Path* ThisPath = &(((NodePath*)pNode)->InkPath);
PathFlags* Flags = ThisPath->GetFlagArray();
PathVerb* Verbs = ThisPath->GetVerbArray();
INT32 UsedSlots = ThisPath->GetNumCoords();
PrevSelected = FALSE;
for (INT32 i=0; i<UsedSlots; i++)
{
if (Flags[i].IsEndPoint)
{
if (Flags[i].IsSelected)
{
if (PrevSelected && ((Verbs[i] & ~PT_CLOSEFIGURE) != PT_MOVETO) )
{
FoundSegment = TRUE;
if ((Verbs[i] & ~PT_CLOSEFIGURE) != PathType)
AllConverted = FALSE;
}
PrevSelected = TRUE;
}
else
{
PrevSelected = FALSE;
}
}
}
}
pNode = Selected->FindNext(pNode);
}
OpSt.Greyed = !FoundSegment;
OpSt.Ticked = AllConverted && FoundSegment;
#endif // #ifdef STANDALONE
return OpSt;
}
void ImagemapRenderRegion::AddPathToImagemap(Path* ppthToAdd, WebAddressAttribute* pwaaCurrent)
{
//First get the origin of the export area and the DPI
DocCoord dcOrigin=ImagemapFilterOptions::GetOriginOfExportArea(m_Options.m_stExportArea);
double dDPI=m_Options.m_dDPI;
//Now, how many subpaths are there in this path?
INT32 lNumSubpaths=ppthToAdd->GetNumSubpaths();
//For each subpath in the path
for (INT32 l=0; l<lNumSubpaths; l++)
{
//Create a new path
Path pthSubpath;
pthSubpath.Initialise(ppthToAdd->GetNumCoords());
//And copy the next subpath into it
ppthToAdd->MakePathFromSubPath(l, &pthSubpath);
//Now, if that subpath is closed
if (pthSubpath.IsSubPathClosed(0))
{
//Then we want to add it to the imagemap
//So scale it to dDPI and by dcOrigin
pthSubpath.Scale(dcOrigin, dDPI);
//Now we need to flatten it.
//This means creating a new path, because otherwise Path::Flatten
//goes wrong
Path pthFlattened;
pthFlattened.Initialise(pthSubpath.GetNumCoords());
//So, if we should flatten the path
if (m_Options.m_ffApprox!=FF_NOTATALL)
//Then do it
pthSubpath.Flatten(m_Options.m_ffApprox, &pthFlattened);
else
//Otherwise, simply copy the path across
pthFlattened.CopyPathDataFrom(&pthSubpath);
//Then add the flattened path to the imagemap
m_Imagemap.AddPolygon(&pthFlattened, pwaaCurrent->m_url.GetWebAddress(), pwaaCurrent->m_pcFrame);
}
}
}
BOOL StringToBitmap::TTFAddString(String_256 *text, UINT32 Xsize, UINT32 Ysize, UINT32 DPI, PLOGFONT pLogFont,
INT32 IntLeading, KernelBitmap **BM, UINT32 ForeColour)
{
KernelBitmap *Bitmap = *BM;
/* HDC ScreenDC = CreateCompatibleDC(NULL);
if (ScreenDC == NULL)
{
ERROR3("StringToBitmap::AddString: Unable to create screen DC");
return FALSE;
}*/
CDC SysDisplay;
BOOL ok=SysDisplay.CreateCompatibleDC(NULL);
if(!ok)
{
//DeleteDC(ScreenDC);
ERROR3("StringToBitmap::TTF AddString: Unable to create CDC");
return FALSE;
}
HDC ScreenDC = SysDisplay.m_hDC;
// bodge to get things working with GetBezierFromChar
INT32 OldlfHeight = pLogFont->lfHeight;
pLogFont->lfHeight = -(pLogFont->lfHeight - IntLeading);
UINT32 CurrentPathSizeAlloc = 0;
Trans2DMatrix *pTransform = NULL;
DocCoord *pPathCoords = NULL;
Path *pPath = NULL;
//pPath = new Path();
DocCoord *pPolyCordBuffer = NULL;
PathVerb *pPolyVerbBuffer = NULL;
UINT32 TextLength = (UINT32)text->Length();
SIZE StringSize= {0,0};
// Get handle of font
// HFONT hNewFont = CreateFontIndirect(pLogFont);
// HGDIOBJ hOldFont = SelectObject(ScreenDC, hNewFont);
CFont UnHintedCFont;
if(!UnHintedCFont.CreateFontIndirect(pLogFont))
{
SysDisplay.DeleteDC();
pLogFont->lfHeight = OldlfHeight;
return FALSE;
}
CFont* pOldCFont=SysDisplay.SelectObject(&UnHintedCFont);
// Get the default character to use if a charater is not present in the font.
WCHAR FontDefaultCharacter = (unsigned char)'?';
TEXTMETRIC FontTextData;
#ifdef _UNCCODE
if (SysDisplay.GetTextMetrics(&FontTextData))
FontDefaultCharacter = FontTextData.tmDefaultChar;
#else
if (SysDisplay.GetTextMetrics(&FontTextData))
FontDefaultCharacter = (unsigned char)FontTextData.tmDefaultChar;
#endif
// Work out a nice scaling factor so the font fits in the bitmap ok...
// Not 32 ?
GetTextExtentPoint(ScreenDC, *text, TextLength, &StringSize);
if(StringSize.cy == 0)
{
SysDisplay.SelectObject(pOldCFont);
SysDisplay.DeleteDC();
pLogFont->lfHeight = OldlfHeight;
return FALSE;
}
//ERROR3IF(!ok, "Initial GetTextExtentPoint32() failed");
double YScale = ((double)Ysize / (double)StringSize.cy) / (double)2;
double XScale = YScale;
// Shift thumbnail upwards, and scale down a bit - to get the g's looking right
// One or two fonts require this reducing (their tops are clipped), 72000/100 is
// about right for most of them though...
// Note the external previews were done with 72000/220 for Matrix and 72000/140 for
// the capital only fonts.
double YShift = 72000/100;//72000/80;
YScale = (YScale * 78) / 100;
XScale = (XScale * 78) / 100;
if(!text->IsEmpty())
{
const TCHAR* pCurrentChar = (const TCHAR*)(*text);
while (ok && *pCurrentChar!=0)
{
// Get the current character as Unicode.
#ifdef _UNICODE
WCHAR wchr = *pCurrentChar; // pCurrentChar is a pointer to WCHAR in _UNICODE builds
#else
UINT32 CharToConvert = 0;
if (UnicodeManager::IsDBCSLeadByte(*pCurrentChar))
CharToConvert = UnicodeManager::ComposeMultiBytes(*pCurrentChar, *(pCurrentChar+1));
else
CharToConvert = (unsigned char)(*pCurrentChar);
WCHAR wchr = UnicodeManager::MultiByteToUnicode(CharToConvert);
#endif
// Get positioning information for this character
ok = GetTextExtentPoint(ScreenDC, *text, (pCurrentChar-(TCHAR*)(*text)), &StringSize);
ERROR3IF(!ok, "GetTextExtentPoint32() failed");
if (!ok) break;
// Get the characters path
DWORD PathSize = 0;
ok = TextManager::GetBezierFromChar(&SysDisplay, wchr, pLogFont, &PathSize, (POINT *)NULL, (BYTE *)NULL);
if (!ok)
{
wchr = FontDefaultCharacter;
ok = TextManager::GetBezierFromChar(&SysDisplay, wchr, pLogFont, &PathSize, (POINT *)NULL, (BYTE *)NULL);
}
ERROR3IF(!ok, "GetBezierFromChar returned false");
if (!ok) break;
// Pointer to an array of path coordinates
if(pPolyCordBuffer == NULL)
{
TRY
{
pPolyCordBuffer = new DocCoord[PathSize];
}
CATCH (CMemoryException, e)
{
pPolyCordBuffer = NULL;
/*ERROR(_R(IDS_OUT_OF_MEMORY), FALSE);*/
}
END_CATCH
}
// Pointer to an array of path verbs
if(pPolyVerbBuffer == NULL)
{
TRY
{
pPolyVerbBuffer = new PathVerb[PathSize];
}
CATCH (CMemoryException, e)
{
pPolyVerbBuffer = NULL;
/*ERROR(_R(IDS_OUT_OF_MEMORY), FALSE);*/
}
END_CATCH
}
if (pPolyCordBuffer == NULL || pPolyVerbBuffer == NULL)
{
ok = FALSE;
break;
}
CurrentPathSizeAlloc = PathSize;
// Fill up the buffers until they're bursting with fontyness
ok = TextManager::GetBezierFromChar(&SysDisplay, wchr, pLogFont, &PathSize, (POINT *)pPolyCordBuffer,
(BYTE *)pPolyVerbBuffer);
if(!ok) TRACEUSER( "Richard", _T("GetBezierFromChar returned false in second phase...\n"));
if(!ok) break;
// Spaces set PathSize to zero
if((PathSize > 0)/* && (pPath != NULL)*/)
{
pPath = new Path();
pPath->Initialise(PathSize, 12);
pPath->CopyPathDataFrom(pPolyCordBuffer, pPolyVerbBuffer, PathSize, TRUE);
// Major bodge at present with the x spacing...
Matrix scale(XScale, 0, 0, YScale, (INT32)((XScale*StringSize.cx*72000)/(double)DPI), (INT32)YShift);
pTransform = new Trans2DMatrix(scale);
pPathCoords = pPath->GetCoordArray();
pTransform->Transform( pPathCoords, pPath->GetNumCoords() );
delete pTransform;
pPath->InitialiseFlags();
ok = ALU->GradFillPath(pPath, ForeColour, ForeColour, 0, 0, 0,/*Xsize/2,*/ Ysize, S2BMP_ANTIALIAS);
ERROR3IF(!ok, "Gradfillpath returned false");
if(!ok) break;
delete pPath;
}
// S2BMP_MAGIC is the worderfully fabby constant that mark's getbezierfromchar returns
// Theory goes that he's going to sort this out sometime...
if(CurrentPathSizeAlloc != S2BMP_MAGIC)
{
delete []pPolyCordBuffer;
delete []pPolyVerbBuffer;
pPolyCordBuffer = NULL;
pPolyVerbBuffer = NULL;
CurrentPathSizeAlloc = 0;
}
pPath = NULL;
pTransform = NULL;
pCurrentChar = camStrinc(pCurrentChar);
}
void OpBreakAtPoints::Do(OpDescriptor*)
{
// Obtain the current selections
SelRange* Selected = GetApplication()->FindSelection();
NodePath* pSplitNode;
// Now, because we're going to be doing mad things to the selection, we have to make a list
// of all the selected nodes, so that adding nodes into the tree won't confuse us
List* NodeList = Selected->MakeListOfNodes();
NodeListItem* CurItem = (NodeListItem*)(NodeList->GetHead());
if (!CurItem)
goto FailAndDeleteList;
if (!DoStartSelOp(TRUE,TRUE))
goto FailAndDeleteList;
while (CurItem)
{
// get a pointer to the NodePath
NodePath* pThisNode = (NodePath*)(CurItem->pNode);
// Only interested in NodePaths that have a sub selection, and that will allow the op to happen
if ((IS_A(pThisNode,NodePath) || IS_A(pThisNode,NodeBlendPath)) && pThisNode->InkPath.IsSubSelection())
{
// Find out how many nodes this op will reproduce
INT32 NumSplinters = pThisNode->InkPath.NumSplinters();
BOOL DoThisNode = FALSE;
if (NumSplinters > 0)
{
// We need to ask the effected nodes if they (and their parents) can handle this node being replaced
ObjChangeFlags cFlags;
if (NumSplinters > 1)
cFlags.MultiReplaceNode = TRUE; // Node will be replaced with more than one node.
else
cFlags.ReplaceNode = TRUE; // Node will be replaced with one node only.
ObjChangeParam ObjChange(OBJCHANGE_STARTING,cFlags,NULL,this);
DoThisNode = pThisNode->AllowOp(&ObjChange);
}
if (DoThisNode)
{
BOOL ok;
Node* pnode;
// Copy the nodepath and all its children, without placing the copy in the tree
CALL_WITH_FAIL(pThisNode->NodeCopy(&pnode), this, ok);
if (!ok) goto DeleteList;
pSplitNode = (NodePath*)pnode;
// remove the fill from this path as we're about to open it
pSplitNode->InkPath.IsFilled = FALSE;
// Now stick the new path into the tree
CALL_WITH_FAIL
(
DoInsertNewNode(pSplitNode, pThisNode, NEXT, TRUE, FALSE),
this,ok
);
if (!ok)
goto DeleteListAndPath;
// Now breakup this copy of the path where necessary
Path* pChildPath;
INT32 split;
do
{
// Create a new path, ready for split
ALLOC_WITH_FAIL(pChildPath, new Path, this);
if (!pChildPath)
goto DeleteList;
// Now split the path, possibly into two pieces.
split = pSplitNode->InkPath.BreakInTwo(pChildPath);
if (split==-1)
{
InformError(_R(IDS_OUT_OF_MEMORY), _R(IDS_OK));
delete pChildPath;
goto FailAndDeleteList;
}
/* Karim 05/12/2000
No longer required - see code addition at the bottom of this loop.
if (split==1)
{
delete pChildPath;
continue;
}
*/
if (split>1)
{
// update the split paths bounding rectangle
pSplitNode->InvalidateBoundingRect();
// Create a new nodepath.
NodePath* pChildNode;
ALLOC_WITH_FAIL(pChildNode, new NodePath(), this);
if (!pChildNode)
{
delete pChildPath;
goto DeleteList;
}
// make room for the new path in the node path.
CALL_WITH_FAIL
(
pChildNode->SetUpPath(pChildPath->GetNumCoords(),12),
this,ok
);
if (!ok)
{
delete pChildNode;
delete pChildPath;
goto DeleteList;
}
// now copy the path data in there.
pChildNode->InkPath.CopyPathDataFrom(pChildPath);
delete pChildPath;
// Clear the selection flag from the first element in both the split
// and child paths. All others apart from the last will be unselected
// by definition. Also select the last element in the child
(pSplitNode->InkPath.GetFlagArray())[0].IsSelected = FALSE;
(pChildNode->InkPath.GetFlagArray())[0].IsSelected = FALSE;
(pChildNode->InkPath.GetFlagArray())[(pChildNode->InkPath.GetNumCoords()-1)].IsSelected = TRUE;
pChildNode->InkPath.IsFilled = FALSE;
// now, copy all attributes from the parent split to the child split
Node* pAttr = pSplitNode->FindFirstChild();
while (pAttr != NULL)
{
if (pAttr->IsKindOf(CC_RUNTIME_CLASS(NodeAttribute)))
{
Node* pAttrCopy;
CALL_WITH_FAIL(pAttr->NodeCopy(&pAttrCopy), this,ok);
if (!ok)
{
pChildNode->CascadeDelete();
delete pChildNode;
goto DeleteList;
}
pAttrCopy->AttachNode(pChildNode, FIRSTCHILD);
}
pAttr = pAttr->FindNext();
}
for (INT32 loop = 0; loop < pChildNode->InkPath.GetNumCoords(); loop ++)
{
pChildNode->InkPath.GetVerbArray()[loop] = pChildNode->InkPath.GetVerbArray()[loop] & ~PT_CLOSEFIGURE;
}
// Now stick the new path into the tree
CALL_WITH_FAIL
(
DoInsertNewNode(pChildNode, pSplitNode, NEXT, TRUE, FALSE),
this,ok
);
if (!ok)
{
pChildNode->CascadeDelete();
delete pChildNode;
goto DeleteList;
}
pSplitNode = pChildNode;
}
// Karim 05/12/2000
// Fix for memory leak.
else
{
delete pChildPath;
}
}
while (split);
// Clear out any remaining closefigures on the last bit of the path
for (INT32 loop = 0; loop < pSplitNode->InkPath.GetNumCoords(); loop ++)
{
pSplitNode->InkPath.GetVerbArray()[loop] = pSplitNode->InkPath.GetVerbArray()[loop] & ~PT_CLOSEFIGURE;
}
// Now we've broken up this path, let's hide it
CALL_WITH_FAIL(DoHideNode(pThisNode,TRUE), this, ok)
if (!ok) goto DeleteList;
}
}
CurItem = (NodeListItem*)(NodeList->GetNext(CurItem));
}
/********************************************************************************************
> BOOL BlendHelpers::BlendPaths(BlendNodeParam * pParam, Path * pPath)
Author: David_McClarnon (Xara Group Ltd) <*****@*****.**>
Created: 21/2/2000
Inputs: The blend node parameter
Outputs: The blended path is stored in three arrays: the coords, the verbs, and the flags.
The arrays are:
pTempCoords
pTempVerbs
pTempFlags
ArrayLength = the length of all three arrays
This allows the caller to decide what to do with the blended path in a very flexible way.
Returns: TRUE if successful, FALSE otherwise
Purpose: Blends two BlendPath objects by the amount specified in BlendRatio
SeeAlso: -
********************************************************************************************/
BOOL BlendHelpers::BlendPaths(BlendNodeParam * pParam, Path * pPath)
{
// Check entry params
BlendPath * pBlendPathStart = pParam->GetStartBlendPath();
BlendPath * pBlendPathEnd = pParam->GetEndBlendPath();
ERROR2IF(!pBlendPathStart->GetBlendNode()->IsNodePath(), FALSE,
"Start blend path's node isn't a node path");
ERROR2IF(!pBlendPathEnd->GetBlendNode()->IsNodePath(), FALSE,
"End blend path's node isn't a node path");
BOOL ok = (pBlendPathStart != NULL && pBlendPathEnd != NULL);
if (ok) ok = (pBlendPathStart->GetBlendNode() != NULL && pBlendPathEnd->GetBlendNode() != NULL);
ERROR3IF(!ok,"One or more NULL entry params");
if (!ok) return FALSE;
// Get the types of the two paths
PathTypeEnum PathTypeStart = pBlendPathStart->GetPathType();
PathTypeEnum PathTypeEnd = pBlendPathEnd ->GetPathType();
// The blended path will be closed if either of the paths is a shape
BOOL Closed = (PathTypeStart == PATHTYPE_SHAPE) || (PathTypeEnd == PATHTYPE_SHAPE);
Path * pPathStart = NULL;
// Find the paths associated with the start and end blend paths
if (pBlendPathStart->GetBlendNode()->IsNodePath())
{
pPathStart = &(((NodePath *)pBlendPathStart->GetBlendNode())->InkPath);
}
Path * pPathEnd = NULL;
if (pBlendPathEnd->GetBlendNode()->IsNodePath())
{
pPathEnd = &(((NodePath *)pBlendPathEnd->GetBlendNode())->InkPath);
}
// Calculate how large the arrays have to be to store the blended path definition
INT32 DestPathSize = ((pPathStart->GetNumCoords()+pPathEnd->GetNumCoords())*3)+500;
// Get some arrays used to hold the blended path data, and error if any are NULL
DocCoord* pDestCoords = GetCoordArray(DestPathSize);
PathVerb* pDestVerbs = GetVerbArray(DestPathSize);
PathFlags* pDestFlags = GetFlagArray(DestPathSize);
UINT32* pBuff = GetGBlendBuff(DestPathSize);
if (pDestCoords == NULL || pDestVerbs == NULL || pDestFlags == NULL || pBuff == NULL)
return FALSE;
// This section copes with the case when blending a line with a shape.
// In this case we need to get a temp path the is actually a shape version of the line.
// The line is simply reversed back onto itself to form a shape that would look identical to the
// line if rendered. This allows the line to appear to open up to the shape when blended.
Path Shape;
if (PathTypeStart != PathTypeEnd)
{
BOOL ok = FALSE;
if (!Shape.Initialise()) return FALSE;
// if going from a line to a shape, convert the start path to a shape
if (PathTypeStart == PATHTYPE_LINE && PathTypeEnd == PATHTYPE_SHAPE)
{
ok = NodeBlender::ConvertLineToShape(pPathStart,&Shape);
pPathStart = &Shape;
}
// if going from a shape to a line, convert the end path to a shape
if (PathTypeStart == PATHTYPE_SHAPE && PathTypeEnd == PATHTYPE_LINE)
{
ok = NodeBlender::ConvertLineToShape(pPathEnd,&Shape);
pPathEnd = &Shape;
}
if (!ok) return FALSE;
}
// The blend should do a one-to-one mapping when the OneToOne flag is set AND both paths
// have the same number of elements
BOOL OneToOne = FALSE;
if (pParam->GetOneToOne())
OneToOne = (pBlendPathStart->GetNumElements() == pBlendPathEnd->GetNumElements());
// Now actually blend the two paths
GBlend GBlendObj;
// Define the blend
GBlendObj.Define( (PPOINT)pPathStart->GetCoordArray(), // Specify the start path
pPathStart->GetVerbArray(),
pPathStart->GetNumCoords(),
(PPOINT)pPathEnd ->GetCoordArray(), // Specify the end path
pPathEnd ->GetVerbArray(),
pPathEnd ->GetNumCoords(),
OneToOne, // The one-to-one flag
1024, // Flatness
pBuff, // Buffer for GBlend to use
DestPathSize*sizeof(UINT32)); // The buffer size
// Blend the paths
m_ArrayLength = GBlendObj.Blend(pParam->GetBlendRatio(), // The blend ratio, 0.0 < BlendRatio < 1.0
(PPOINT)pDestCoords, // Array to store blended coords
pDestVerbs, // Array to store blended verbs
DestPathSize); // The num elements in the two arrays
// If we're blending a line to another line, we need to make sure that the blended line
// is going in a direction that corresponds to the source lines. This ensures attributes
// that depend on this direction (e.g. start and end arrows) look correct.
//
// When creating blend paths of lines, we can detect if the blend path has been reversed,
// in relation to the original path, by the original mapping value.
// If it's 0 it has NOT been reversed, otherwise it's been reversed.
//
// If the blend ratio is <=0.5, the blended path is closest to the start blend path,
// so we look at the start blend path's original mapping.
//
// If blend ration > 0.5, look at the end blend path's original mapping.
//
// The (BlendRation <= 0.5) cut-off point is the same as the cut-off point used in the blending
// of attributes.
if (pBlendPathStart->IsLine() && pBlendPathEnd->IsLine())
{
BlendPath* pBlendPath;
if (pParam->GetBlendRatio() <= 0.5)
pBlendPath = pBlendPathStart;
else
pBlendPath = pBlendPathEnd;
if (pBlendPath->GetOrigMapping() != 0)
NodeBlender::ReversePath(pDestCoords,pDestVerbs,m_ArrayLength);
}
// We need to do some work on the blended path
if (!NodeBlender::ProcessBlendedPath(pDestCoords,pDestVerbs,pDestFlags,m_ArrayLength,Closed))
return FALSE;
Path RetnPath;
RetnPath.Initialise(m_ArrayLength);
BOOL Filled = pPathStart->IsFilled || pPathEnd->IsFilled;
BOOL Stroked = pPathStart->IsStroked || pPathEnd->IsStroked;
RetnPath.MergeTwoPaths(pDestCoords,pDestVerbs,pDestFlags,m_ArrayLength,Filled);
pPath->ClearPath();
pPath->CloneFrom(RetnPath);
pPath->IsFilled = Filled;
pPath->IsStroked = Stroked;
return TRUE;
}
