/*

* 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:  Binary output.

*

*/

#include "SDCGlobals.h"

#include "SDCBinOutput.h"

#include "AknsConstants.hrh"

#include "SDCException.h"

// Make std namespace available for compatibility

namespace std {}

using namespace std;

// CLASS DECLARATION

class TPos

    {

    public:

        TPos( CSDCBinOutput* aBinOutput )

            {

            iPosition = aBinOutput->iOutputPos;

            }

        void Go( CSDCBinOutput* aBinOutput )

            {

            iOriginalPosition = aBinOutput->iOutputPos;

            aBinOutput->iOutputPos = iPosition;

            }

        void Back( CSDCBinOutput* aBinOutput )

            {

            aBinOutput->iOutputPos = iOriginalPosition;

            }

        int BackwardsDelta()

             {

             return iOriginalPosition-iPosition;

             }

    public:

        int iPosition;

        int iOriginalPosition;

    };

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

// Construction/Destruction

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

CSDCBinOutput::CSDCBinOutput()

    {

    iOutputPos = 0;

    }

CSDCBinOutput::~CSDCBinOutput()

    {

    }

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

// Other methods

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

void CSDCBinOutput::Output( CSDCData* aData, const char* aBaseName, const char* aBinFilename, const bool aStubOnly )

    {

    iData = aData;

    strcpy( iBaseName, aBaseName );

    PrepareSkinDescriptor( aStubOnly );

    FILE* file = fopen( aBinFilename, "wb" );

    if( !file ) throw CSDCException( ESDCFileOpenError, "Can not open target binary file for writing" );

    for( i=0; i<iOutputVector.size(); i++ )

        {

        fputc( iOutputVector[i], file );

        }

    fclose( file );

    }

void CSDCBinOutput::PrepareSkinDescriptor( const bool aStubOnly )

    {

    TPos startPos( this );

    AppendBytes( 1*4 + 2*2 );

    WriteUint( 0 );             // Length

    WriteUint16( 0 );           // Type

    WriteUint16( 1 );           // Version

    AppendBytes( 3*4 + 1*2 + 2*4 );

    WriteInt( iData->iPid.iPID1 );      // SkinPID1

    WriteInt( iData->iPid.iPID2 );      // SkinPID2

    WriteInt( 0 );                      // SkinCF

    WriteUint16( (unsigned short int)iData->iSkinType ); // SkinType

    WriteInt( iData->iPalettePid.iPID1 ); // ColorSchemePID1

    WriteInt( iData->iPalettePid.iPID2 ); // ColorSchemePID2

    AppendBytes( 1*1 );                 // Protection

    if( iData->iProtection == 1 )

        {

        WriteByte( 0x01 );

        }

    else

        {

        WriteByte( 0x00 );

        }

    AppendBytes( 1*1 );                 // ContentFlags

    if( (iData->iAppIconDefVector.size()>0) && (!iData->IsScalable()) )

        {

        WriteByte( 1 );

        }

    else

        {

        WriteByte( 0 );

        }

    AppendBytes( 1*2 + 1*4 );

    WriteUint16( 0 );                   // Reserved2

    WriteInt( 0 );                      // Reserved3

    int chunksN = 0;

    AppendBytes( 1*4 );

    TPos chunksNPos( this );

    WriteInt( 0 );              // ChunksN

    PrepareInformation();

    chunksN++;

    for( i=0; i<iData->iTargetDeviceVector.size(); i++ )

        {

        TSDCTargetDeviceEntry* entry = iData->iTargetDeviceVector[i];

        PrepareTargetDevice( entry->iDeviceName );

        chunksN++;

        }

    for( i=0; i<iData->iNameVector.size(); i++ )

        {

        TSDCNameEntry* entry = iData->iNameVector[i];

        PrepareName( entry->iLanguageID, entry->iName );

        chunksN++;

        }

    if( (iData->iAHOverridePid.iPID1!=0) && (iData->iAHOverridePid.iPID2!=0) )

        {

        PrepareLanguageOverride( 0x01, iData->iAHOverridePid );

        chunksN++;

        }

    if( !iData->IsScalable() )

        {

        for( i=0; i<iData->iBitmapDefVector.size(); i++ )

            {

            TSDCBitmapDef* entry = iData->iBitmapDefVector[i];

            if( (entry->iIID.iMajor == EAknsMajorSkin) &&

                (entry->iIID.iMinor == EAknsMinorWallpaper) )

                {

                PrepareWallpaper( 0x00, entry );

                chunksN++;

                PrepareWallpaper( 0x01, entry );

                chunksN++;

                }

            if( (entry->iIID.iMajor == EAknsMajorPinboard) &&

                (entry->iIID.iMinor == EAknsMinorQsnFrPinbCenterWp) )

                {

                PrepareWallpaper( 0x02, entry );

                chunksN++;

                }

            }

        }

    if( !aStubOnly )

        {

        char buf[512];

        strcpy( buf, iBaseName );

        strcat( buf, ".mbm" );

        PrepareFilename( 0, buf );

        chunksN++;

        if( iData->IsScalable() )

            {

            strcpy( buf, iBaseName );

            strcat( buf, ".mif" );

            PrepareFilename( 1, buf );

            chunksN++;

            }

        PrepareNormalClass( 0 );

        chunksN++;

        if( !iData->IsScalable() )

            {

            PrepareAppIconClass();

            chunksN++;

            }

        // Release 2.6 specifics

        PrepareEncapsulatedNormalClass( 0x0206 );

        chunksN++;

        // Release 2.7 specifics

        PrepareEncapsulatedNormalClass( 0x0207 );

        chunksN++;

        // Release 2.8 specifics

        PrepareEncapsulatedNormalClass( 0x0208 );

        chunksN++;

        // Release 3.0 specifics

        PrepareEncapsulatedNormalClass( 0x0300 );

        chunksN++;

        // Non-mirrored

        PrepareEncapsulatedNormalClass( 0x00010000 );

        chunksN++;

        // Mirrored

        PrepareEncapsulatedNormalClass( 0x00020000 );

        chunksN++;

            {

            // Language

            PrepareEncapsulatedNormalClass( iData->iLanguageVector[count] );

            chunksN++;

            }

        }

    chunksNPos.Go( this );

    WriteInt( chunksN );

    chunksNPos.Back( this );

    AppendBytes( 1*1 );

    WriteByte( 0xf5 );

    startPos.Go( this );

    WriteUint( startPos.BackwardsDelta() );

    startPos.Back( this );

    }

