/*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Graphics Extension Library source file
*
*/


#include "GfxEllipseIteratorP.h"
#include "GfxEllipse2D.h"



// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
// --------------------------------------------------------------------------
// CGfxEllipseIteratorP::CGfxEllipseIteratorP( TGfxEllipse2D* aEllipse,
// ---------------------------------------------------------------------------
CGfxEllipseIteratorP::CGfxEllipseIteratorP( TGfxEllipse2D* aEllipse,
                                            TGfxAffineTransform* aTransform )
    {
    TFloatFixPt KZero;
    if ( aEllipse->iWidth < KZero )
        aEllipse->iWidth = KZero;

    if ( aEllipse->iHeight < KZero )
        aEllipse->iHeight = KZero;

    iEllipse = aEllipse;
    iTransform = aTransform;
    }

// --------------------------------------------------------------------------
// TGfxSegType CGfxEllipseIteratorP::CurrentSegment( TFloatFixPt* aCoords )
// ---------------------------------------------------------------------------
TGfxSegType CGfxEllipseIteratorP::CurrentSegment( TFloatFixPt* aCoords )
    {
    TGfxSegType segtype;

    TInt32 pts = 3;

    TFloatFixPt px[12], py[12];

	#ifdef SVG_FLOAT_BUILD    
    TFloatFixPt cx = iEllipse->iX + (iEllipse->iWidth * TFloatFixPt(.5f));
    TFloatFixPt cy = iEllipse->iY + (iEllipse->iHeight * TFloatFixPt(.5f));
    TFloatFixPt offx = iEllipse->iWidth * TFloatFixPt(.257f);
    TFloatFixPt offy = iEllipse->iHeight * TFloatFixPt(.257f);
	#else	
    TFloatFixPt cx = iEllipse->iX + (iEllipse->iWidth >> 1);
    TFloatFixPt cy = iEllipse->iY + (iEllipse->iHeight >> 1);
    TFloatFixPt offx = TFloatFixPt( 0x41ca, ETrue ) * iEllipse->iWidth;
    TFloatFixPt offy = TFloatFixPt( 0x41ca, ETrue ) * iEllipse->iHeight;
	#endif

    px[0] = px[1] = px[11] = iEllipse->iX;
    px[2] = px[10] = cx - offx;
    px[3] = px[9] = cx;
    px[4] = px[8] = cx + offx;
    px[5] = px[6] = px[7] = iEllipse->iX + iEllipse->iWidth;

    py[2] = py[3] = py[4] = iEllipse->iY;
    py[1] = py[5] = cy - offy;
    py[0] = py[6] = cy;
    py[7] = py[11] = cy + offy;
    py[8] = py[9] = py[10] = iEllipse->iY + iEllipse->iHeight;

    TFloatFixPt* p = aCoords;
    switch ( iIdx )
        {
        case 0:
            p[0] = px[0];
            p[1] = py[0];
            segtype = EGfxSegMoveTo;
            pts = 1;
            break;
        case 1:
            p[0] = px[1];
            p[1] = py[1];
            p[2] = px[2];
            p[3] = py[2];
            p[4] = px[3];
            p[5] = py[3];
            segtype = EGfxSegCubicTo;
            break;
        case 2:
            p[0] = px[4];
            p[1] = py[4];
            p[2] = px[5];
            p[3] = py[5];
            p[4] = px[6];
            p[5] = py[6];
            segtype = EGfxSegCubicTo;
            break;
        case 3:
            p[0] = px[7];
            p[1] = py[7];
            p[2] = px[8];
            p[3] = py[8];
            p[4] = px[9];
            p[5] = py[9];
            segtype = EGfxSegCubicTo;
            break;
        case 4:
            p[0] = px[10];
            p[1] = py[10];
            p[2] = px[11];
            p[3] = py[11];
            p[4] = px[0];
            p[5] = py[0];
            segtype = EGfxSegCubicTo;
            break;
        default:
            segtype = EGfxSegClose;
            pts = 0;
        }



    if ( !iTransform->IsIdentity() && pts > 0 )
        {
        iTransform->Transform( aCoords, aCoords, pts );
        }

    return segtype;
    }

// --------------------------------------------------------------------------
// TBool CGfxEllipseIteratorP::IsDone()
// ---------------------------------------------------------------------------
TBool CGfxEllipseIteratorP::IsDone()
    {
    return ( iIdx > 4 );
    }

// --------------------------------------------------------------------------
// void CGfxEllipseIteratorP::NextL()
// ---------------------------------------------------------------------------
void CGfxEllipseIteratorP::NextL()
    {
    iIdx++;
    }