/*

* Copyright (c) 2006-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:   ?Description

*

*/

#include "HuiVg10TextureManager.h"  // Class definition

#include "HuiVg10TextureProcessor.h"

CHuiVg10TextureManager* CHuiVg10TextureManager::NewL(CHuiEnv& aEnv)

    {

    CHuiVg10TextureManager* self = CHuiVg10TextureManager::NewLC(aEnv);

    CleanupStack::Pop(self);

    return self;

    }

CHuiVg10TextureManager* CHuiVg10TextureManager::NewLC(CHuiEnv& aEnv)

    {

    CHuiVg10TextureManager* self = new (ELeave) CHuiVg10TextureManager(aEnv);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CHuiVg10TextureManager::CHuiVg10TextureManager(CHuiEnv& aEnv)

        : CHuiTextureManager(aEnv)

    {

    }

void CHuiVg10TextureManager::ConstructL()

    {

    CHuiTextureManager::BaseConstructL();

    // Create a texture processor.

    CHuiVg10TextureProcessor* proc = CHuiVg10TextureProcessor::NewL(Env());

    SetProcessor(proc); // ownership to base class

    iBitmap16MA = new (ELeave) CFbsBitmap;

    iBitmap16MA->Create(TSize(1,1), EColor16MA);

    iBitmap16MU = new (ELeave) CFbsBitmap;

    iBitmap16MU->Create(TSize(1,1), EColor16MU);

    iBitmap64K = new (ELeave) CFbsBitmap;

    iBitmap64K->Create(TSize(1,1), EColor64K);

    iBitmap256Gray = new (ELeave) CFbsBitmap;

    iBitmap256Gray->Create(TSize(1,1), EGray256);

    iBitmapDevice16MA = CFbsBitmapDevice::NewL(iBitmap16MA);

    iBitmapDevice16MU = CFbsBitmapDevice::NewL(iBitmap16MU);

    iBitmapDevice64K = CFbsBitmapDevice::NewL(iBitmap64K);

    iBitmapDevice256Gray = CFbsBitmapDevice::NewL(iBitmap256Gray);

    }

CHuiVg10TextureManager::~CHuiVg10TextureManager()

    {

    delete iBitmap16MA;

    delete iBitmap16MU;

    delete iBitmap64K;

    delete iBitmap256Gray;

    delete iBitmapDevice16MA;

    delete iBitmapDevice16MU;

    delete iBitmapDevice64K;

    delete iBitmapDevice256Gray;

    delete iBitGc16MA;

    delete iBitGc16MU;

    delete iBitGc64K;

    delete iBitGc256Gray;

    }

CFbsBitmap& CHuiVg10TextureManager::ConvertBitmapL(const CFbsBitmap& aBitmap, TDisplayMode aDisplayMode, TBitmapCopyMode aCopyMode, TSize aNewSize)

    {

    TSize newSize = aBitmap.SizeInPixels();

    if (aNewSize != TSize(0,0))

        {

        newSize = aNewSize;

        }

    // Select the correct Colormode bitmap & device

    CFbsBitmap* bitmap = NULL;

    CFbsBitmapDevice* bitmapDevice = NULL;

    CFbsBitGc* bitGc = NULL;

    // This is needed for storing the possibly recreated bitGc to a member variable

    CFbsBitGc** bitGcMemberPtr = NULL;

    switch(aDisplayMode)

        {

        case EColor16MA:

            bitmap = iBitmap16MA;

            bitmapDevice = iBitmapDevice16MA;

            bitGc = iBitGc16MA;

            bitGcMemberPtr = &iBitGc16MA;

            break;

        case EColor16MU:

            bitmap = iBitmap16MU;

            bitmapDevice = iBitmapDevice16MU;

            bitGc = iBitGc16MU;

            bitGcMemberPtr = &iBitGc16MU;

            break;

        case EColor64K:

            bitmap = iBitmap64K;

            bitmapDevice = iBitmapDevice64K;

            bitGc = iBitGc64K;

            bitGcMemberPtr = &iBitGc64K;

            break;

        case EGray256:

            bitmap = iBitmap256Gray;

            bitmapDevice = iBitmapDevice256Gray;

            bitGc = iBitGc256Gray;

            bitGcMemberPtr = &iBitGc256Gray;

            break;

        default:

            // Not supported! Implement more cases if needed, otherwise this'll leave

            User::Leave(KErrNotSupported);

            break;

        }

    // No conversion required?

    if ( aCopyMode == EAllowDuplication && aBitmap.DisplayMode() == aDisplayMode && 

         !aBitmap.IsCompressedInRAM() && newSize == aBitmap.SizeInPixels() )

        {

        // If the bitmap's color mode was already correct & sizes matched,

        // and bmp isn't rombitmap, no conversion was required and we can return

        // the same bitmap that was given as a parameter

        CFbsBitmap& bmp = const_cast<CFbsBitmap&>(aBitmap);

        return bmp;

        }

    // If needed, Resize the bitmap & bitmapDevice to correct dimensions,

    // instead of recreating them always

    if (newSize != bitmap->SizeInPixels() || !bitGc)

        {

        // Try to resize the bitmap & bmpDevice, leave, if e.g. out of memory

        User::LeaveIfError(bitmap->Resize(newSize));

        delete bitGc;

		bitGc = 0;

        *bitGcMemberPtr = 0;

        User::LeaveIfError(bitmapDevice->Resize(newSize));

        // The BitGc has to be created every time separately

        User::LeaveIfError(bitmapDevice->CreateContext(bitGc));

        // Store the newly created context to a correct member variable

        *bitGcMemberPtr = bitGc;

        }

    if (aDisplayMode == EColor16MA && bitGc)

        {

        bitGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

        }

    if (bitGc)

		{

		bitGc->BitBlt(TPoint(0, 0), &aBitmap);

		}

    return *bitmap;

    }

// End of file