/*
* Copyright (c) 2003 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:  SVG Implementation source file
 *
*/


#include "SVGTestsImpl.h"


// ---------------------------------------------------------------------------
// Two phase construction:
// - Implements the SVGTests DOM interface.
// - Partially implemented, only those required
//   for passing SVG Test Suite.
// ---------------------------------------------------------------------------
CSvgTestsImpl* CSvgTestsImpl::NewL()
    {
    CSvgTestsImpl* self = new ( ELeave ) CSvgTestsImpl();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgTestsImpl* CSvgTestsImpl::NewLC()
    {
    CSvgTestsImpl* self = new ( ELeave ) CSvgTestsImpl();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgTestsImpl::~CSvgTestsImpl()
    {
    if ( iRequiredFeatures )
		{
        delete iRequiredFeatures;
		iRequiredFeatures = NULL;
		}
    if ( iRequiredExtensions )
		{
        delete iRequiredExtensions;
		iRequiredExtensions = NULL;
		}
    if ( iSystemLanguage )
		{
        delete iSystemLanguage;
		iSystemLanguage = NULL;
		}
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTestsImpl::ConstructL()
    {
    iRequiredFeatures = new ( ELeave ) CDesCArrayFlat( 1 );
    iRequiredFeatures->Reset();
    iRequiredExtensions = new ( ELeave ) CDesCArrayFlat( 1 );
    iRequiredExtensions->Reset();
    iSystemLanguage = new ( ELeave ) CDesCArrayFlat( 1 );
    iSystemLanguage->Reset();

    iSystemLanguageEmpty = EFalse;
    }


// From MSvgTests

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTestsImpl::GetRequiredFeatures( const CDesCArrayFlat*& aRequiredFeatures )
    {
    aRequiredFeatures = iRequiredFeatures;
    }

// ---------------------------------------------------------------------------
// function for decoding
// ---------------------------------------------------------------------------
void CSvgTestsImpl::SetRequiredFeatures(  CDesCArrayFlat*& aRequiredFeatures )
    {
	if(iRequiredFeatures)
		{
		iRequiredFeatures->Reset();
		delete iRequiredFeatures;
		iRequiredFeatures= NULL;
		}
    iRequiredFeatures= aRequiredFeatures;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTestsImpl::GetRequiredExtensions( const CDesCArrayFlat*& aRequiredExtensions )
    {
    aRequiredExtensions = iRequiredExtensions;
    }

// ---------------------------------------------------------------------------
// function for decoding
// ---------------------------------------------------------------------------
void CSvgTestsImpl::SetRequiredExtensions(  CDesCArrayFlat*& aRequiredExtensions )
    {
	if(iRequiredExtensions)
		{
		iRequiredExtensions->Reset();
		delete iRequiredExtensions;
		iRequiredExtensions= NULL;
		}
    iRequiredExtensions= aRequiredExtensions;
    }

// ---------------------------------------------------------------------------
// returns false if there was an empty string system language true otherwise
// ---------------------------------------------------------------------------
TBool CSvgTestsImpl::GetSystemLanguage( const CDesCArrayFlat*& aSystemLanguage )
    {
    aSystemLanguage = iSystemLanguage;

    if (iSystemLanguageEmpty)
    	{
    		return EFalse;
    	}

    return ETrue;

    }

// ---------------------------------------------------------------------------
// function for decoding
// ---------------------------------------------------------------------------
void CSvgTestsImpl::SetSystemLanguage(  CDesCArrayFlat*& aSystemLanguage )
    {
	if(iSystemLanguage)
		{
		iSystemLanguage->Reset();
		delete iSystemLanguage;
		iSystemLanguage= NULL;
		}
    iSystemLanguage= aSystemLanguage;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool CSvgTestsImpl::HasExtension( const TDesC& /* aExtension */ )
    {
    return EFalse;
    }

// For use in requiredFeatures
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool CSvgTestsImpl::HasFeature( const TDesC& aFeature )
    {
    // SVG Tiny Feature List
    _LIT( KTiny, "http://www.w3.org/TR/SVGMobile/Tiny/feature#" );
    _LIT( KBase, "base" );
    _LIT( KInteractivity, "interactivity" );
    _LIT( KAll, "all" );

    // SVG 1.1 Feature List
    _LIT( KSVG11, "http://www.w3.org/TR/SVG11/feature#" );
    _LIT( KCoreAttr, "CoreAttribute" );
    _LIT( KBasicStr, "BasicStructure" );
    _LIT( KStyle, "Style" );
    _LIT( KPaintAttr, "PaintAttribute" );
    _LIT( KGraphicsAttr, "BasicGraphicsAttribute" );
    _LIT( KHyperlink, "Hyperlinking" );
    _LIT( KXlinkAttr, "XlinkAttribute" );
    _LIT( KCond, "ConditionalProcessing" );
    _LIT( KShape, "Shape" );
    _LIT( KImage, "Image" );
    _LIT( KBasicTest, "BasicText" );
    _LIT( KBasicFont, "BasicFont" );
    _LIT( KDocAttr,"DocumentEventsAttribute" );
    _LIT( KGraphEvt,"GraphicalEventsAttribute" );
    _LIT( KAnimEvt,"AnimationEventsAttribute" );
    _LIT( KScript, "Scripting" );
    _LIT( KView, "View" );
    _LIT( KAnim, "SVG-animation" );
    _LIT( KExt, "Extensibility" );

    _LIT( KSVG12, "http://www.w3.org/TR/SVG12/feature#" );
    _LIT( KAudio, "Audio");

    // SVG 1.2 Feature List
    // SVG Feature List
    _LIT( KStatic, "org.w3c.svg.static" );
    _LIT( KDynamic, "org.w3c.svg.dynamic" );

    TPtrC tinybase( KTiny );
    if( (aFeature.Length()-tinybase.Length()) > 1 )
        {
        TPtrC rightTiny= aFeature.Right(aFeature.Length()-tinybase.Length() );
        if ( rightTiny.Match(KBase) != KErrNotFound)
        return ETrue;
        if ( rightTiny.Match(KInteractivity) != KErrNotFound)
        return ETrue;
        if ( rightTiny.Match(KAll) != KErrNotFound )
        return ETrue;
        }

    TPtrC svg11base( KSVG11 );
    if( (aFeature.Length()-svg11base.Length()) > 1 )
        {
        TPtrC rightSvg11= aFeature.Right(aFeature.Length()-svg11base.Length() );
    if ( rightSvg11.Match(KAnim) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KCoreAttr) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KBasicStr) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KStyle) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KPaintAttr) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KGraphicsAttr) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KHyperlink) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KXlinkAttr) != KErrNotFound )
        return ETrue;
    if (rightSvg11.Match(KCond) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KShape) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KImage) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KBasicTest) != KErrNotFound )
        return ETrue;
    if (rightSvg11.Match(KBasicFont) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KDocAttr) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KGraphEvt) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KAnimEvt) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KScript)!= KErrNotFound )
        return EFalse;          // Scripting is not supported.
    if ( rightSvg11.Match(KView) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KAnim) != KErrNotFound )
        return ETrue;
    if ( rightSvg11.Match(KExt) != KErrNotFound )
        return ETrue;
        }

    TPtrC svg12base( KSVG12 );
    if( (aFeature.Length()-svg12base.Length()) > 1 )
        {
        TPtrC rightSvg12= aFeature.Right(aFeature.Length()-svg12base.Length() );
        if ( rightSvg12.Match(KAudio) != KErrNotFound )
            {
            return ETrue;
            }
        }

    if ( aFeature == KStatic )
        return ETrue;
    if ( aFeature == KDynamic )
        return EFalse;
    else
        return FALSE;
    }

