/**************************************************************************\
* 
* Copyright (c) 1999  Microsoft Corporation
*
* Abstract:
*
*   Implementation of XBezier class and its DDA.
*
* History:
*
*   11/08/1999 ikkof
*       Created it.
*
\**************************************************************************/

#include "precomp.hpp"

    // Path types used for advanced path.

// !!! [asecchia] 
// this is a very clumsy hack to enable the XPath stuff to work.
// we should have an internal set of enum values that are different
// from the external ones.

#define PathPointTypeBezier2 2    // quadratic Beizer
#define PathPointTypeBezier4 4    // quartic (4th order) Beizer
#define PathPointTypeBezier5 5    // quintic (5th order) Bezier
#define PathPointTypeBezier6 6    // hexaic (6th order) Bezier



GpXPath::GpXPath(const GpPath* path)
{
    InitDefaultState();

    if(!path || !path->IsValid())
		return;
	
	INT count = path->GetPointCount();
    const GpPointF *pts = ((GpPath*) path)->GetPathPoints();
    const BYTE *types = ((GpPath*) path)->GetPathTypes();

	if(pts && types && count > 0)
	{
		Types = (BYTE*) GpMalloc(count);
		XPoints.Count = count;
		XPoints.Dimension = 2;
		XPoints.Data = (REALD*) GpMalloc(2*count*sizeof(REALD));
        XPoints.IsDataAllocated = TRUE;

		if(Types && XPoints.Data)
		{
			GpMemcpy(Types, types, count);
			REALD* data = XPoints.Data;
			for(INT i = 0; i < count; i++)
			{
				*data++ = pts->X;
				*data++ = pts->Y;
				pts++;
			}
			SetValid(TRUE);
		}
		FillMode = ((GpPath*) path)->GetFillMode();
	}
}

GpXPath::GpXPath(
	const GpPath* path,
    const GpRectF& rect,
    const GpPointF* points,
    INT count,
	WarpMode warpMode
	)
{
    InitDefaultState();

    if(warpMode == WarpModePerspective)
        ConvertToPerspectivePath(path, rect, points, count);
    else if(warpMode == WarpModeBilinear)
        ConvertToBilinearPath(path, rect, points, count);
}

GpStatus
GpXPath::ConvertToPerspectivePath(
    const GpPath* path,
    const GpRectF& rect,
    const GpPointF* points,
    INT count
    )
{
    ASSERT(path && path->IsValid());

	if(!path || !path->IsValid())
		return InvalidParameter;

	// Obtain the path points.

	const GpPointF* pathPts = ((GpPath*) path)->GetPathPoints();
    const BYTE* pathTypes = ((GpPath*) path)->GetPathTypes();
	INT pathCount = path->GetPointCount();

    BYTE* types = (BYTE*) GpMalloc(pathCount);

    if(!types)
        return OutOfMemory;

    GpMemcpy(types, pathTypes, pathCount);

    // Set the perspective transform.

	GpPerspectiveTransform trans(rect, points, count);
    
	// Convert the path points to 3D perspective points.

    REALD* data = (REALD*) GpMalloc(3*pathCount*sizeof(REALD));

	if(!data)
		return OutOfMemory;

    // Use this data for xpoints.

	XPoints.Count = pathCount;
    XPoints.Dimension = 3;
    XPoints.Data = data;
    XPoints.IsDataAllocated = TRUE;

    Types = types;
    GpStatus status = trans.ConvertPoints(pathPts, pathCount, &XPoints);

    if(status == Ok)
        SetValid(TRUE);

    return status;
}

