/*

* Copyright (c) 2003-2008 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:  Reader class.

*

*/

#include "SDCGlobals.h"

#include "SDCReader.h"

#include "SDCIIDConstants.h"

#include "SDCException.h"

#include "SDCCompat.h"

// Make std namespace available for compatibility

namespace std {}

using namespace std;

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

// Construction/Destruction

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

CSDCReader::CSDCReader( CSDCData* aData )

    {

    iData = aData;

    }

CSDCReader::~CSDCReader()

    {

    }

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

// Other methods

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

void CSDCReader::Parse()

    {

    gInput.NextTokenAllowLF();

    if( sd_wcscasecmp( gInput.iToken, L"SKINTYPE" ) != 0 ) UnexpectedTokenError( gInput.iToken, L"SKINTYPE" );

    ParseSkintype();

    gInput.NextTokenAllowLF();

    if( sd_wcscasecmp( gInput.iToken, L"UID" ) == 0 )

        {

        ParseUID();

        gInput.NextTokenAllowLF();

        }

    else if( sd_wcscasecmp( gInput.iToken, L"PID" ) == 0 )

        {

        ParsePID();

        gInput.NextTokenAllowLF();

        }

    else

        {

        GeneratePID();

        }

    if( sd_wcscasecmp( gInput.iToken, L"NAME" ) != 0 ) UnexpectedTokenError( gInput.iToken, L"NAME" );

    ParseName();

    while( gInput.NextTokenAllowLF() )

        {

        if( sd_wcscasecmp( gInput.iToken, L"NAME" ) == 0 )

            {

            ParseName();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"LANGUAGEOVERRIDE" ) == 0 )

            {

            ParseLanguageOverride();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"LANGUAGEPARENT" ) == 0 )

            {

            ParseParentUID();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"PROTECT" ) == 0 )

            {

            ParseProtect();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"AUTHOR" ) == 0 )

            {

            ParseAuthor();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"COPYRIGHT" ) == 0 )

            {

            ParseCopyright();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"TARGETDEVICE" ) == 0 )

            {

            ParseTargetDevice();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"TOOL" ) == 0 )

            {

            ParseTool();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"BITMAP" ) == 0 )

            {

            ParseBitmap();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"COLORTABLE" ) == 0 )

            {

            ParseColorTable();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"FRAME" ) == 0 )

            {

            ParseFrame();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"BMPANIM" ) == 0 )

            {

            ParseBmpAnim();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"APPICON" ) == 0 )

            {

            ParseAppIcon();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"PALETTE" ) == 0 )

            {

            ParsePalette();

            }

        else if( (sd_wcscasecmp( gInput.iToken, L"SOUND" ) == 0)

            || (sd_wcscasecmp( gInput.iToken, L"STRING" ) == 0) )

            {

            ParseString();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"SCALABLEITEM" ) == 0 )

            {

            if( !iData->IsScalable() ) throw CSDCException( ESDCContentError, "SCALABLEITEM can only be included in scalable skins" );

            ParseScalableItem();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"ANIMATION" ) == 0 )

            {

            if( !iData->IsScalable() ) throw CSDCException( ESDCContentError, "ANIMATION can only be included in scalable skins" );

            ParseAnimation();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"BITMAPPATH" ) == 0 )

            {

            ParseBitmapPath();

            }

        else if( sd_wcscasecmp( gInput.iToken, L"RESTRICTION" ) == 0 )

            {

            ParseRestriction();

            }

        else

            {

            wprintf(L"DEBUG: Unknown token: \"%s\"\n", gInput.iToken );

            throw CSDCException( ESDCParseError, "Unknown token encountered or syntax error" );

            }

        }

    }