void CSDCBinOutput::PrepareTargetDevice( const wchar_t* aDeviceName )

    {

    TPos startPos( this );

    AppendBytes( 1*4 + 2*2 );

    WriteUint( 0 );             // Length

    WriteUint16( 14 );          // Type

    WriteUint16( 1 );           // Version

    AppendBytes( 1*2 );

    WriteUint16( wcslen( aDeviceName ) );

        {

        AppendBytes( 2 );

        WriteUint16( aDeviceName[i] );

        }

    AppendBytes( 1*1 );

    WriteByte( 0xf5 );

    startPos.Go( this );

    WriteUint( startPos.BackwardsDelta() );

    startPos.Back( this );

    }

void CSDCBinOutput::PrepareName( const short int aLanguage, const wchar_t* aName )

    {

    TPos startPos( this );

    AppendBytes( 1*4 + 2*2 );

    WriteUint( 0 );             // Length

    WriteUint16( 1 );           // Type

    WriteUint16( 1 );           // Version

    AppendBytes( 2*2 );

    WriteInt16( aLanguage );

    WriteUint16( wcslen( aName ) );

        {

        AppendBytes( 2 );

        WriteUint16( aName[i] );

        }

    AppendBytes( 1*1 );

    WriteByte( 0xf5 );

    startPos.Go( this );

    WriteUint( startPos.BackwardsDelta() );

    startPos.Back( this );

    }

void CSDCBinOutput::PrepareInformation()

    {

    TPos startPos( this );

    AppendBytes( 1*4 + 2*2 );

    WriteUint( 0 );             // Length

    WriteUint16( 11 );          // Type

    WriteUint16( 2 );           // Version

    AppendBytes( 2*4 );

    AppendBytes( 2*4 );

    WriteInt( (gVersionMajor<<16) | gVersionMinor );

    WriteInt( 0 );

    AppendBytes( 1*2 );

    WriteUint16( wcslen( iData->iAuthor ) );

    for( i=0; i<wcslen( iData->iAuthor ); i++ )

        {

        AppendBytes( 2 );

        WriteUint16( iData->iAuthor[i] );

        }

    AppendBytes( 1*2 );

    WriteUint16( wcslen( iData->iCopyright ) );

    for( i=0; i<wcslen( iData->iCopyright ); i++ )

        {

        AppendBytes( 2 );

        WriteUint16( iData->iCopyright[i] );

        }

    AppendBytes( 2*1 );

    WriteByte( gPlatformMajor );

    WriteByte( gPlatformMinor );

    AppendBytes( 1*2 );

    WriteUint16( wcslen( iData->iTool ) );

    for( i=0; i<wcslen( iData->iTool ); i++ )

        {

        AppendBytes( 2 );

        WriteUint16( iData->iTool[i] );

        }

    AppendBytes( 1*1 );

    WriteByte( 0xf5 );

    startPos.Go( this );

    WriteUint( startPos.BackwardsDelta() );

    startPos.Back( this );

    }