GpStatus
GpXPath::ConvertToBilinearPath(
    const GpPath* path,
    const GpRectF& rect,
    const GpPointF* points,
    INT count
    )
{
    ASSERT(path && path->IsValid());

	if(!path || !path->IsValid())
		return InvalidParameter;

	// Obtain the path points.

	const GpPointF* pathPts = ((GpPath*) path)->GetPathPoints();
	const BYTE* pathTypes = ((GpPath*) path)->GetPathTypes();
	INT pathCount = path->GetPointCount();

    // The maximum data size of the bilinear transform is
    // 2*pathCount - 1.  Here set it as 2*pathCount.

    INT dimension = 2;
	INT maxCount = 2*pathCount;
	REALD* data = (REALD*) GpMalloc(dimension*maxCount*sizeof(REALD));
    BYTE* types = (BYTE*) GpMalloc(maxCount);

	if(!data || !types)
    {
        GpFree(data);
        GpFree(types);

		return OutOfMemory;
    }
    
	GpMemset(types, 0, maxCount);

    // Set the bilinear transform.

	GpBilinearTransform trans(rect, points, count);

    DpPathIterator iter(pathPts, pathTypes, pathCount);

    INT startIndex, endIndex;
    BOOL isClosed;
    GpStatus status = Ok;
    REALD* dataPtr = data;

    INT totalCount = 0; // Number of control points.

    while(
		iter.NextSubpath(
		&startIndex, &endIndex, &isClosed)
		&& status == Ok
		)
    {
        INT typeStartIndex, typeEndIndex;
        BYTE pathType;
        BOOL isFirstPoint = TRUE;

        while(
			iter.NextPathType(&pathType, &typeStartIndex, &typeEndIndex)
            && status == Ok
			)
        {
            // Starting point of the current suptype
            // and the number of points.

            const GpPointF* pts = pathPts + typeStartIndex;
            INT typeCount = typeEndIndex - typeStartIndex + 1;

            switch(pathType)
            {
			case PathPointTypeBezier3:
                trans.ConvertCubicBeziers(pts, typeCount, dataPtr);
                pts += typeCount - 1;
                dataPtr += dimension*2*(typeCount - 1);

                if(isFirstPoint)
                {
                    *(types + totalCount) = PathPointTypeStart;
                    totalCount++;
                }
                
                GpMemset(types + totalCount, PathPointTypeBezier6, 2*(typeCount - 1));
                totalCount += 2*(typeCount - 1);
                isFirstPoint = FALSE;
                break;           
            
            case PathPointTypeLine:
                trans.ConvertLines(pts, typeCount, dataPtr);
                pts += typeCount - 1;
                dataPtr += dimension*2*(typeCount - 1);

                if(isFirstPoint)
                {
                    *(types + totalCount) = PathPointTypeStart;
                    totalCount++;
                }

                GpMemset(types + totalCount, PathPointTypeBezier2, 2*(typeCount - 1));
                totalCount += 2*(typeCount - 1);
                isFirstPoint = FALSE;
                break;

            case PathPointTypeStart:
            case PathPointTypeBezier2:
            case PathPointTypeBezier4:
            case PathPointTypeBezier5:
	    case PathPointTypeBezier6:
            default:
                // Should not have any of those types in GpPath.
                
                ASSERT(0);
                break;
            }
        }
    }

    Types = types;
    XPoints.Count = totalCount;
    XPoints.Dimension = dimension;
    XPoints.Data = data;
    XPoints.IsDataAllocated = TRUE;
    SetValid(TRUE);

    return Ok;
}

