/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"
#include <tools/vcompat.hxx>

#include <vcl/graphictools.hxx>

static ::rtl::OString polyToString( const Polygon& rPoly )
{
    ::rtl::OString aStr;
    sal_uInt16 nVertex;
    for(nVertex=0; nVertex<rPoly.GetSize(); ++nVertex)
    {
        aStr += "(";
        switch( rPoly.GetFlags(nVertex) )
        {
            case POLY_NORMAL:
            case POLY_SMOOTH:
            case POLY_SYMMTR:
                aStr += "n: ";
                break;

            case POLY_CONTROL:
                aStr += "c: ";
                break;

            default:
                DBG_ERROR( "SvtGraphicStroke::polyToString invalid flag");
                break;
        }
        aStr += ::rtl::OString::valueOf( static_cast< double >( rPoly[nVertex].getX() ) );
        aStr += ",";
        aStr += ::rtl::OString::valueOf( static_cast< double >( rPoly[nVertex].getY() ) );
        aStr += ") ";
    }    

    return aStr;
}

static ::rtl::OString polyPolyToString( const PolyPolygon& rPolyPoly )
{
    ::rtl::OString aStr;
    sal_uInt16 nPoly;
    for(nPoly=0; nPoly<rPolyPoly.Count(); ++nPoly)
    {
        const Polygon& rPoly = rPolyPoly[nPoly];

        aStr += "{ ";
        aStr += polyToString( rPoly );
        aStr += "} ";
    }

    return aStr;
}

static ::rtl::OString dashToString( const SvtGraphicStroke::DashArray& rDashArray )
{
    ::rtl::OString aStr;

    aStr += "dash: [ ";

    int i, nDashes( rDashArray.size() );
    for(i=0; i<nDashes; ++i)
    {
        aStr += ::rtl::OString::valueOf( rDashArray[i] );
        aStr += " ";
    }

    aStr += "] ";

    return aStr;
}

static ::rtl::OString colorToString( Color aColor )
{
    ::rtl::OString aStr;

    aStr += "color: [ ";
    aStr += ::rtl::OString::valueOf( aColor.GetRed() );
    aStr += " ";
    aStr += ::rtl::OString::valueOf( aColor.GetGreen() );
    aStr += " ";
    aStr += ::rtl::OString::valueOf( aColor.GetBlue() );
    aStr += " ] ";

    return aStr;
}

////////////////////////////////////////////////////////////////////////////

SvtGraphicFill::Transform::Transform()
{
    matrix[0] = 1.0; matrix[1] = 0.0; matrix[2] = 0.0;
    matrix[3] = 0.0; matrix[4] = 1.0; matrix[5] = 0.0;
} 

////////////////////////////////////////////////////////////////////////////

SvtGraphicStroke::SvtGraphicStroke() :
    maPath(),
    maStartArrow(),
    maEndArrow(),
    mfTransparency(),
    mfStrokeWidth(),
    maCapType(),
    maJoinType(),
    mfMiterLimit( 3.0 ),
    maDashArray()
{ 
}

SvtGraphicStroke::SvtGraphicStroke( const Polygon& 		rPath,
                                    const PolyPolygon&	rStartArrow,
                                    const PolyPolygon&	rEndArrow,
                                    double				fTransparency,
                                    double 				fStrokeWidth,
                                    CapType				aCap,
                                    JoinType			aJoin,
                                    double				fMiterLimit,
                                    const DashArray&	rDashArray	) :
    maPath( rPath ),
    maStartArrow( rStartArrow ),
    maEndArrow( rEndArrow ),
    mfTransparency( fTransparency ),
    mfStrokeWidth( fStrokeWidth ),
    maCapType( aCap ),
    maJoinType( aJoin ),
    mfMiterLimit( fMiterLimit ),
    maDashArray( rDashArray )
{
}

void SvtGraphicStroke::getPath( Polygon& rPath ) const
{
    rPath = maPath;
}