TBool CSvgTestsImpl::HasAnyTests()
{
	const CDesCArrayFlat* tempTestArray = NULL;

	GetRequiredFeatures(tempTestArray);
	if (tempTestArray && tempTestArray->Count() > 0)
	{
		return ETrue;
	}

	GetSystemLanguage(tempTestArray);
	if (tempTestArray && tempTestArray->Count() > 0)
	{
		return ETrue;
	}

	GetRequiredExtensions(tempTestArray);
	if (tempTestArray && tempTestArray->Count() > 0)
	{
		return ETrue;
	}

	if (iSystemLanguageEmpty)
	{
		return ETrue;
	}

	return EFalse;
}

// Implementation

TBool CSvgTestsImpl::SetRequiredFeatureAttribute( const TDesC& aValue )
{
	TLex input( aValue );

    while ( !( input.Eos() ) )
    {
    	input.SkipSpace();
        input.Mark();
        input.SkipCharacters();
        TPtrC token = input.MarkedToken();    // then extract token
        TRAPD(error,iRequiredFeatures->AppendL( token ));

        if (error != KErrNone)
        {
        	//Error Processing
        	return EFalse;
        }
    }

    return ETrue;
}

TBool CSvgTestsImpl::SetRequiredExtensionAttribute( const TDesC& aValue )
{
	TLex input( aValue );

    if ( aValue.Length() == 0 )
    {
	    TRAPD(error1,iRequiredExtensions->AppendL( aValue ));

	    if (error1 != KErrNone)
	    {
        	//Error Processing
        	return EFalse;
	  	}
    }
    else
    {
    	while ( !( input.Eos() ) )
        {
        	input.SkipSpace();
            input.Mark();
            input.SkipCharacters();
            TPtrC token = input.MarkedToken();    // then extract token
            TRAPD(error,iRequiredExtensions->AppendL( token ));

            if (error != KErrNone)
            {
							//Error Processing
							return EFalse;
            }
        }
    }
    return ETrue;
}