void CSDCReader::ParseSkintype()

    {

    gInput.NextToken();

    if( sd_wcscasecmp( gInput.iToken, L"normal" ) == 0 )

        {

        iData->iSkinType = 0x0;

        }

    else if( sd_wcscasecmp( gInput.iToken, L"system" ) == 0 )

        {

        iData->iSkinType = 0x1;

        }

    else if( sd_wcscasecmp( gInput.iToken, L"scalable" ) == 0 )

        {

#if !defined( RD_ENHANCED_SKINNING )

        throw CSDCException( ESDCNotSupportedError, "Scalable skins not supported" );

#endif

        iData->iSkinType = 0x80;

        return; // No other types are supported, if scalable

        }

    else

        {

        throw CSDCException( ESDCParseError, "Unknown or missing parameter for SKINTYPE" );

        }

    if( gInput.NextToken() )

        {

        if( sd_wcscasecmp( gInput.iToken, L"language=AH" ) == 0 )

            {

            iData->iSkinType |= 0x102;

            }

        else

            {

            throw CSDCException( ESDCParseError, "Unknown or missing additional parameter for SKINTYPE" );

            }

        }

    }

void CSDCReader::ParseUID()

    {

    gInput.NextToken();

    iData->iPid.iPID2 = 0; // Timestamp

    iData->iPid.iPID1 = gInput.ConvertToNumber( gInput.iToken ); // UID

    }

void CSDCReader::ParsePID()

    {

    gInput.NextToken();

    iData->iPid.iPID2 = gInput.ConvertToNumber( gInput.iToken ); // Timestamp

    if( iData->iPid.iPID2 == 0 )

        {

        throw CSDCException( ESDCParseError, "PID can not start with zero" );

        }

    gInput.NextToken();

    iData->iPid.iPID1 = gInput.ConvertToNumber( gInput.iToken ); // Random number

    }

void CSDCReader::GeneratePID()

    {

    iData->iPid.iPID2 = 0;

    iData->iPid.iPID1 = 0;

    }

void CSDCReader::ParseName()

    {

    gInput.NextToken();

    int languageID = gInput.ConvertToNumber( gInput.iToken );

    gInput.NextStringToken();

    iData->AppendNameEntry( languageID, gInput.iToken );

    }

void CSDCReader::ParseLanguageOverride()

    {

    if( iData->IsScalable() )

        throw CSDCException( ESDCParseError, "Language override can not be used with scalable skins" );

    gInput.NextToken();

    if( sd_wcscasecmp( gInput.iToken, L"AH" ) != 0 )

        {

        throw CSDCException( ESDCParseError, "Unknown or missing parameter for LANGUAGEOVERRIDE" );

        }

    gInput.NextToken();

    int value = gInput.ConvertToNumber( gInput.iToken );

    if( gInput.NextToken() )

        {

        iData->iAHOverridePid.iPID1 = gInput.ConvertToNumber( gInput.iToken );

        iData->iAHOverridePid.iPID2 = value;

        }

    else

        {

        iData->iAHOverridePid.iPID2 = 0;

        iData->iAHOverridePid.iPID1 = value;

        }

    }

void CSDCReader::ParseParentUID()

    {

    if( iData->IsScalable() )

        throw CSDCException( ESDCParseError, "Parent UID can not be used with scalable skins" );

    gInput.NextToken();

    int value = gInput.ConvertToNumber( gInput.iToken );

    if( gInput.NextToken() )

        {

        iData->iParentPid.iPID1 = gInput.ConvertToNumber( gInput.iToken );

        iData->iParentPid.iPID2 = value;

        }

    else

        {

        iData->iParentPid.iPID2 = 0;

        iData->iParentPid.iPID1 = value;

        }

    }

void CSDCReader::ParseProtect()

    {

    gInput.NextToken();

    if( sd_wcscasecmp( gInput.iToken, L"disablecopy" ) != 0 )

        {

        throw CSDCException( ESDCParseError, "Unknown or missing parameter for PROTECT" );

        }

    iData->iProtection = 1;

    }

void CSDCReader::ParseAuthor()

    {

    gInput.NextStringToken();

    wcscpy( iData->iAuthor, gInput.iToken );

    }

void CSDCReader::ParseCopyright()

    {

    gInput.NextStringToken();

    wcscpy( iData->iCopyright, gInput.iToken );

    }

void CSDCReader::ParseTargetDevice()

    {

    gInput.NextStringToken();

    iData->AppendTargetDeviceEntry( gInput.iToken );

    }