void SvtGraphicStroke::getStartArrow( PolyPolygon& rPath ) const
{
    rPath = maStartArrow;
}

void SvtGraphicStroke::getEndArrow( PolyPolygon& rPath ) const
{
    rPath = maEndArrow;
}

double SvtGraphicStroke::getTransparency() const
{
    return mfTransparency;
}

double SvtGraphicStroke::getStrokeWidth() const
{
    return mfStrokeWidth;
}

SvtGraphicStroke::CapType SvtGraphicStroke::getCapType() const
{
    return maCapType;
}

SvtGraphicStroke::JoinType SvtGraphicStroke::getJoinType() const
{
    return maJoinType;
}

double SvtGraphicStroke::getMiterLimit() const
{
    return mfMiterLimit;
}

void SvtGraphicStroke::getDashArray( DashArray& rDashArray ) const
{
    rDashArray = maDashArray;
}

::rtl::OString SvtGraphicStroke::toString() const
{
    ::rtl::OString aStr;

    aStr += polyToString( maPath );
    aStr += "trans: ";
    aStr += ::rtl::OString::valueOf( static_cast< double >(getTransparency()) ); 
    aStr += " width: ";
    aStr += ::rtl::OString::valueOf( static_cast< double >(getStrokeWidth()) );
    aStr += " cap: ";
    switch( getCapType() )
    {
        case capButt:
            aStr += "butt";
            break;

        case capRound:
            aStr += "round";
            break;

        case capSquare:
            aStr += "square";
            break;

        default:
            DBG_ERROR( "SvtGraphicStroke::toString missing cap type");
            break;
    }
    aStr += " join: ";
    switch( getJoinType() )
    {
        case joinMiter:
            aStr += "miter";
            break;

        case joinRound:
            aStr += "round";
            break;

        case joinBevel:
            aStr += "bevel";
            break;

        case joinNone:
            aStr += "none";
            break;

        default:
            DBG_ERROR( "SvtGraphicStroke::toString missing join type");
            break;
    }
    aStr += " ";

    if( maStartArrow.Count() )
    {
        aStr += "start: ";
        aStr += polyPolyToString( maStartArrow );
        aStr += " ";
    }

    if( maEndArrow.Count() )
    {
        aStr += "end: ";
        aStr += polyPolyToString( maEndArrow );
        aStr += " ";
    }

    aStr += dashToString( maDashArray );

    return aStr;
}

void SvtGraphicStroke::setPath( const Polygon& rPoly )
{
    maPath = rPoly;
}

void SvtGraphicStroke::setStartArrow( const PolyPolygon& rPoly )
{
    maStartArrow = rPoly;
}

void SvtGraphicStroke::setEndArrow( const PolyPolygon& rPoly )
{
    maEndArrow = rPoly;
}

void SvtGraphicStroke::setTransparency( double fTrans )
{
    mfTransparency = fTrans;
}

void SvtGraphicStroke::setStrokeWidth( double fWidth )
{
    mfStrokeWidth = fWidth;
}

void SvtGraphicStroke::setCapType( CapType eType )
{
    maCapType = eType;
}

void SvtGraphicStroke::setJoinType( JoinType eType )
{
    maJoinType = eType;
}

void SvtGraphicStroke::setMiterLimit( double fMiterLimit )
{
    mfMiterLimit = fMiterLimit;
}

void SvtGraphicStroke::setDashArray( const DashArray& rDashArray )
{
    maDashArray = rDashArray;
}

