/*

* Copyright (c) 2002-2006 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:  Utility methods for call object handling.

*

*/

// INCLUDE FILES

#include    "BMCallObjectUtils.h"

#include    "BMLayout2.h"

#include    "BMUtils.h"

#include    "BMPanic.h"

#include    <AknUtils.h>

#include    <AknBidiTextUtils.h>

#include    <AknLayoutFont.h>

// CONSTANTS

const TReal KBMCallObjectScaleFactorMax = 1.0;

_LIT( KSpaceChar, " " );

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

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

// BubbleCallObjectUtils::CreateBitmapL

//

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

//    

CFbsBitmap* BubbleCallObjectUtils::CreateBitmapL( 

    const CFbsBitmap* aBitmap, 

    const TSize& aTargetSize,

    TDisplayMode aDisplayMode,

    TTileMode aTileMode )

    {

    __ASSERT_ALWAYS( aBitmap, User::Leave( KErrArgument ) );

    // get scaling factor

    TReal scalingFactor = ScalingFactor( aBitmap->SizeInPixels(),

                                         aTargetSize,

                                         EFillTarget );

    if ( scalingFactor > 1.0 ) // bitmap scaling not supported

        {

        // image smaller than target area is tiled

        return CreateTiledBitmapL( aBitmap, 

                                   aTargetSize, 

                                   aDisplayMode, 

                                   aTileMode );

        }

    else        

        {

        // image bigger than target area is clipped

        return CreateCroppedBitmapL( aBitmap,

                                     aTargetSize,

                                     aDisplayMode );    

        }

    }

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

// BubbleCallObjectUtils::CreateCroppedBitmapL

//

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

//    

CFbsBitmap* BubbleCallObjectUtils::CreateCroppedBitmapL( 

    const CFbsBitmap* aBitmap, 

    const TSize& aTargetSize,

    TDisplayMode aDisplayMode )

    {

    __ASSERT_ALWAYS( aBitmap, User::Leave( KErrArgument ) );

    // create bitmap

    CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

    CleanupStack::PushL( bitmap );

    // calculate cropping rectangle   

    TSize sourceBitmapSize( aBitmap->SizeInPixels() );

    TRect croppingRect( TPoint(0,0), sourceBitmapSize );

    TInt xDelta( sourceBitmapSize.iWidth - aTargetSize.iWidth );

    if ( xDelta < 0 )

        {

        // do not crop horizontally

        xDelta = 0;    

        }

    TInt yDelta( sourceBitmapSize.iHeight - aTargetSize.iHeight );

    if ( yDelta < 0 )

        {

        // do not crop vertically

        yDelta = 0;    

        }

    if ( xDelta == 0 && yDelta == 0 )

        {

        // cropping not required -> just duplicate

        User::LeaveIfError( bitmap->Duplicate( aBitmap->Handle() ) );

        CleanupStack::Pop( bitmap );

        return bitmap;                            

        }

    else

        {

        // shrink to cropping area

        croppingRect.Shrink( xDelta/2, yDelta/2 );        

        }

    // create bitmap to target size

    User::LeaveIfError( bitmap->Create( aTargetSize, 

                                        aDisplayMode ) );

    // crop

    CFbsBitmapDevice* bitmapDev = 

        CFbsBitmapDevice::NewL( bitmap );

    CleanupStack::PushL( bitmapDev );

    CFbsBitGc* bitmapCtx;

    User::LeaveIfError( bitmapDev->CreateContext( bitmapCtx ) );

    CleanupStack::PushL( bitmapCtx );                                               

    TRect targetRect( TPoint(0,0), aTargetSize );

    bitmapCtx->DrawBitmap( targetRect, aBitmap, croppingRect );    

    CleanupStack::PopAndDestroy( 2, bitmapDev );

    CleanupStack::Pop( bitmap );

    return bitmap;            

    }

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

// BubbleCallObjectUtils::CreateTiledBitmapL

//

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

//    