TBool CSvgTestsImpl::SetSystemLanguageAttribute( const TDesC& aValue  )
{
	TLex input( aValue );

	iSystemLanguageEmpty = EFalse;

 	if ( input.Eos() )
    {
		iSystemLanguageEmpty = ETrue;
    }
    else
    {
    	while ( !( input.Eos() ) )
        {
        	input.SkipSpace();
            input.Mark();
            input.SkipCharacters();
            TPtrC token = input.MarkedToken();    // then extract token
            TRAPD(error,iSystemLanguage->AppendL( token ));

            if (error != KErrNone)
            {
							//Error Processing
							return EFalse;
          	}
        }
    }

    return ETrue;

}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool CSvgTestsImpl::SetTestAttributeL( const TDesC& aPropertyName,
                                        const TDesC& aValue )
{

    _LIT( KRequiredFeatures, "requiredFeatures" );
    _LIT( KRequiredExtensions, "requiredExtensions" );
    _LIT( KSystemLanguage, "systemLanguage" );

    if (aPropertyName == KRequiredFeatures)
    {
    	return SetRequiredFeatureAttribute(aValue);
    }
    else if (aPropertyName == KRequiredExtensions)
    {
    	return SetRequiredExtensionAttribute(aValue);
    }
    else if (aPropertyName == KSystemLanguage)
    {
    	return SetSystemLanguageAttribute(aValue);
    }
	else
	{
		return EFalse;
	}
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgTestsImpl* CSvgTestsImpl::CloneL()
    {
    CSvgTestsImpl* retValue = CSvgTestsImpl::NewL();

	CleanupStack::PushL(retValue);
    // no need to call Reset() on any of these arrays because
    // that already happened in the call to NewL above
    int i;

    // *** copy required features
    TInt requiredFeaturesCnt = this->iRequiredFeatures->Count();
    for (i=0; i< requiredFeaturesCnt; i++)
        {
        retValue->iRequiredFeatures->AppendL(this->iRequiredFeatures->operator[](i));
        }

    // *** copy required extensions
    TInt requiredExtensionsCnt = this->iRequiredExtensions->Count();
    for (i=0; i< requiredExtensionsCnt; i++)
        {
        retValue->iRequiredExtensions->AppendL(this->iRequiredExtensions->operator[](i));
        }

    // *** copy system language
    TInt systemLanguageCnt = this->iSystemLanguage->Count();
    for (i=0; i< systemLanguageCnt; i++)
        {
        retValue->iSystemLanguage->AppendL(this->iSystemLanguage->operator[](i));
        }
	CleanupStack::Pop();
    return retValue;
    }