SvStream& operator<<( SvStream& rOStm, const SvtGraphicStroke& rClass )
{
	VersionCompat aCompat( rOStm, STREAM_WRITE, 1 );
	
    rClass.maPath.Write( rOStm );
    rClass.maStartArrow.Write( rOStm );
    rClass.maEndArrow.Write( rOStm );
    rOStm << rClass.mfTransparency;
    rOStm << rClass.mfStrokeWidth;
    sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maCapType );
    rOStm << nTmp;
    nTmp = sal::static_int_cast<sal_uInt16>( rClass.maJoinType );
    rOStm << nTmp;
    rOStm << rClass.mfMiterLimit;

    rOStm << static_cast<sal_uInt32>(rClass.maDashArray.size());
    size_t i;
    for(i=0; i<rClass.maDashArray.size(); ++i)
        rOStm << rClass.maDashArray[i];

	return rOStm;
}

SvStream& operator>>( SvStream& rIStm, SvtGraphicStroke& rClass )
{
	VersionCompat aCompat( rIStm, STREAM_READ );
	
    rClass.maPath.Read( rIStm );
    rClass.maStartArrow.Read( rIStm );
    rClass.maEndArrow.Read( rIStm );
    rIStm >> rClass.mfTransparency;
    rIStm >> rClass.mfStrokeWidth;
    sal_uInt16 nTmp;
    rIStm >> nTmp;
    rClass.maCapType = SvtGraphicStroke::CapType(nTmp);
    rIStm >> nTmp;
    rClass.maJoinType = SvtGraphicStroke::JoinType(nTmp);
    rIStm >> rClass.mfMiterLimit;

    sal_uInt32 nSize;
    rIStm >> nSize;
    rClass.maDashArray.resize(nSize);
    size_t i;
    for(i=0; i<rClass.maDashArray.size(); ++i)
        rIStm >> rClass.maDashArray[i];
	
	return rIStm;
}


/////////////////////////////////////////////////////////////////////////////

SvtGraphicFill::SvtGraphicFill() :
    maPath(),
    maFillColor( COL_BLACK ),
    mfTransparency(),
    maFillRule(),
    maFillType(),
    maFillTransform(),
    maHatchType(),
    maHatchColor( COL_BLACK ),
    maGradientType(),
    maGradient1stColor( COL_BLACK ),
    maGradient2ndColor( COL_BLACK ),
    maGradientStepCount( gradientStepsInfinite ),
    maFillGraphic()
{
}

SvtGraphicFill::SvtGraphicFill( const PolyPolygon& 	rPath,
                                Color				aFillColor,
                                double				fTransparency,
                                FillRule			aFillRule,
                                FillType			aFillType,
                                const Transform&	aFillTransform,
                                bool				bTiling,
                                HatchType			aHatchType,
                                Color				aHatchColor,
                                GradientType		aGradientType,
                                Color				aGradient1stColor,
                                Color				aGradient2ndColor,
                                int					aGradientStepCount,
                                const Graphic&		aFillGraphic ) :
    maPath( rPath ),
    maFillColor( aFillColor ),
    mfTransparency( fTransparency ),
    maFillRule( aFillRule ),
    maFillType( aFillType ),
    maFillTransform( aFillTransform ),
    mbTiling( bTiling ),
    maHatchType( aHatchType ),
    maHatchColor( aHatchColor ),
    maGradientType( aGradientType ),
    maGradient1stColor( aGradient1stColor ),
    maGradient2ndColor( aGradient2ndColor ),
    maGradientStepCount( aGradientStepCount ),
    maFillGraphic( aFillGraphic )
{
}

void SvtGraphicFill::getPath( PolyPolygon& rPath ) const
{
    rPath = maPath;
}

Color SvtGraphicFill::getFillColor() const
{
    return maFillColor;
}

double SvtGraphicFill::getTransparency() const
{
    return mfTransparency;
}

SvtGraphicFill::FillRule SvtGraphicFill::getFillRule() const
{
    return maFillRule;
}

SvtGraphicFill::FillType SvtGraphicFill::getFillType() const
{
    return maFillType;
}

void SvtGraphicFill::getTransform( Transform& rTrans ) const
{
    rTrans = maFillTransform;
}

bool SvtGraphicFill::IsTiling() const
{
    return mbTiling;
}

bool SvtGraphicFill::isTiling() const
{
    return mbTiling;
}