void CSDCReader::ParseTool()

    {

    gInput.NextStringToken();

    wcscpy( iData->iTool, gInput.iToken );

    }

void CSDCReader::ParseBitmap()

    {

    gInput.NextToken();

    bool appIcon = false;

    if( sd_wcscasecmp( gInput.iToken, L"CLASS=appicon" ) == 0 )

        {

        appIcon = true;

        gInput.NextToken();

        }

    int restriction( iData->iCurrentRestriction );

    const TSDCIIDEntry* iid = NULL;

    if( sd_wcsncasecmp( gInput.iToken, L"IID=", 4 ) == 0 )

        {

        wchar_t iidBuf[512];

        wcscpy( iidBuf, gInput.iToken+4 );

        StripIIDPrefix( iidBuf, restriction );

        iid = SDCIIDConstants::FindPlain( iidBuf );

        if( !iid ) UnknownIIDError( gInput.iToken+4 );

        gInput.NextToken();

        }

    TSDCColorDepth colorDepth = gInput.ConvertToColorDepth( gInput.iToken );

    gInput.NextToken();

    if( !iid )

        {

        iid = SDCIIDConstants::FindBmpName( gInput.iToken );

        if( !iid ) UnknownIIDError( gInput.iToken );

        }

    bool svg = CSDCInput::IsSvgFile( gInput.iToken );

    TSDCMBMEntry* mbmEntry = iData->AppendMbmEntry( svg, colorDepth, gInput.iToken );

    int mbmIndex = mbmEntry->iIndex;

    TSDCImageAttributes attributes;

    attributes.iAttributeFlags = ESDCImageAttributeNone;

    attributes.iCoordX = 0;

    attributes.iCoordY = 0;

    attributes.iSizeW = 0;

    attributes.iSizeH = 0;

    attributes.iAlignmentFlags = ESDCImageAlignNone;

    if( iData->IsScalable() ) {

        attributes.iAttributeFlags |= ESDCImageAttributeNBC;

        }

    int maskIndex = -1;

    while( gInput.NextToken() )

        {

        if( sd_wcsncasecmp( gInput.iToken, L"MASK=", 5 ) == 0 )

            {

            if( svg ) throw CSDCException( ESDCParseError, "SVG icon can not have a named mask" );

            if( mbmEntry->iMaskColorDepth!=ESDCColorDepthNone )

                {

                printf("NOTE: Mask already defined, second definition ignored (line %i)\n", gInput.iLineNumber );

                }

            else

                {

                const wchar_t* maskFile = gInput.iToken+5;

                mbmEntry->iMaskColorDepth = ESDCColorDepth1;

                wcscpy( mbmEntry->iMaskSourceFilename, maskFile );

                }

            maskIndex = mbmIndex+1;

            }

        else if( sd_wcsncasecmp( gInput.iToken, L"SOFTMASK=", 9 ) == 0 )

            {

            if( svg ) throw CSDCException( ESDCParseError, "SVG icon can not have a named mask" );

            if( mbmEntry->iMaskColorDepth!=ESDCColorDepthNone )

                {

                printf("NOTE: Mask already defined, second definition ignored (line %i)\n", gInput.iLineNumber );

                }

            else

                {

                const wchar_t* maskFile = gInput.iToken+9;

                mbmEntry->iMaskColorDepth = ESDCColorDepth8;

                wcscpy( mbmEntry->iMaskSourceFilename, maskFile );

                }

            maskIndex = mbmIndex+1;

            }

        else if( sd_wcscasecmp( gInput.iToken, L"MASK" ) == 0 )

            {

            if( !svg ) throw CSDCException( ESDCParseError, "Non-SVG icon can not have an unnamed mask" );

            mbmEntry->iMaskColorDepth = ESDCColorDepth1;

            maskIndex = mbmIndex+1;

            }

        else if( sd_wcscasecmp( gInput.iToken, L"SOFTMASK" ) == 0 )

            {

            if( !svg ) throw CSDCException( ESDCParseError, "Non-SVG icon can not have an unnamed mask" );

            mbmEntry->iMaskColorDepth = ESDCColorDepth8;

            maskIndex = mbmIndex+1;

            }

        else

            {

            ProcessAttribute( attributes, gInput.iToken );

            }

        }

    TSDCIID realIid;

    realIid.iMajor = iid->iMajor;

    realIid.iMinor = iid->iMinor;

    iData->CreateBitmapDef( realIid, mbmIndex, maskIndex, attributes, appIcon, restriction );

    }