CFbsBitmap* BubbleCallObjectUtils::CreateTiledBitmapL( 

    const CFbsBitmap* aBitmap, 

    const TSize& aTargetSize,

    TDisplayMode aDisplayMode,

    TTileMode aTileMode )

    {

    __ASSERT_ALWAYS( aBitmap, User::Leave( KErrArgument ) );

    TSize sourceSize = aBitmap->SizeInPixels();

    TPoint offset(0,0);

    // calculate offset for brush origin

    // horizontal offset

    if ( aTargetSize.iWidth <= sourceSize.iWidth )

        {

        // wide image -> center horizontally

        offset.iX = ( sourceSize.iWidth - aTargetSize.iWidth ) / 2;    

        }

    else if ( ( aTileMode == ETileCenterRight ) ||

              ( aTileMode == ETileTopRight ) )

        {

        // begin tiling from right

        offset.iX = sourceSize.iWidth - ( aTargetSize.iWidth % 

                                          sourceSize.iWidth );    

        }

    // vertical offset

    if ( aTargetSize.iHeight <= sourceSize.iHeight )

        {

        // tall image -> center vertically 

        offset.iY = ( sourceSize.iHeight - aTargetSize.iHeight ) / 2;    

        }

    else if ( ( aTileMode == ETileCenterRight ) ||

              ( aTileMode == ETileCenterLeft ) )

        {

        // middle most tile is centered vertically

        TInt topMargin = ( aTargetSize.iHeight - sourceSize.iHeight ) / 2;

        if ( topMargin <= sourceSize.iHeight )

            {

            offset.iY = ( sourceSize.iHeight - topMargin );    

            }

        else

            {

            offset.iY = sourceSize.iHeight - ( topMargin % 

                                               sourceSize.iHeight );    

            }            

        }

    // create bitmap to target size

    CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

    CleanupStack::PushL( bitmap );

    User::LeaveIfError( bitmap->Create( aTargetSize, 

                                        aDisplayMode ) );            

    // create device and graphics context

    CFbsBitmapDevice* bitmapDev = CFbsBitmapDevice::NewL( bitmap );

    CleanupStack::PushL( bitmapDev );

    CFbsBitGc* bitmapCtx;

    User::LeaveIfError( bitmapDev->CreateContext( bitmapCtx ) );

    CleanupStack::PushL( bitmapCtx );         

    // do tiling by using patterned brush

    CFbsBitmap* pattern = new(ELeave) CFbsBitmap;

    CleanupStack::PushL( pattern );

    User::LeaveIfError( pattern->Duplicate( aBitmap->Handle() ) );

    TRect bitmapRect( TPoint(0,0), aTargetSize );

    bitmapCtx->SetPenStyle( CGraphicsContext::ENullPen ); 

    bitmapCtx->SetBrushStyle( CGraphicsContext::EPatternedBrush ); 

    bitmapCtx->UseBrushPattern( pattern );

    bitmapCtx->SetBrushOrigin( -offset );

    bitmapCtx->DrawRect( bitmapRect );

    bitmapCtx->DiscardBrushPattern();

    CleanupStack::PopAndDestroy( 3, bitmapDev );

    CleanupStack::Pop( bitmap ); 

    return bitmap;       

    }    

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

// BubbleCallObjectUtils::CreateImageBitmapsFromTextLC

//

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

//    