SvtGraphicFill::HatchType SvtGraphicFill::getHatchType() const
{
    return maHatchType;
}

Color SvtGraphicFill::getHatchColor() const
{
    return maHatchColor;
}

SvtGraphicFill::GradientType SvtGraphicFill::getGradientType() const
{
    return maGradientType;
}

Color SvtGraphicFill::getGradient1stColor() const
{
    return maGradient1stColor;
}

Color SvtGraphicFill::getGradient2ndColor() const
{
    return maGradient2ndColor;
}

int SvtGraphicFill::getGradientStepCount() const
{
    return maGradientStepCount;
}

void SvtGraphicFill::getGraphic( Graphic& rGraphic ) const
{
    rGraphic = maFillGraphic;
}

::rtl::OString SvtGraphicFill::toString() const
{
    ::rtl::OString aStr;

    aStr += polyPolyToString( maPath );
    aStr += "fill";
    aStr += colorToString( getFillColor() );
    aStr += " trans: ";
    aStr += ::rtl::OString::valueOf( static_cast< double >(getTransparency()) ); 
    aStr += " rule: ";
    switch( getFillRule() )
    {
        case fillNonZero:
            aStr += "nonzero";
            break;

        case fillEvenOdd:
            aStr += "evenodd";
            break;

        default:
            DBG_ERROR( "SvtGraphicFill::toString missing fill rule");
            break;
    }
    aStr += " type: ";
    switch( getFillType() )
    {
        case fillSolid:
            aStr += "solid";
            break;

        case fillGradient:
            aStr += "gradient";
            break;

        case fillHatch:
            aStr += "hatch";
            break;

        case fillTexture:
            aStr += "bitmap";
            break;

        default:
            DBG_ERROR( "SvtGraphicStroke::toString missing fill type");
            break;
    }

    aStr += " transform: [ ";
    int i;
    for(i=0; i<Transform::MatrixSize; ++i)
        aStr += ::rtl::OString::valueOf( maFillTransform.matrix[i] ); 
    aStr += " ] ";

    aStr += " hatch: ";
    switch( getHatchType() )
    {
        case hatchSingle:
            aStr += "single";
            break;

        case hatchDouble:
            aStr += "double";
            break;

        case hatchTriple:
            aStr += "triple";
            break;

        default:
            DBG_ERROR( "SvtGraphicStroke::toString missing hatch type");
            break;
    }

    aStr += " hatch";
    aStr += colorToString( getHatchColor() );

    aStr += " gradient: ";
    switch( getGradientType() )
    {
        case gradientLinear:
            aStr += "linear";
            break;

        case gradientRadial:
            aStr += "radial";
            break;

        case gradientRectangular:
            aStr += "rectangular";
            break;

        default:
            DBG_ERROR( "SvtGraphicStroke::toString missing gradient type");
            break;
    }

    aStr += " grad1st";
    aStr += colorToString( getGradient1stColor() );

    aStr += " grad2nd";
    aStr += colorToString( getGradient2ndColor() );

    aStr += " gradstep";
    aStr += ::rtl::OString::valueOf( (sal_Int32)getGradientStepCount() );

    if( maFillGraphic.GetType() != GRAPHIC_NONE )
    {
        aStr += " fillgraphic: ";
        switch( maFillGraphic.GetType() )
        {
            case GRAPHIC_BITMAP:
                aStr += "bitmap"; 
                break;

            case GRAPHIC_GDIMETAFILE:
                aStr += "metafile"; 
                break;

            case GRAPHIC_DEFAULT:
                aStr += "default"; 
                break;

            default:
                DBG_ERROR( "SvtGraphicStroke::toString missing graphic type");
                break;
        }

        aStr += " of ";
        aStr += ::rtl::OString::valueOf( static_cast< sal_Int32 >(maFillGraphic.GetSizeBytes()) ); 
        aStr += " bytes";
    }

    return aStr;
}