GpStatus
GpXPath::Flatten(
    DynByteArray* flattenTypes,
    DynPointFArray* flattenPoints,
    const GpMatrix *matrix
    )
{
    GpStatus status = Ok;

    ASSERT(matrix);

    FPUStateSaver fpuState;  // Setup the FPU state.

    flattenPoints->Reset(FALSE);
    flattenTypes->Reset(FALSE);

	INT dimension = XPoints.Dimension;
	REALD* data = XPoints.Data;

    GpXPathIterator iter(this);

    INT startIndex, endIndex;
    BOOL isClosed;

	GpPointF* ptsBuffer = NULL;

    while(
		iter.NextSubpath(
		&startIndex, &endIndex, &isClosed)
		&& status == Ok
		)
    {
        INT typeStartIndex, typeEndIndex;
        BYTE pathType;
        BOOL isFirstPoint = TRUE;

        while(
			iter.NextPathType(&pathType, &typeStartIndex, &typeEndIndex)
            && status == Ok
			)
        {
			INT count, index;
			BYTE* types;
			GpPointF* pts;

            switch(pathType)
            {
            case PathPointTypeStart:
                break;

            case PathPointTypeBezier2:
			case PathPointTypeBezier3:
			case PathPointTypeBezier4:
			case PathPointTypeBezier5:
			case PathPointTypeBezier6:
				{
					BOOL dontCopy = FALSE;
					GpXBezier bezier;
					GpXPoints xpoints;
					INT order;

					xpoints.SetData(
						data + typeStartIndex*dimension,
						dimension,
						typeEndIndex - typeStartIndex + 1,
						dontCopy	// Don't copy the data.
						);
					order = (INT) pathType;
					if(bezier.SetBeziers(order, xpoints) == Ok)
					{
						// Flatten() flattens Bezier.
						// The flattened points are already transformed.
						
                        DynPointFArray bezierFlattenPts;

                        bezier.Flatten(&bezierFlattenPts, matrix);
//						count = bezier.GetFlattenCount();
                        count = bezierFlattenPts.GetCount();

						// Check if there is already the first point.
						if(!isFirstPoint)
							count--;    // Don't add the first point.

						if (count > 0)
						{

							if((types = flattenTypes->AddMultiple(count)) != NULL)
							{
//								pts = bezier.GetFlattenData();
                                pts = bezierFlattenPts.GetDataBuffer();

								if(!isFirstPoint)
									pts++;  // Skip the first point.

								flattenPoints->AddMultiple(pts, count);
								GpMemset(types, PathPointTypeLine, count);
								if(isFirstPoint)
									types[0] = PathPointTypeStart;

								isFirstPoint = FALSE;
							}
							else
								status = OutOfMemory;

						}

					}
					else
						status =InvalidParameter;
				}

                break;           
            
            case PathPointTypeLine:
            default:
                count = typeEndIndex - typeStartIndex + 1;

                if(!isFirstPoint)
                    count--;

                if((types = flattenTypes->AddMultiple(count)) != NULL)
                {
                    // Set the type.

					GpMemset(types, PathPointTypeLine, count);
                    if(isFirstPoint)
                        types[0] = PathPointTypeStart;

					// Get the first data.

					REALD* dataPtr = data + typeStartIndex*dimension;
					if(!isFirstPoint)
						dataPtr += dimension;	// Skip the first point.

                    // Allocate the point buffer to save
					// for the flatten points.

					pts = (GpPointF*) GpRealloc(ptsBuffer,
						count*sizeof(GpPointF));

					if(!pts)
					{
						status = OutOfMemory;
						break;
					}
					else
						ptsBuffer = pts;

					// Copy the data

					GpPointF* ptsPtr = pts;

					for(INT k = 0; k < count; k++)
					{
						// Simply copy the first 2 elments
						// of the data as the x and y component.

						REALD x, y, w;

                        x = *dataPtr++;
						y = *dataPtr++;

                        // Do the perspective projection if
                        // dimension  is higher than 2.

                        if(dimension > 2)
                        {
                            w = *dataPtr;
                            x /= w;
                            y /= w;
                        }

                        ptsPtr->X = TOREAL(x);
                        ptsPtr->Y = TOREAL(y);

						ptsPtr++;
						
						// Skip the rest.

						if(dimension > 2)
							dataPtr += (dimension - 2);
					}

                    // Add to the flatten points.

					index = flattenPoints->GetCount();
					flattenPoints->AddMultiple(pts, count);

                    // Get the data biffer of the flatten points.

					pts = flattenPoints->GetDataBuffer();

                    // Transform the newly added points.

					matrix->Transform(pts + index, count);

                    isFirstPoint = FALSE;
                }
                
                break;
            }
        }

        // This is the end of the current subpath.  Close subpath
        // if necessary.

        if(isClosed)
        {
             BYTE* typeBuffer = flattenTypes->GetDataBuffer();
             INT lastCount = flattenTypes->GetCount();
             typeBuffer[lastCount - 1] |= PathPointTypeCloseSubpath;
        }
    }

	if(ptsBuffer)
		GpFree(ptsBuffer);

    return status;
}


/**************************************************************************\
*
* GpXPathIterator class
*
*   11/08/1999 ikkof
*       Created it.
*
\**************************************************************************/

