/*
* 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: 
*
*/



// INCLUDE FILES
#include <e32math.h>
#include <fbs.h>
#include <mifconvdefs.h> // For definition of EIconFormatNVG

#include "AknNvgFormatHandler.h"
#include "AknIconObserver.h"
#include "AknIconSrvPanic.h"
#include "AknIconTraces.h"
#include <flogger.h>
#include "AknIconManager.h"
#include "AknIconHeader.h"

// CONSTANTS


// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::CAknNvgFormatHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CAknNvgFormatHandler::CAknNvgFormatHandler():iMode(EAspectRatioPreserved),iAngle(0)
	{
	iData = 0x00;
	}

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::ConstructL()
    {
#ifdef __AKNICON_TRACES
    RDebug::Print( _L("AknIcon: %x Calling ConstructL - iSvgEngine: %x"), this, iSvgEngine);
#endif            
    }

CAknNvgFormatHandler* CAknNvgFormatHandler::NewL()
    {
    CAknNvgFormatHandler* self = new( ELeave ) CAknNvgFormatHandler();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// Destructor
CAknNvgFormatHandler::~CAknNvgFormatHandler()
    {
	iIconData.Close();
	delete iData;
    delete iDummyBitmap;
    delete iNvgEngine;
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::SetScaleMode
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::SetScaleMode( TScaleMode aMode )
    {
    iMode = aMode;
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::SetRotation
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::SetRotation( TInt aAngle )
    {
    iAngle = aAngle;
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::GetContentDimensionsL
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::GetContentDimensionsL(
        TAknContentDimensions& aContentDimensions)
    {
    if ( iNvgEngine && iData)
        {
        TSize lSize = iNvgEngine->ContentDimensions(iData->Des().MidTPtr(KIconHeaderLength) );
        aContentDimensions.SetDimensions( lSize );
        }    
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::InitializeEngineL
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::InitializeEngineL()
    {
    if ( !iNvgEngine)
        {
        iNvgEngine = CNvgEngine::NewL( );
        }
	
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::PrepareIconL
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::PrepareIconL( const TDesC8& aIconData, TInt& aHandle )
    {
    InitializeEngineL();

    TInt handle = 1;


    if (iData)
        {
        delete iData;
        iData = NULL;
        }
    
    iData = HBufC8::NewL(aIconData.Size()+KIconHeaderLength);

    TPtr8 lPtr(iData->Des() );
    TUint8 header[KIconHeaderLength]=
        {
        0
        };

    lPtr.Append(header, KIconHeaderLength);

    lPtr.Append(aIconData);

    aHandle = handle;
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::UsePreparedIconL
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::UsePreparedIconL(TInt /*aHandle */)
    {
  
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::RenderPreparedIconL
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::RenderPreparedIconL(CFbsBitmap* aBitmap,
        CFbsBitmap* aMask, TSize Bitmapsize, TDisplayMode Bitmapdepth,
        TDisplayMode Maskdepth, TRgb aColor, TBool aMarginFlag)
    {
    FormCommonHeader(aBitmap, EFalse, aColor, aMarginFlag);
    aBitmap->CreateExtendedBitmap(Bitmapsize, Bitmapdepth,
            KUidNvgProprietaryFormat, iData->Ptr(), iData->Length());

    if (aMask)
        {
        FormCommonHeader(0, ETrue, 0, 0);
        aMask->CreateExtendedBitmap(Bitmapsize, Maskdepth,
                KUidNvgProprietaryFormat, iData->Ptr(), iData->Length());
        }
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::UnprepareIcon
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::UnprepareIcon( TInt /*aHandle*/ )
    {
    delete iData;
    iData = NULL;
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::SetAnimated
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::SetAnimated( TBool aAnimated )
    {
    iAnimated = aAnimated;
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::IconFormatType
// -----------------------------------------------------------------------------
//
TInt CAknNvgFormatHandler::IconFormatType()
    {
    return EIconFormatNVG;
    }    

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::SetObserver
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::SetObserver( MAknIconChangeObserver* aObserver )
    {
	
    iObserver = aObserver;
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::CheckHandleActivatedL
// -----------------------------------------------------------------------------
//

void CAknNvgFormatHandler::CheckHandleActivatedL( CFbsBitmap* /*aBitmap*/, CFbsBitmap * /*aMask*/ )
    {      
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::SupportedDisplayMode
// -----------------------------------------------------------------------------
//
void CAknNvgFormatHandler::SupportedDisplayMode(
    TDisplayMode& aMode, TDisplayMode aPreferredMode )
    {
    // Modes currently supported by SVG engine are:
    // EGray2, EColor4K, EColor64K, EColor16M
    if ( aMode != EGray2 )
        {
        aMode = aPreferredMode;
        }
    }

// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::SetEngineScaleMode
// -----------------------------------------------------------------------------
//

void CAknNvgFormatHandler::SetEngineScaleMode()
    {
   
    }
    
// -----------------------------------------------------------------------------
// CAknNvgFormatHandler::CleanupNullMaskPointer
// -----------------------------------------------------------------------------
//    
//
void CAknNvgFormatHandler::CleanupNullMaskPointer(TAny* aParam)
    {
    static_cast<CAknNvgFormatHandler*>( aParam )->iMask = NULL;
    }

void CAknNvgFormatHandler::FormCommonHeader(const CFbsBitmap *aBitmap,
        TBool isMask, TRgb aColor, TBool aMarginFlag)
    {

    TPtr8 tmpBufPtr(iData->Des());
   
    TAknIconHeader iconheader(tmpBufPtr);
    
    if(isMask)
             {
             iconheader.SetIsMask(ETrue);
             return;
             }
    
    iconheader.Initialize();
    
    iconheader.SetRotation(iAngle);

    iconheader.SetIconColor(aColor.Value());

    iconheader.SetScaleMode(iMode);
    
    if(aMarginFlag)
    iconheader.SetMarginCorrection(ETrue);

    iconheader.SetIsMask(EFalse);

    iconheader.SetBitmapId(aBitmap->Handle());
    }


//  End of File