void SvtGraphicFill::setPath( const PolyPolygon& rPath )
{
    maPath = rPath;
}

void SvtGraphicFill::setFillColor( Color aFillColor )
{
    maFillColor = aFillColor;
}

void SvtGraphicFill::setTransparency( double fTransparency )
{
    mfTransparency = fTransparency;
}

void SvtGraphicFill::setFillRule( FillRule aFillRule )
{
    maFillRule = aFillRule;
}

void SvtGraphicFill::setFillType( FillType aFillType )
{
    maFillType = aFillType;
}

void SvtGraphicFill::setTransform( const Transform& rTransform )
{
    maFillTransform = rTransform;
}

void SvtGraphicFill::setTiling( bool bTiling )
{
    mbTiling = bTiling;
}

void SvtGraphicFill::setHatchType( HatchType aHatchType )
{
    maHatchType = aHatchType;
}

void SvtGraphicFill::setHatchColor( Color aHatchColor )
{
    maHatchColor = aHatchColor;
}

void SvtGraphicFill::setGradientType( GradientType aGradType )
{
    maGradientType = aGradType;
}

void SvtGraphicFill::setGradient1stColor( Color aColor )
{
    maGradient1stColor = aColor;
}

void SvtGraphicFill::setGradient2ndColor( Color aColor )
{
    maGradient2ndColor = aColor;
}

void SvtGraphicFill::setGradientStepCount( int aCount )
{
    maGradientStepCount = aCount;
}

void SvtGraphicFill::setGraphic( const Graphic& rGraphic )
{
    maFillGraphic = rGraphic;
}

SvStream& operator<<( SvStream& rOStm, const SvtGraphicFill& rClass )
{
	VersionCompat aCompat( rOStm, STREAM_WRITE, 1 );
	
    rClass.maPath.Write( rOStm );
    rOStm << rClass.maFillColor;
    rOStm << rClass.mfTransparency;
    sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillRule );
    rOStm << nTmp;
    nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillType );
    rOStm << nTmp;
    int i;
    for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i)
        rOStm << rClass.maFillTransform.matrix[i];
    nTmp = rClass.mbTiling;
    rOStm << nTmp;
    nTmp = sal::static_int_cast<sal_uInt16>( rClass.maHatchType );
    rOStm << nTmp;
    rOStm << rClass.maHatchColor;
    nTmp = sal::static_int_cast<sal_uInt16>( rClass.maGradientType );
    rOStm << nTmp;
    rOStm << rClass.maGradient1stColor;
    rOStm << rClass.maGradient2ndColor;
    rOStm << rClass.maGradientStepCount;
    rOStm << rClass.maFillGraphic;

	return rOStm;
}

SvStream& operator>>( SvStream& rIStm, SvtGraphicFill& rClass )
{
	VersionCompat aCompat( rIStm, STREAM_READ );
	
    rClass.maPath.Read( rIStm );
    rIStm >> rClass.maFillColor;
    rIStm >> rClass.mfTransparency;
    sal_uInt16 nTmp;
    rIStm >> nTmp;
    rClass.maFillRule = SvtGraphicFill::FillRule( nTmp );
    rIStm >> nTmp;
    rClass.maFillType = SvtGraphicFill::FillType( nTmp );
    int i;
    for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i)
        rIStm >> rClass.maFillTransform.matrix[i];
    rIStm >> nTmp;
    rClass.mbTiling = nTmp;
    rIStm >> nTmp;
    rClass.maHatchType = SvtGraphicFill::HatchType( nTmp );
    rIStm >> rClass.maHatchColor;
    rIStm >> nTmp;
    rClass.maGradientType = SvtGraphicFill::GradientType( nTmp );
    rIStm >> rClass.maGradient1stColor;
    rIStm >> rClass.maGradient2ndColor;
    rIStm >> rClass.maGradientStepCount;
    rIStm >> rClass.maFillGraphic;

	return rIStm;
}