/*

* Copyright (c) 2004, 2006 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 "bitmapmethods.h"

#include <eikenv.h>

#include <fbs.h>

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

// ----------------------------------------------------------------------------

// NBitmapMethods::CreateGraphicsContextLC()

// Create a graphics context and leave it on the cleanup stack.

// ----------------------------------------------------------------------------

//

CFbsBitGc* NBitmapMethods

::CreateGraphicsContextLC( CFbsBitmapDevice& aBitmapDevice )

    {

    CFbsBitGc* graphicsContext = NULL;

    User::LeaveIfError( aBitmapDevice.CreateContext( graphicsContext ) );

    CleanupStack::PushL( graphicsContext );

    return graphicsContext;

    }

// ----------------------------------------------------------------------------

// NBitmapMethods::CreateGraphicsContextL()

// Create a graphics context.

// ----------------------------------------------------------------------------

//

CFbsBitGc* NBitmapMethods

::CreateGraphicsContextL( CFbsBitmapDevice& aBitmapDevice )

    {

    CFbsBitGc* gc = CreateGraphicsContextLC( aBitmapDevice );

    CleanupStack::Pop( gc );

    return gc;

    }

// ----------------------------------------------------------------------------

// NBitmapMethods::CreateBitmapDeviceLC()

// Create a bitmap device and leave it on the cleanup stack.

// ----------------------------------------------------------------------------

//

CFbsBitmapDevice* NBitmapMethods::CreateBitmapDeviceLC( CFbsBitmap& aBitmap )

    {

    CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( &aBitmap );

    CleanupStack::PushL( bitmapDevice );

    return bitmapDevice;

    }

// ----------------------------------------------------------------------------

// NBitmapMethods::CreateBitmapDeviceL()

// Create a bitmap device.

// ----------------------------------------------------------------------------

//

CFbsBitmapDevice* NBitmapMethods::CreateBitmapDeviceL( CFbsBitmap& aBitmap )

    {

    CFbsBitmapDevice* device = CreateBitmapDeviceLC( aBitmap );

    CleanupStack::Pop( device );

    return device;

    }

// ----------------------------------------------------------------------------

// NBitmapMethods::CreateBitmapLC()

// Create a bitmap and leave it on the cleanup stack.

// ----------------------------------------------------------------------------

//

CFbsBitmap* NBitmapMethods

::CreateBitmapLC( TSize aSizeInPixels, TDisplayMode aDispMode )

    {

    CFbsBitmap* bitmap = new ( ELeave ) CFbsBitmap();

    CleanupStack::PushL( bitmap );

    User::LeaveIfError( bitmap->Create( aSizeInPixels,aDispMode ) );

    ASSERT( ( bitmap->DisplayMode() == KColourDepth )

                                    || ( bitmap->DisplayMode()  == EGray2 ) );

    return bitmap;

    }

// ----------------------------------------------------------------------------

// NBitmapMethods::CreateBitmapL()

// Create a bitmap.

// ----------------------------------------------------------------------------

//

CFbsBitmap* NBitmapMethods

::CreateBitmapL( TSize aSizeInPixels, TDisplayMode aDispMode )

    {

    CFbsBitmap* bitmap = CreateBitmapLC( aSizeInPixels, aDispMode );

    CleanupStack::Pop( bitmap );

    return bitmap;

    }

// ----------------------------------------------------------------------------

// NBitmapMethods::CreateBitmapLC()

// Create a bitmap and leave it on the cleanup stack.

// ----------------------------------------------------------------------------

//

CFbsBitmap* NBitmapMethods::CreateBitmapLC( const TDesC& aFileName, TInt aId )

    {

    CFbsBitmap* bitmap = new ( ELeave ) CFbsBitmap();

    CleanupStack::PushL( bitmap );

    TInt loadException = bitmap->Load( aFileName, aId );

    User::LeaveIfError( loadException );

    if ( ( bitmap->DisplayMode() == KColourDepth )

                                 || ( bitmap->DisplayMode()  == EGray2 ) )

        {

        return bitmap;

        }

    else

        {

        CFbsBitmap* newBitmap = CreateBitmapLC(    bitmap->SizeInPixels(),

                                                KColourDepth );

        CFbsBitmapDevice* bitmapDevice = CreateBitmapDeviceLC( *newBitmap );

        CFbsBitGc* bitmapGc = CreateGraphicsContextLC( *bitmapDevice );

        bitmapGc->BitBlt( TPoint( 0,0 ),

                          bitmap, TRect( bitmap->SizeInPixels() ) );

        CleanupStack::PopAndDestroy( 2 ); // gc and device

        // The next three lines are here to get rid

        // of the old bitmap but keep the new one

        CleanupStack::Pop( newBitmap );

        CleanupStack::PopAndDestroy( bitmap );

        CleanupStack::PushL( newBitmap );

        return newBitmap;

        }

    }

// ----------------------------------------------------------------------------

// NBitmapMethods::CreateBitmapL()

// Create a bitmap.

// ----------------------------------------------------------------------------

//

CFbsBitmap* NBitmapMethods::CreateBitmapL( const TDesC& aFileName, TInt aId )

    {

    CFbsBitmap* bitmap = CreateBitmapLC( aFileName, aId );

    CleanupStack::Pop( bitmap );

    return bitmap;

    }

// ----------------------------------------------------------------------------

// NBitmapMethods::BitBltMaskedEntireBitmap()

// Blit the entire of a bitmap with a mask onto a gc.

// ----------------------------------------------------------------------------

//

void NBitmapMethods::BitBltMaskedEntireBitmap( CFbsBitGc& aTargetGc,

                                               TPoint aTopLeft,

                                               const CFbsBitmap& aBitmap,

                                               const CFbsBitmap& aBitMask )

    {

    PartialReset( aTargetGc );

    aTargetGc.BitBltMasked( aTopLeft,

                            &aBitmap,

                            aBitmap.SizeInPixels(),

                            &aBitMask,

                            ETrue );

    PartialReset( aTargetGc );

    }

// ----------------------------------------------------------------------------

// NBitmapMethods::PartialReset()

// Reset a gc.

// ----------------------------------------------------------------------------

//

void NBitmapMethods::PartialReset( CFbsBitGc& aGc )

    {

    aGc.SetPenSize( TSize( 1,1 ) );

    aGc.SetPenColor( KRgbBlack );

    aGc.SetPenStyle( CFbsBitGc::ESolidPen );

    aGc.SetDrawMode( CFbsBitGc::EDrawModePEN );

    aGc.DiscardFont();

    aGc.DiscardBrushPattern();

    aGc.SetBrushColor( KRgbWhite );

    aGc.SetBrushStyle( CFbsBitGc::ENullBrush );

    aGc.SetCharJustification( 0,0 );

    aGc.SetWordJustification( 0,0 );

    aGc.SetDitherOrigin( TPoint( 0,0 ) );

    aGc.SetPenStyle( CFbsBitGc::ENullPen );

    aGc.SetShadowMode( EFalse );

    aGc.SetStrikethroughStyle( EStrikethroughOff );

    aGc.SetUnderlineStyle( EUnderlineOff );

    aGc.SetUserDisplayMode( ENone );

    }

// End of File