void CSDCReader::ParseColorTable()

    {

    gInput.NextToken();

    TSDCIID realIid;

    int restriction( iData->iCurrentRestriction );

    if( sd_wcsncasecmp( gInput.iToken, L"IID=", 4 ) == 0 )

        {

        wchar_t iidBuf[512];

        wcscpy( iidBuf, gInput.iToken+4 );

        StripIIDPrefix( iidBuf, restriction );

        const TSDCIIDEntry* iid = SDCIIDConstants::FindPlain( iidBuf );

        if( !iid ) UnknownIIDError( gInput.iToken+4 );

        realIid.iMajor = iid->iMajor;

        realIid.iMinor = iid->iMinor;

        }

    else

        {

        throw CSDCException( ESDCParseError, "IID parameter expected for COLORTABLE" );

        }

    vector<TSDCColorTableEntry> colors;

    while( gInput.NextTokenAllowLF() )

        {

        if( sd_wcscasecmp( gInput.iToken, L"END" ) == 0 )

            {

            iData->CreateColorTableDef( realIid, colors, restriction );

            return;

            }

        else if( sd_wcsncasecmp( gInput.iToken, L"IDX=", 4 ) == 0 )

            {

            TSDCColorTableEntry entry;

            entry.iIndex = gInput.ConvertToNumber( gInput.iToken+4 );

            entry.iRgb = 0;

            colors.push_back( entry );

            }

        else if( sd_wcsncasecmp( gInput.iToken, L"RGB=", 4 ) == 0 )

            {

            TSDCColorTableEntry entry;

            entry.iIndex = -1;

            int rgb = gInput.ConvertToNumber( gInput.iToken+4 );

            // SymbianOS actually uses BGR order

            entry.iRgb =

                ((rgb&0xff)<<16) | (rgb&0xff00) | ((rgb&0xff0000)>>16);

            colors.push_back( entry );

            }

        else throw CSDCException( ESDCParseError, "Unknown token inside COLORTABLE" );

        }

    throw CSDCException( ESDCParseError, "No END token for COLORTABLE" );

    }

void CSDCReader::ParseFrame()

    {

    gInput.NextToken();

    TSDCIID realIid;

    int restriction( iData->iCurrentRestriction );

    if( sd_wcsncasecmp( gInput.iToken, L"IID=", 4 ) == 0 )

        {

        wchar_t iidBuf[512];

        wcscpy( iidBuf, gInput.iToken+4 );

        StripIIDPrefix( iidBuf, restriction );

        const TSDCIIDEntry* iid = SDCIIDConstants::FindPlain( iidBuf );

        if( !iid ) UnknownIIDError( gInput.iToken+4 );

        realIid.iMajor = iid->iMajor;

        realIid.iMinor = iid->iMinor;

        }

    else

        {

        throw CSDCException( ESDCParseError, "IID parameter expected for FRAME" );

        }

    vector<TSDCIID> elements;

    while( gInput.NextTokenAllowLF() )

        {

        if( sd_wcscasecmp( gInput.iToken, L"END" ) == 0)

            {

            iData->CreateFrameDef( realIid, elements, restriction );

            return;

            }

        else

            {

            elements.push_back( ParseBitmapSource( false, restriction ) );

            }

        }

    throw CSDCException( ESDCParseError, "No END token for FRAME" );

    }

void CSDCReader::ParseBmpAnim()

    {

    gInput.NextToken();

    TSDCIID realIid;

    int restriction( iData->iCurrentRestriction );

    if( sd_wcsncasecmp( gInput.iToken, L"IID=", 4 ) == 0 )

        {

        wchar_t iidBuf[512];