void BubbleCallObjectUtils::CreateImageBitmapsFromTextLC(

    const TDesC& aText,

    const TRect& aMainPaneRect, 

    const TSize& aSize,

    const TRgb&  aTextColor,

    TUint aAlpha,

    TDisplayMode aDisplayMode,

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask )

    {

    // create bitmap

    aBitmap= new(ELeave) CFbsBitmap;

    CleanupStack::PushL( aBitmap );

    User::LeaveIfError( aBitmap->Create( aSize, aDisplayMode ) );

    // create mask

    aMask = new(ELeave) CFbsBitmap;

    CleanupStack::PushL( aMask );

    User::LeaveIfError( aMask->Create( aSize, EGray256 ) );

    // create bitmap context

    CFbsBitmapDevice* bitmapDev = CFbsBitmapDevice::NewL( aBitmap );

    CleanupStack::PushL( bitmapDev );

    CFbsBitGc* bitmapGc;

    User::LeaveIfError( bitmapDev->CreateContext( bitmapGc ) ); 

    CleanupStack::PushL( bitmapGc );    

    // create mask context

    CFbsBitmapDevice* maskDev = CFbsBitmapDevice::NewL( aMask );

    CleanupStack::PushL( maskDev );

    CFbsBitGc* maskGc;

    User::LeaveIfError( maskDev->CreateContext( maskGc ) ); 

    CleanupStack::PushL( maskGc );

    // initialize bitmap

    bitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

    bitmapGc->SetPenStyle( CGraphicsContext::ENullPen );

    bitmapGc->SetBrushColor( KRgbWhite );

    bitmapGc->DrawRect( TRect( aSize ) );

    bitmapGc->SetPenStyle( CGraphicsContext::ESolidPen );

    bitmapGc->SetBrushStyle( CGraphicsContext::ENullBrush );

    // initialize mask

    maskGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

    maskGc->SetPenStyle( CGraphicsContext::ENullPen );

    maskGc->SetBrushColor( KRgbBlack );

    maskGc->DrawRect( TRect( aSize ) );

    maskGc->SetPenStyle( CGraphicsContext::ESolidPen );

    maskGc->SetBrushStyle( CGraphicsContext::ENullBrush );

    // reserve text buffers

    TAknLayoutRect textPaneLayout;

    textPaneLayout.LayoutRect( aMainPaneRect,

                             BubbleLayout2::call2_cli_visual_text_pane() );

    TRect textPaneRect = textPaneLayout.Rect();                             

    TAknLayoutText textLayout;

    textLayout.LayoutText( textPaneRect, 

                           BubbleLayout2::call2_main_pane_text( 0 ) );

    const CFont* font = textLayout.Font();

    TInt lineWidth = textLayout.TextRect().Size().iWidth;

    TInt averageFontWidth( font->WidthZeroInPixels() );

    TInt maxCharsPerLine( lineWidth / averageFontWidth );

    maxCharsPerLine = maxCharsPerLine * 4; // to secure

    HBufC* logicalLineBuf = HBufC::NewL( maxCharsPerLine );

    CleanupStack::PushL( logicalLineBuf );

    HBufC* visualLineBuf = HBufC::NewL( maxCharsPerLine + 

                                        KAknBidiExtraSpacePerLine );

    CleanupStack::PushL( visualLineBuf );

    TPtr logicalLine( logicalLineBuf->Des() );

    TPtr visualLine( visualLineBuf->Des() );

    TRgb alphaColor( aAlpha, aAlpha, aAlpha );

    TInt currentRow = 0;

    TInt i = 0;

    TInt textLength = aText.Length();    

    const TInt numberOfRows = 

        BubbleLayout2::call2_cli_visual_text_number_of_rows();

    // shift gc origin

    TPoint offset( (aMainPaneRect.Size().iWidth - aSize.iWidth) / 2,

                   (aMainPaneRect.Size().iHeight - aSize.iHeight) / 2 );

    bitmapGc->SetOrigin( -offset );

    maskGc->SetOrigin( -offset );

    // render text

    while ( currentRow <= numberOfRows )

        {

        TAknLayoutText textLayout;

        textLayout.LayoutText( textPaneRect,

            BubbleLayout2::call2_main_pane_text( currentRow ) );

        TRect textRect = textLayout.TextRect();            

        if ( ( textRect.iBr.iY < offset.iY ) || 

             ( textRect.iTl.iY > ( offset.iY + aSize.iHeight ) ) )

            {

            // this line is outside the bitmap.

            currentRow++;

            continue;                

            }

        logicalLine.Zero();

        TBool clipped( EFalse );

        do // Find the clipping point

            {

            TChar c( aText[i] );

            if( logicalLine.Length() == maxCharsPerLine )

                {

                User::Leave( KErrOverflow );

                }

            logicalLine.Append( c );

            i++;

            if ( i == textLength )

                {

                if( logicalLine.Length() == maxCharsPerLine )

                    {

                    User::Leave( KErrOverflow );

                    }

                // start over to fill whole pane

                i = 0;

                logicalLine.Append( KSpaceChar );

                }

            visualLine.Zero();

            clipped = AknBidiTextUtils::ConvertToVisualAndClip(

                logicalLine,

                visualLine,

                *font,

                lineWidth,

                lineWidth,

                AknBidiTextUtils::EImplicit,

                0xFFFF );

            } while ( !clipped );

        // Remove the last character that caused clipping

        if ( logicalLine.Length() )

            {

            logicalLine.SetLength( logicalLine.Length() - 1 );                

            }

        AknBidiTextUtils::ConvertToVisualAndClip(

            logicalLine,

            visualLine,

            *font,

            lineWidth,

            lineWidth,

            AknBidiTextUtils::EImplicit,

            0xFFFF );

        textLayout.DrawText( *bitmapGc, visualLine, EFalse, aTextColor );

        textLayout.DrawText( *maskGc, visualLine, EFalse, alphaColor );

        // clipped -> go back by one        

        i = i > 0 ? (i - 1) : (textLength-1);                    

        currentRow++;

        }

    CleanupStack::PopAndDestroy(6, bitmapDev);

    }

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

// BubbleCallObjectUtils::ScalingFactor