GpXPathIterator::GpXPathIterator(GpXPath* xpath)
{
    Initialize();

    if(xpath && xpath->IsValid())
    {
        TotalCount = xpath->GetPointCount();
        XPoints.SetData(
            xpath->GetPathPoints(),
            xpath->GetPointDimension(),
            TotalCount,
            FALSE   // Don't copy data.
            );
        Types = xpath->GetPathTypes();
    }

    // Check if this path is valid.

    if(
        XPoints.Data
        && XPoints.Dimension > 0
        && XPoints.Count > 0
        && Types
        && TotalCount > 0
        )
    {
        SetValid(TRUE);
    }
}

VOID
GpXPathIterator::Initialize()
{
//    XPath = NULL;
    Types = NULL;
    TotalCount = 0;
    Index = 0;
    SubpathStartIndex = 0;
    SubpathEndIndex = 0;
    TypeStartIndex = 0;
    TypeEndIndex = 0;
    SetValid(FALSE);
}


INT
GpXPathIterator::Enumerate(GpXPoints* xpoints, BYTE* types)
{
    if(!IsValid())
        return 0;

    ASSERT(xpoints && types);
    if(xpoints == NULL || types == NULL)
        return 0;

    INT inputSize = xpoints->Dimension*xpoints->Count;

    ASSERT(xpoints->Data && inputSize > 0);
    if(xpoints->Data == NULL || inputSize <= 0)
        return 0;

    if(Index >= TotalCount)
        return 0;

    // Make sure the resultant dimension is the same as
    // the internal dimension.

    INT dimension = XPoints.Dimension;
    if(xpoints->Dimension != dimension)
    {
        xpoints->Dimension = dimension;
        xpoints->Count = inputSize/dimension;
    }

    INT number = min(TotalCount - Index, xpoints->Count);
    GpMemcpy(
        xpoints->Data,
        XPoints.Data + Index*dimension,
        number*dimension*sizeof(REALD));
    GpMemcpy(types, Types + Index, number*sizeof(BYTE));

    Index += number;
    
    return number;
}

INT
GpXPathIterator::NextSubpath(INT* startIndex, INT* endIndex, BOOL *isClosed)
{
    if(!IsValid())
        return 0;
    
    INT count = TotalCount;

    if(SubpathEndIndex >= count - 1)
        return 0;

    const BYTE* types = Types;

    INT i;

    // Set the starting index of the current subpath.

    if(SubpathEndIndex == 0)
    {
        SubpathStartIndex = 0;
        i = 1;
    }
    else
    {
        SubpathStartIndex = SubpathEndIndex + 1;
        SubpathEndIndex = SubpathStartIndex;
        i = SubpathStartIndex + 1;
    }

    BOOL hasData = FALSE;
    INT segmentCount = 0;

    while(i < count)
    {
        // Do the move segments.

        segmentCount = 0;
        while(i < count && (types[i] & PathPointTypePathTypeMask) == PathPointTypeStart)
        {
            segmentCount++;
            if(hasData)
            {
                break;
            }
            else
            {
                SubpathStartIndex = i;
                SubpathEndIndex = SubpathStartIndex;
                i++;
            }
        }
        if(segmentCount > 0 && hasData)
        {
            SubpathEndIndex = i - 1;
            break;
        }
        
        // Do the non-move segments.
        
        segmentCount = 0;
        BYTE nextType = types[i] & PathPointTypePathTypeMask;
        while(i < count && (types[i] & PathPointTypePathTypeMask) == nextType)
        {
            i++;
            segmentCount++;
        }
        if(segmentCount > 0)
        {
            hasData = TRUE;
        }
    }

    *startIndex = SubpathStartIndex;
    if(i >= count)
        SubpathEndIndex = count - 1;    // The last subpath.
    *endIndex = SubpathEndIndex;
    segmentCount = SubpathEndIndex - SubpathStartIndex + 1;
    if(segmentCount <= 1)   // Start and end point is the same.
        segmentCount = 0;

    if(segmentCount > 1)
    {
        // If there is the close flag or the start and end points match,
        // this subpath is closed.

        if(
            (types[SubpathEndIndex] & PathPointTypeCloseSubpath)
            || XPoints.AreEqualPoints(SubpathStartIndex, SubpathEndIndex)
        )
        {
            *isClosed = TRUE;
        }
        else
            *isClosed = FALSE;
    }
    else
        *isClosed = FALSE;
    
    // Set the current index to the starting index of the current subpath.

    Index = SubpathStartIndex;

    // Set the start and end index of type to be the starting index of
    // the current subpath.  NextPathType() will start from the
    // beginning of the current subpath.

    TypeStartIndex = TypeEndIndex = SubpathStartIndex;

    return segmentCount;
}


