/*
* 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 status indicator
*
*/


#include "BMBubbleManager.h"
#include "BMMainPaneControl.h"
#include "BMCustomManager.h"
#include "BMBubbleHeader.h"
#include "BMUtils.h"
#include "BMCallObjectManager.h"
#include "BMBubbleImageManager.h"

#include <telbubblecallimage.h>
#include <AknIconUtils.h>
#include <layoutmetadata.cdl.h>

// ---------------------------------------------------------------------------
// C++ constructor
// ---------------------------------------------------------------------------
//
CBubbleMainPaneControl::CBubbleMainPaneControl( 
    CBubbleManager& aBubbleManager,  
    CBubbleCallObjectManager& aCallObjectManager ) : 
    iBubbleManager( aBubbleManager ), 
    iCallObjectManager ( aCallObjectManager )
    {
    }

// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::ConstructL()
    {
    }

// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CBubbleMainPaneControl* CBubbleMainPaneControl::NewL(
    CBubbleManager& aBubbleManager,
    CBubbleCallObjectManager& aCallObjectManager )
    {
    CBubbleMainPaneControl* self = 
        new( ELeave ) CBubbleMainPaneControl( aBubbleManager, 
                                               aCallObjectManager );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CBubbleMainPaneControl::~CBubbleMainPaneControl()
    {
    }

// ---------------------------------------------------------------------------
// ReadBubbleHeader
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::ReadBubbleHeader( 
    const CBubbleHeader& aHeader )
    {
    iBubble = aHeader.BubbleId();
    iBitmap = aHeader.CallObjectImage();
    iMask = aHeader.CallObjectImageMask();
    iThreeLinedBubble = ( aHeader.CNAP().Length() > 0 );
    
    if ( iBitmap )
        {
        CFbsBitmap* bitmap;
        CFbsBitmap* mask;
        TBool bitmapOwnership;
        TBool maskOwnership;
        
        TRAPD(err, PrepareBitmapsL( bitmap, 
                                    bitmapOwnership, 
                                    mask, 
                                    maskOwnership,
                                    aHeader.CallObjectImageType() == 
                                    CBubbleHeader::EThemeImage ) );
        
        if ( err )
            {
            return;
            }

        iCallImage = iBubbleManager.CustomManager().ReserveCustomElement(
                aHeader, CTelBubbleCustomElement::ECallImage );
        SizeChanged();
        
        if ( iCallImage->ControlType() == 
             CTelBubbleCustomElement::EBubbleCallImage )
            {
            CTelBubbleCallImage* image = 
                static_cast<CTelBubbleCallImage*> ( iCallImage->Control() );
            image->SetImage( bitmap, EFalse, mask, maskOwnership );
            } 
        
        iIsUsed = ETrue;
        MakeVisible( ETrue );
        }
    }

// ---------------------------------------------------------------------------
// PrepareBitmapsL
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::PrepareBitmapsL( 
    CFbsBitmap*& aBitmap,
    TBool& aBitmapOwnership, 
    CFbsBitmap*& aMask,
    TBool& aMaskOwnership,
    TBool aIsScalable )
    {
    aBitmap = iBitmap;
    aMask = iMask;
    aBitmapOwnership = EFalse;
    aMaskOwnership = EFalse;
    
    if ( aIsScalable )
        {
        // Switch to preloaded image when available
        if ( iCallObjectManager.CallThemeImageIcon() )
            {
            aBitmap = iCallObjectManager.CallThemeImageIcon()->Bitmap();
            aMask = iCallObjectManager.CallThemeImageIcon()->Mask();
            }
    
        // Secure that SVG image is initialized
        User::LeaveIfError( AknIconUtils::SetSize( aBitmap,
             iBubbleManager.MainPaneImageRect().Size(),
             EAspectRatioPreservedSlice ) != KErrNone );
        }
    
    TSize imageSize = aBitmap->SizeInPixels();
    TSize tinyImageSize( iBubbleManager.MainPaneImageRect( ETrue ).Size() );
    TBool fullScreen = !( ( imageSize.iWidth <= tinyImageSize.iWidth ) &&
                          ( imageSize.iHeight <= tinyImageSize.iHeight ) );  
    
    if ( iBubbleManager.IsTouchCallHandling() &&
         fullScreen )
        {
        // Attach display mask to image.
        CEikImage* displayMask = new( ELeave ) CEikImage;
        CleanupStack::PushL( displayMask ); 
    
        TBMIcons maskId = 
            Layout_Meta_Data::IsLandscapeOrientation() ?
            EQgn_indi_call4_image_mask_lsc :
            EQgn_indi_call4_image_mask_prt;
    
        iBubbleManager.ImageManager().SetBitmapToImage( 
            displayMask,
            maskId );
    
        User::LeaveIfError( AknIconUtils::SetSize( 
            const_cast<CFbsBitmap*> (displayMask->Bitmap()),
            imageSize,
            EAspectRatioNotPreserved ) );
            
        if ( aMask )
            {
            // Combine display mask and image mask.
            CFbsBitmap* combinedMask = 
                BubbleUtils::CreateCombinedMaskL(
                    displayMask->Bitmap(),
                    aMask );        
            aMask = combinedMask;
            }
        else
            {
            aMask = 
                const_cast<CFbsBitmap*> ( displayMask->Bitmap());
            displayMask->SetPictureOwnedExternally( ETrue );
            }                        
            
        aMaskOwnership = ETrue;    
        CleanupStack::PopAndDestroy( displayMask );
        }    
    }

// ---------------------------------------------------------------------------
// Reset
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::Reset()
    {
    if ( iIsUsed )
        {
        iIsUsed = EFalse;
        MakeVisible( EFalse );
        iBubble = KErrNotFound;
        
        if ( iCallImage && 
             iCallImage->ControlType() == 
             CTelBubbleCustomElement::EBubbleCallImage )
            {
            CTelBubbleCallImage* image = 
                static_cast<CTelBubbleCallImage*> ( iCallImage->Control() );
            image->SetImage( NULL, EFalse, NULL, EFalse );
            }
        
        iBubbleManager.CustomManager().ReleaseCustomElement( iCallImage );
        }
    }

// ---------------------------------------------------------------------------
// DrawBitmaps
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::DrawBitmaps( const TRect& aRect ) const
    {
    if ( iCallImage )
        {
        // ToDo: propagate to components
        iCallImage->Control()->DrawForeground( aRect );
        }
    }

// ---------------------------------------------------------------------------
// BubbleId
// ---------------------------------------------------------------------------
//
CBubbleManager::TBubbleId CBubbleMainPaneControl::BubbleId() const
    {
    return iBubble;
    }

// ---------------------------------------------------------------------------
// IsUsed
// ---------------------------------------------------------------------------
//
TBool CBubbleMainPaneControl::IsUsed() const
    {
    return iIsUsed;
    }

// ---------------------------------------------------------------------------
// SizeChanged
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::SizeChanged()
    {
    if ( iCallImage )
        {
        iCallImage->Control()->SetRect( Rect() );
        if ( iCallImage->ControlType() == 
             CTelBubbleCustomElement::EBubbleCallImage )
            {
            CTelBubbleCallImage* image = 
                static_cast<CTelBubbleCallImage*> ( iCallImage->Control() );
            TRect imageArea( iBubbleManager.MainPaneImageRect( 
                                 ETrue, iThreeLinedBubble ) );
            
            image->SetImagePlacingArea( imageArea );
            }
        }
    }

// END OF FILE