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

// ---------------------------------------------------------------------------
// 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.
    TRect rect;
    if ( IsFullScreenImage() )
        {
        rect = Rect();
        }
    else
        {
        rect = ImagePlacingArea();
        }
    
    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 drawing area then center it.
    iOffset.iX = ( iSourceRect.Width() < rect.Width() ) ? 
                ((rect.Width() - iSourceRect.Width()) / 2) : 0;
    iOffset.iY = ( iSourceRect.Height() < rect.Height() ) ? 
                ((rect.Height() - iSourceRect.Height()) / 2) : 0;
    }


// ---------------------------------------------------------------------------
// CTelBubbleCallImage::Draw
// ---------------------------------------------------------------------------
//
EXPORT_C void CTelBubbleCallImage::Draw( const TRect& /*aRect*/ ) const
    {
    CWindowGc& gc = SystemGc();
    
    TPoint topLeft = IsFullScreenImage() ? Rect().iTl : iImagePlacingArea.iTl;
    
    
    if ( iImage && iMask )
        {
        gc.BitBltMasked( topLeft + iOffset,
                         iImage, 
                         iSourceRect, 
                         iMask, 
                         EFalse );
        }
    else if ( iImage )
        {
        gc.BitBlt( topLeft + iOffset, 
                   iImage,
                   iSourceRect );    
        }
    }

// end of file