INT
GpXPathIterator::EnumerateSubpath(
    GpXPoints* xpoints,
    BYTE* types
    )
{
    if(!IsValid())
        return 0;

    ASSERT(xpoints && types);
    if(xpoints == NULL || types == NULL)
        return 0;
    
    INT inputSize = xpoints->Dimension*xpoints->Count;

    ASSERT(xpoints->Data && inputSize > 0);
    if(xpoints->Data == NULL || inputSize <= 0)
        return 0;

    if(Index > SubpathEndIndex)
        return 0;

    // Make sure the resultant dimension is the same as
    // the internal dimension.

    INT dimension = XPoints.Dimension;
    if(xpoints->Dimension != dimension)
    {
        xpoints->Dimension = dimension;
        xpoints->Count = inputSize/dimension;
    }

    INT number = min(SubpathEndIndex - Index + 1, xpoints->Count);

    GpMemcpy(
        xpoints->Data,
        XPoints.Data + Index*dimension,
        number*dimension*sizeof(REALD));
    GpMemcpy(types, Types + Index, number*sizeof(BYTE));

    Index += number;
    
    return number;
}


INT
GpXPathIterator::NextPathType(
    BYTE* pathType,
    INT* startIndex,
    INT* endIndex
    )
{
    if(!IsValid())
        return 0;
    
    if(TypeEndIndex >= SubpathEndIndex)
        return 0;   // There is no more segment in the current subpath.

    INT count = SubpathEndIndex + 1;    // Limit for the ending index.
    const BYTE* types = Types;

    TypeStartIndex = TypeEndIndex;
    INT i = TypeStartIndex;
    INT segmentCount = 0;

    i++;    // Go to the next point.

    while(i < count)
    {
        // Do the move segments.

        segmentCount = 0;
        while(i < count && (types[i] & PathPointTypePathTypeMask) == PathPointTypeStart)
        {
            // Move the start and end index.

            TypeStartIndex = i;
            TypeEndIndex = TypeStartIndex;
            i++;
            segmentCount++;
        }
        
        // Do the non-move segments.
        
        segmentCount = 0;
        BYTE nextType = types[i] & PathPointTypePathTypeMask;
        while(i < count && (types[i] & PathPointTypePathTypeMask) == nextType)
        {
            i++;
            segmentCount++;
        }
        if(segmentCount > 0)
        {
            TypeEndIndex = TypeStartIndex + segmentCount;
            *pathType = nextType;
            break;
        }
    }

    *startIndex = TypeStartIndex;
    *endIndex = TypeEndIndex;
    segmentCount = TypeEndIndex - TypeStartIndex + 1;
    if(segmentCount <= 1)
    {
        // Start and End type index is the same.  This means there is
        // no more segment left.

        segmentCount = 0;
    }

    // Set the current index to the starting index of the current subpath.

    Index = TypeStartIndex;

    return segmentCount;   
}


INT
GpXPathIterator::EnumeratePathType(
    GpXPoints* xpoints,
    BYTE* types
    )
{
    if(!IsValid())
        return 0;

    ASSERT(xpoints && types);
    if(xpoints == NULL || types == NULL)
        return 0;
    
    INT inputSize = xpoints->Dimension*xpoints->Count;

    ASSERT(xpoints->Data && inputSize > 0);
    if(xpoints->Data == NULL || inputSize <= 0)
        return 0;

    if(Index > TypeEndIndex)
        return 0;

    // Make sure the resultant dimension is the same as
    // the internal dimension.

    INT dimension = XPoints.Dimension;
    if(xpoints->Dimension != dimension)
    {
        xpoints->Dimension = dimension;
        xpoints->Count = inputSize/dimension;
    }

    INT number = min(TypeEndIndex - Index + 1, xpoints->Count);

    GpMemcpy(
        xpoints->Data,
        XPoints.Data + Index*dimension,
        number*dimension*sizeof(REALD));
    GpMemcpy(types, Types + Index, number*sizeof(BYTE));

    Index += number;
    
    return number;
}