/*

* Copyright (c) 2004 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:  Default implementation of bitmap class.

*

*/

// INCLUDE FILES

#include "CIHLBitmap.h"

#include <fbs.h>

// ======================== STATIC FACTORY FUNCTIONS ===========================

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

// IHLBitmap::CreateL

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

//

EXPORT_C MIHLBitmap* IHLBitmap::CreateL()

	{

	return CIHLBitmap::NewL();

	}

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

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

CIHLBitmap::CIHLBitmap()

    {

    }

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

//

// Second phase constructors. Can leave.

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

void CIHLBitmap::ConstructL()

	{

	iBitmap = new (ELeave) CFbsBitmap;

	iMask = new (ELeave) CFbsBitmap;

	}

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

//

// Two-phased constructors.

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

CIHLBitmap* CIHLBitmap::NewL()

	{

    CIHLBitmap* self = new( ELeave ) CIHLBitmap;

	CleanupStack::PushL( self );

    self->ConstructL();

	CleanupStack::Pop(); // self

    return self;

	}

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

// Destructor

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

CIHLBitmap::~CIHLBitmap()

    {

	delete iBitmap;

	delete iMask;

    }

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

// CIHLBitmap::Create

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

TInt CIHLBitmap::Create( const TSize& aSize, TDisplayMode aDisplayMode )

	{

	Reset();

	return iBitmap->Create( aSize, aDisplayMode );

	}

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

// CIHLBitmap::Create

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

TInt CIHLBitmap::Create( const TSize& aSize, TDisplayMode aBitmapDisplayMode,

											 TDisplayMode aMaskDisplayMode )

	{

    Reset();

	TInt err( KErrArgument );

    if( aMaskDisplayMode == EGray2 || aMaskDisplayMode == EGray256 )

        {

    	err = iBitmap->Create( aSize, aBitmapDisplayMode );

    	if( err )

    		{

    		return err;

    		}

    	err = iMask->Create( aSize, aMaskDisplayMode );

    	if( err )

    		{

    		iBitmap->Reset();

    		}

        }

	return err;

	}

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

// CIHLBitmap::Copy

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

TInt CIHLBitmap::Copy( const CFbsBitmap& aBitmap, TBool aDuplicate )

	{

	Reset();

	TInt err( KErrNone );

	TInt bitmapHandle( aBitmap.Handle() );

	if( bitmapHandle )

		{

		if( aDuplicate )

			{

			err = iBitmap->Duplicate( bitmapHandle );

			}

		else

			{

			err = CopyBitmap( aBitmap, *iBitmap );

			}

		}

	return err;

	}

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

// CIHLBitmap::Copy

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

TInt CIHLBitmap::Copy( const CFbsBitmap& aBitmap, const CFbsBitmap& aMask, TBool aDuplicate )

	{

	Reset();

	TInt bitmapHandle( aBitmap.Handle() );

	TInt maskHandle( aMask.Handle() );

	if( bitmapHandle && maskHandle &&

		aBitmap.SizeInPixels() != aMask.SizeInPixels() )

		{

		return KErrArgument;

		}

	if( maskHandle )

		{

		switch( aMask.DisplayMode() )

		    {

		    case EGray2:

		    case EGray256:

		        {

		        break;

		        }

		    default:

		        {

		        return KErrArgument;

		        }

		    }

		}

	TInt err( KErrNone );

	if( bitmapHandle )

		{

		if( aDuplicate )

			{

			err = iBitmap->Duplicate( bitmapHandle );

			}

		else

			{

			err = CopyBitmap( aBitmap, *iBitmap );

			}

		}

	if( !err && maskHandle )

		{

		if( aDuplicate )

			{

			err = iMask->Duplicate( maskHandle );

			}

		else

			{

			err = CopyBitmap( aMask, *iMask );

			}

		if( err )

			{

			iBitmap->Reset();

			}

		}

	return err;

	}

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

// CIHLBitmap::Copy

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

TInt CIHLBitmap::Copy( const MIHLBitmap& aBitmap, TBool aDuplicate )

	{

	return Copy( aBitmap.Bitmap(), aBitmap.Mask(), aDuplicate );

	}

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

// CIHLBitmap::Reset

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