//

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

//

TReal BubbleCallObjectUtils::ScalingFactor( 

    const TSize& aSourceSize,

    const TSize& aTargetSize,

    TScaleMode aScaleMode )

    {

    if ( aTargetSize == TSize(0,0) || aSourceSize == TSize(0,0) )

        {

        return 0;    

        }

    // check aspect ratios

    TReal targetAspectRatio = (TReal) aTargetSize.iWidth / 

                              (TReal) aTargetSize.iHeight;

    TReal sourceAspectRatio = (TReal) aSourceSize.iWidth  / 

                              (TReal) aSourceSize.iHeight;

    TReal scaleFactor = 1.0; 

    if ( sourceAspectRatio == targetAspectRatio )

        {

        // aspect ratios are same.

        return (TReal) aTargetSize.iWidth / (TReal) aSourceSize.iWidth;

        }

    else if ( targetAspectRatio > sourceAspectRatio )

        {

        // target wide more screen than source.

        if ( aScaleMode == EFillTarget )

            {

            // width defines the scale

            scaleFactor = (TReal) aTargetSize.iWidth / 

                          (TReal) aSourceSize.iWidth;    

            }

        else // EMaximumFit

            {

            // height defines the scale

            scaleFactor = (TReal) aTargetSize.iHeight / 

                          (TReal) aSourceSize.iHeight;    

            }            

        }

    else

        {

        // video is more wide screen than window.

        if ( aScaleMode == EFillTarget )

            {

            // height defines the scale

            scaleFactor = (TReal) aTargetSize.iHeight / 

                          (TReal) aSourceSize.iHeight;    

            }

        else // EMaximumFit

            {

            // width defines the scale

            scaleFactor = (TReal) aTargetSize.iWidth / 

                          (TReal) aSourceSize.iWidth;    

            }            

        }

    return scaleFactor;        

    }

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

// BubbleCallObjectUtils::GetScaleFactorAndClipRect

//

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

//    

TBool BubbleCallObjectUtils::GetScaleFactorAndClipRect( 

    const TSize& aSourceSize,

    const TSize& aTargetSize,

    TScaleMode aScaleMode,

    TReal& aScaleFactor,

    TRect& aClipRect )

    {

    TBool isTinyImage( EFalse );

    // scaling to fit main pane

    TReal scaleFactor = BubbleCallObjectUtils::ScalingFactor(

        aSourceSize,

        aTargetSize,

        aScaleMode );

    // set clipping rect

    TRect clipRect;

    if ( aScaleMode == EMaximumFit )

        {

        aScaleFactor = scaleFactor > KBMCallObjectScaleFactorMax ?

                       KBMCallObjectScaleFactorMax : scaleFactor; 

        aClipRect = TRect( aSourceSize ); // no clip   

        }

    else if ( scaleFactor == 0 )

        {

        aScaleFactor = scaleFactor;

        aClipRect = TRect( aSourceSize );    

        }

    else if ( scaleFactor > KBMCallObjectScaleFactorMax )

        {

        isTinyImage = ETrue;

        aScaleFactor = KBMCallObjectScaleFactorMax;

        TInt x_offset = 0;

        if ( aSourceSize.iWidth > aTargetSize.iWidth )

            {

            // center horizontally

            x_offset =

                ( aSourceSize.iWidth - aTargetSize.iWidth ) / 4;

            }

        TInt y_offset = 0;

        if ( aSourceSize.iHeight > aTargetSize.iHeight )

            {

            // center vertically

            y_offset =

                ( aSourceSize.iHeight - aTargetSize.iHeight ) / 4;    

            }

        aClipRect = TRect( aSourceSize );

        aClipRect.Shrink( x_offset, y_offset );    

        }

    else // 0 < scaleFactor < KBMCallObjectScaleFactorMax

        {

        aScaleFactor = scaleFactor;

        TSize relativeTargetSize;

        relativeTargetSize.iWidth = aTargetSize.iWidth / scaleFactor;

        relativeTargetSize.iHeight = aTargetSize.iHeight / scaleFactor;

        TInt x_offset = ( aSourceSize.iWidth - 

                          relativeTargetSize.iWidth ) / 2;

        TInt y_offset = ( aSourceSize.iHeight - 

                          relativeTargetSize.iHeight ) / 2;

        aClipRect = TRect( relativeTargetSize );

        if ( x_offset >= 0 && y_offset >= 0 )

            {

            // clip from center of the source image

            aClipRect.Move( x_offset, y_offset );    

            }

        }