/*

* Copyright (c) 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:  Call image control.

*

*/

#include <telbubblecallimage.h>

#include <gdi.h>

// ======== LOCAL FUNCTIONS ========

/**

 * Draws rounded rect. Used for drawing frame to caller image bitmap.

 */

void DrawRoundRect(CWindowGc& aGC, TPoint aTopLeft, TSize aSize )

    {   

    const TRgb white( 255, 255, 255);

    aGC.SetPenColor( white );

    aGC.SetPenSize( TSize( 5, 5 ) );

    TPoint bottomRight = aTopLeft + aSize;

    TRect decoratorRect( aTopLeft, bottomRight );

    // Make rect litle larger so that it will be outside of the caller image, 

    // so that bitmap's corners are hidden.

    decoratorRect.Grow( 2, 2 ); 

    const TSize ellipsesSize( 10, 10 );

    aGC.DrawRoundRect( decoratorRect, ellipsesSize );

    }

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

// Constructor

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

//

EXPORT_C CTelBubbleCallImage::CTelBubbleCallImage()

    {

    }

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

// NewL

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

//

EXPORT_C CTelBubbleCallImage* CTelBubbleCallImage::NewL()

    {

    CTelBubbleCallImage* self = new( ELeave )CTelBubbleCallImage();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

EXPORT_C CTelBubbleCallImage::~CTelBubbleCallImage()

    {

    if ( iImageOwnership )

        {

        delete iImage;

        }

    if ( iMaskOwnership )

        {

        delete iMask;

        }

    }

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

// CTelBubbleCallImage::ConstructL

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

//

EXPORT_C void CTelBubbleCallImage::ConstructL()

    {

    }

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

// CTelBubbleCallImage::SetImage

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

//

EXPORT_C void CTelBubbleCallImage::SetImage( 

    CFbsBitmap* aImage, 

    TBool aImageOwnership,

    CFbsBitmap* aMask,

    TBool aMaskOwnership )

    {

    if ( iImageOwnership )

        {

        delete iImage;

        }

    if ( iMaskOwnership )

        {

        delete iMask;

        }

    iImage = aImage;

    iMask = aMask;

    iImageOwnership = aImageOwnership;

    iMaskOwnership = aMaskOwnership;

    SizeChanged();

    ImageChanged();

    }

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

// CTelBubbleCallImage::ReleaseImage

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

//

EXPORT_C void CTelBubbleCallImage::ImageChanged()

    {

    }

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

// CTelBubbleCallImage::ReleaseImage

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

//

EXPORT_C void CTelBubbleCallImage::SetImagePlacingArea( TRect& aRect )

    {

    iImagePlacingArea = aRect;

    }

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

// CTelBubbleCallImage::ReleaseImage

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

//

EXPORT_C const CFbsBitmap* CTelBubbleCallImage::Image() const

    {

    return iImage;

    }

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

// CTelBubbleCallImage::ReleaseImage

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

//

EXPORT_C const CFbsBitmap* CTelBubbleCallImage::Mask() const

    {

    return iMask;

    }

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

// CTelBubbleCallImage::IsFullScreenImage

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

//

EXPORT_C TBool CTelBubbleCallImage::IsFullScreenImage() const

    {

    TBool isFullScreen = ETrue;

    if ( iImage )

        {

        TSize imageSize = iImage->SizeInPixels();

        TSize thisSize( Rect().Size() );

        isFullScreen = ( imageSize.iWidth >= thisSize.iWidth ) ||

                       ( imageSize.iHeight >= thisSize.iHeight );

        }

    return isFullScreen;  

    }

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

// CTelBubbleCallImage::Offset

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

//

EXPORT_C const TPoint& CTelBubbleCallImage::Offset() const

    {

    return iOffset;

    }

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

// CTelBubbleCallImage::SourceRect

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

//

EXPORT_C const TRect& CTelBubbleCallImage::SourceRect() const

    {

    return iSourceRect;

    }

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

// CTelBubbleCallImage::ImagePlacingArea

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

//

EXPORT_C const TRect& CTelBubbleCallImage::ImagePlacingArea() const

    {

    return iImagePlacingArea;

    }

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

// CTelBubbleCallImage::SizeChanged

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

//

EXPORT_C void CTelBubbleCallImage::SizeChanged()

    {

    if ( !iImage )

        {

        return;                    

        }

    // If bitmap is bigger than drawing area then clip from center of the image.

    TRect rect = Rect();

    iSourceRect = iImage->SizeInPixels();

    TInt offsetX = ( iSourceRect.Width() > rect.Width() ) ? 

                   ((iSourceRect.Width() - rect.Width()) / 2) : 0;

    TInt offsetY = ( iSourceRect.Height() > rect.Height() ) ? 

                   ((iSourceRect.Height() - rect.Height()) / 2) : 0;

    iSourceRect.Shrink( offsetX, offsetY ); 

    // If bitmap is smaller than the drawing area then center the image on it.

    iOffset.iX = ( iSourceRect.Width() < rect.Width() ) ? 

                ((rect.Width() - iSourceRect.Width()) / 2) : 0;

    iOffset.iY = 0;

    // lift the image higher if needed.

    if ( iSourceRect.Height() < rect.Height() )

        {

        // check if it fits totally above the bubble

        TInt height = iImagePlacingArea.iBr.iY - iImagePlacingArea.iTl.iY;

        if ( iSourceRect.Height() < height )

            {

            // if it fits then center it above the bubble

            iOffset.iY = ( height - iSourceRect.Height() ) / 2;

            }

        }

    }

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

// CTelBubbleCallImage::Draw

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

//

EXPORT_C void CTelBubbleCallImage::Draw( const TRect& /*aRect*/ ) const

    {

    if ( iImage )

        {

        CWindowGc& gc = SystemGc();

        const TPoint topLeft = Rect().iTl;

        const TPoint bitmapTopLeft = topLeft + iOffset;

        // if we have y offset then the image wont go under the bubble in any case and so

        // no need for masking

        if ( iMask && iOffset.iY == 0 ) 

            {

            gc.BitBltMasked( bitmapTopLeft,

                         iImage, 

                         iSourceRect, 

                         iMask, 

                         EFalse );

            }

        else

            {

            gc.BitBlt( bitmapTopLeft,

                   iImage,

                   iSourceRect );    

            }

        DrawRoundRect( gc, bitmapTopLeft, iSourceRect.Size() );

        }

    }

// end of file