void CSDCBinOutput::PrepareLanguageOverride( const unsigned char aOverrideType, const TSDCPID aOverridePid )

    {

    TPos startPos( this );

    AppendBytes( 1*4 + 2*2 );

    WriteUint( 0 );             // Length

    WriteUint16( 9 );           // Type

    WriteUint16( 1 );           // Version

    AppendBytes( 1*1 + 2*4 );

    WriteByte( aOverrideType );

    WriteInt( aOverridePid.iPID1 );

    WriteInt( aOverridePid.iPID2 );

    AppendBytes( 1*1 );

    WriteByte( 0xf5 );

    startPos.Go( this );

    WriteUint( startPos.BackwardsDelta() );

    startPos.Back( this );

    }

void CSDCBinOutput::PrepareWallpaper( const unsigned char aWpType, const TSDCBitmapDef* aBitmapDef )

    {

    TPos startPos( this );

    AppendBytes( 1*4 + 2*2 );

    WriteUint( 0 );             // Length

    WriteUint16( 10 );          // Type

    WriteUint16( 1 );           // Version

    char buf[512];

    strcpy( buf, iBaseName );

    strcat( buf, ".mbm" );

    AppendBytes( 1*1 + 1*2 );

    WriteByte( aWpType );

    WriteUint16( strlen( buf ) );

        {

        AppendBytes( 2 );

        WriteUint16( (short int)buf[i] );

        }

    AppendBytes( 1*4 );

    WriteInt( aBitmapDef->iMBMIndex );

    AppendBytes( 1*1 );

    WriteByte( 0xf5 );

    startPos.Go( this );

    WriteUint( startPos.BackwardsDelta() );

    startPos.Back( this );

    }

void CSDCBinOutput::PrepareFilename( const int aId, const char* aFilename )

    {

    TPos startPos( this );

    AppendBytes( 1*4 + 2*2 );

    WriteUint( 0 );             // Length

    WriteUint16( 2 );           // Type

    WriteUint16( 1 );           // Version

    AppendBytes( 1*4 + 1*2 );

    WriteInt( aId );

    WriteUint16( strlen( aFilename ) );

        {

        AppendBytes( 2 );

        WriteUint16( (short int)aFilename[i] );

        }

    AppendBytes( 1*1 );

    WriteByte( 0xf5 );

    startPos.Go( this );

    WriteUint( startPos.BackwardsDelta() );

    startPos.Back( this );

    }

void CSDCBinOutput::PrepareEncapsulatedNormalClass( const int aRestriction )

    {

    TPos restStartPos( this );

    if( aRestriction )

        {

        AppendBytes( 1*4 + 2*2 );

        WriteUint( 0 );             // Length

        if( aRestriction==0x0206 )

            {

            // 2.6 release restriction

            WriteUint16( 13 );          // Type

            WriteUint16( 1 );           // Version

            AppendBytes( 2*1 );

            WriteByte( (aRestriction&0xff00) >> 8 );    // PlatformMajor

            WriteByte( aRestriction&0xff );             // PlatformMinor

            }

        else if( aRestriction<0x0010000 )

            {

            // Only generic release restriction

            WriteUint16( 18 );          // Type

            WriteUint16( 1 );           // Version

            AppendBytes( 2*1 );

            WriteByte( (aRestriction&0xff00) >> 8 );    // PlatformMajor

            WriteByte( aRestriction&0xff );             // PlatformMinor

            AppendBytes( 2*4 );

            WriteInt( 0 );      // Reserved1

            WriteInt( 0 );      // Reserved2

            }

        else if (aRestriction>=0x30000)

            {

            // language restriction

            WriteUint16( 15 );          // Type

            WriteUint16( 1 );           // Version

            AppendBytes( 2*2 );

            WriteUint16( 0 ) ; // GeneralR

            WriteUint16( aRestriction&0xffff );         // LanguageR

            }

        else

            {

            // Layout restriction

            WriteUint16( 15 );          // Type

            WriteUint16( 1 );           // Version

            AppendBytes( 2*2 );

            WriteUint16( (aRestriction&0xffff0000) >> 16 ); // GeneralR

            WriteUint16( 0 );                               // LanguageR

            }

        AppendBytes( 1*4 );

        WriteInt( 1 );              // ChunksN

        }

    PrepareNormalClass( aRestriction );

    if( aRestriction )

        {

        AppendBytes( 1*1 );