void CIHLBitmap::Reset()

	{

	iBitmap->Reset();

	iMask->Reset();

	iEditorPtr = NULL;

	iEditorValue = 0;

	}

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

// CIHLBitmap::IsCreated

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

TBool CIHLBitmap::IsCreated() const

	{

	return ( iBitmap->Handle() != 0 );

	}

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

// CIHLBitmap::Bitmap

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

const CFbsBitmap& CIHLBitmap::Bitmap() const

	{

	return *iBitmap;

	}

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

// CIHLBitmap::HasMask

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

TBool CIHLBitmap::HasMask() const

	{

	return ( iMask->Handle() != 0 );

	}

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

// CIHLBitmap::Mask

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

const CFbsBitmap& CIHLBitmap::Mask() const

	{

	return *iMask;

	}

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

// CIHLBitmap::Draw

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

void CIHLBitmap::Draw( CBitmapContext& aContext, const TPoint& aPoint ) const

	{

	if( iBitmap->Handle() )

		{

		if( iMask->Handle() )

			{

			aContext.BitBltMasked( aPoint, iBitmap, iBitmap->SizeInPixels(), iMask, EFalse );

			}

		else

			{

			aContext.BitBlt( aPoint, iBitmap, iBitmap->SizeInPixels() );

			}

		}

	}

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

// CIHLBitmap::Draw

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

void CIHLBitmap::Draw( CBitmapContext& aContext, const TPoint& aPoint,

                       const TRect& aSourceRect ) const

	{

	if( iBitmap->Handle() )

		{

		if( iMask->Handle() )

			{

			aContext.BitBltMasked( aPoint, iBitmap, aSourceRect, iMask, EFalse );

			}

		else

			{

			aContext.BitBlt( aPoint, iBitmap, aSourceRect );

			}

		}

	}

// Internal interface

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

// CIHLBitmap::SetFilename

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

CFbsBitmap& CIHLBitmap::BitmapModifyable()

	{

	return *iBitmap;

	}

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

// CIHLBitmap::SetFilename

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

CFbsBitmap& CIHLBitmap::MaskModifyable()

	{

	return *iMask;

	}

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

// CIHLBitmap::SetEditorPtr

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

void CIHLBitmap::SetEditorPtr( const TAny* aEditorPtr )

	{

	iEditorPtr = aEditorPtr;

	}

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

// CIHLBitmap::SetEditorValue

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

void CIHLBitmap::SetEditorValue( TInt aEditorValue )

	{

	iEditorValue = aEditorValue;

	}

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

// CIHLBitmap::EditorPtr

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

const TAny* CIHLBitmap::EditorPtr() const

	{

	return iEditorPtr;

	}

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

// CIHLBitmap::FrameIndex

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

TInt CIHLBitmap::EditorValue() const

	{

	return iEditorValue;

	}

// Private methods

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

// CIHLBitmap::CopyBitmap

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

TInt CIHLBitmap::CopyBitmap( const CFbsBitmap& aSource, CFbsBitmap& aDestination )

	{

	TSize size( aSource.SizeInPixels() );

	TDisplayMode displayMode( aSource.DisplayMode() );

	TInt err( aDestination.Create( size, displayMode ) );

	if( !err )

		{

		err = CopyBitmapData( aSource, aDestination, size, displayMode );

		if( err )

			{

			aDestination.Reset();

			}

		}

	return err;

	}

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

// CIHLBitmap::CopyBitmapData

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

TInt CIHLBitmap::CopyBitmapData( const CFbsBitmap& aSource, CFbsBitmap& aDestination,

								 const TSize& aSize, const TDisplayMode& aDisplayMode )

	{

	HBufC8* scanLine = HBufC8::New( aSource.ScanLineLength( aSize.iWidth, aDisplayMode ) );

	if( scanLine )

		{

		TPtr8 scanPtr( scanLine->Des() );

		TPoint pp;

		for( pp.iY = 0; pp.iY < aSize.iHeight; ++pp.iY )

			{

			aSource.GetScanLine( scanPtr, pp, aSize.iWidth, aDisplayMode );

			aDestination.SetScanLine( scanPtr, pp.iY );

			}

		delete scanLine;

		return KErrNone;

		}

	return KErrNoMemory; // scanLine alloc failed

	}

//  End of File