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

#define SCALE_FACTOR 1.5

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

// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::ConstructL()
    {
    iScaler = CTelBubbleImageScaler::NewL( *this );
    }

// ---------------------------------------------------------------------------
// 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()
    {
    delete iScaler;
    iScaler = NULL;
    
    delete iScaledImage;
    iScaledImage = NULL;	
    }

// ---------------------------------------------------------------------------
// ReadBubbleHeader
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::ReadBubbleHeader( 
    const CBubbleHeader& aHeader )
    {
    iBubble = aHeader.BubbleId();
    TBool thumbnail( EFalse );
    TBool noScaling( EFalse );
    
    if ( aHeader.CallObjectImage() )
        {
        iBitmap = aHeader.CallObjectImage();
        iMask = aHeader.CallObjectImageMask();
        }
    else if ( aHeader.TnBitmap() )
        {
        iBitmap = aHeader.TnBitmap();
        iMask = aHeader.TnBitmapMask();
        thumbnail = ETrue;
        }
    else
        {
        iBitmap = NULL;
        }
    
    iThreeLinedBubble = ( aHeader.CNAP().Length() > 0 );
    
    // PrepareBitmapsL() needs to know if a brand new thumbnail is about to get prepared.
    if ( thumbnail && (iOldBitmap != NULL) && (iOldBitmap == iBitmap) && (iScaler->GetState() != CTelBubbleImageScaler::EScalingStarted) )
        {
        noScaling = ETrue;
        }
    
    if ( iBitmap )
        {
        iOldBitmap = iBitmap;
        
        CFbsBitmap* bitmap( NULL );
        CFbsBitmap* mask( NULL );
        TBool bitmapOwnership( EFalse );
        TBool maskOwnership( EFalse );
        
        TRAPD(err, PrepareBitmapsL( bitmap, 
                                    bitmapOwnership, 
                                    mask, 
                                    maskOwnership,
                                    aHeader.CallObjectImageType() == 
                                    CBubbleHeader::EThemeImage,
                                    noScaling ));
        
        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 );
        
        // upscale thumbnails if loading it for the first time.
        if ( thumbnail && !noScaling && ( iScaler->GetState() != CTelBubbleImageScaler::EScalingStarted ) )
            {
            StartScaling( iBitmap );
            }
        }
    }

// ---------------------------------------------------------------------------
// PrepareBitmapsL
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::PrepareBitmapsL( 
    CFbsBitmap*& aBitmap,
    TBool& aBitmapOwnership, 
    CFbsBitmap*& aMask,
    TBool& aMaskOwnership,
    TBool aIsScalable,
    TBool aThumbnail )
    {
    if ( aThumbnail )
        {
        aBitmap = iScaledImage;
        }
    else
        {
        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 );
            }
        }
    }

// ---------------------------------------------------------------------------
// CTelBubbleCallImage::ImageScalingComplete
//
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::ImageScalingComplete( TInt aError,
        CFbsBitmap* aBitmap )
    {
    if ( aError == KErrNone )
        {
        // Draw the scaled image
        iScaledImage = aBitmap;
        iScaler->SetState( CTelBubbleImageScaler::EScalingDone );
        
        CFbsBitmap* bitmap( NULL );
        CFbsBitmap* mask( NULL );
        TBool bitmapOwnership( EFalse );
        TBool maskOwnership( EFalse );
      
        TRAPD(err, PrepareBitmapsL( bitmap, 
                                    bitmapOwnership, 
                                    mask, 
                                    maskOwnership,
                                    EFalse,
                                    ETrue ) );
        
        if ( err )
            {
            return;
            }
                
        if ( iCallImage->ControlType() == 
             CTelBubbleCustomElement::EBubbleCallImage )
            {
            CTelBubbleCallImage* image = 
                static_cast<CTelBubbleCallImage*> ( iCallImage->Control() );
            image->SetImage( bitmap, EFalse, mask, maskOwnership );
            } 

        SizeChanged();
        
        iIsUsed = ETrue;
        MakeVisible( ETrue );
        
        Parent()->DrawNow(); // refreshing view with scaled image
        }
    else if ( aError == KErrCancel )
        {
        // error is ignored
        // This error is returned when a previous scaling is cancelled
        // while new scaling request is given to active object
        }
    else
        {
        // draw the unscaled image in error cases
    
        delete iScaledImage;
        iScaledImage = NULL;
        }
    
    iScaler->SetState( CTelBubbleImageScaler::EScalingDone );
    }

// ---------------------------------------------------------------------------
// CTelBubbleCallImage::StartScaling
//
// ---------------------------------------------------------------------------
//
void CBubbleMainPaneControl::StartScaling( CFbsBitmap *aSourceBitmap )
    {
    if ( !iScaler )
        {
        return;
        }
    
    iScaler->Cancel(); // cancels any outstanding scaling requests
    
    delete iScaledImage;
    iScaledImage = NULL;

    // create a bitmap for scaled size
    iScaledImage = new CFbsBitmap();
    if ( !iScaledImage )
        {
        // no scaling in error cases
        iScaler->SetState( CTelBubbleImageScaler::EScalingIdle );
        return;
        }

    TSize size = aSourceBitmap->SizeInPixels();
    TRect scaledRect( 0, 0, size.iWidth * SCALE_FACTOR, size.iHeight * SCALE_FACTOR );
    
    TInt error = iScaledImage->Create( scaledRect.Size(), aSourceBitmap->DisplayMode() );
    if ( error != KErrNone )
        {
        delete iScaledImage;
        iScaledImage = NULL;
        iScaler->SetState( CTelBubbleImageScaler::EScalingIdle );
        }
    else
        {
        //start scaling
        TRAPD( err, iScaler->StartScaleL( aSourceBitmap, iScaledImage ) );
        if (err != KErrNone)
            {
            iScaler->SetState( CTelBubbleImageScaler::EScalingIdle );
            delete iScaledImage;
            iScaledImage = NULL;
            }
        }
    }
	
// END OF FILE