/*

* Copyright (c) 2005-2007 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:  Implementation for CPopupBubbleCtrl

*

*/

#include <AknIconUtils.h>

#include <AknsUtils.h>

#include <AknUtils.h>

#include <AknsDrawUtils.h> 

#include "peninputpopupbubble.h"

#include "peninputlayout.h"

#include <peninputpluginutils.h>

#include <imageconversion.h> 

#include "peninputcmd.h"

const TInt KShrinkSize = 10;

const TInt KDefaultTextColorIndex = EAknsCIQsnTextColorsCG60;

const TInt KAlpha = 200;

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

/*****************************************************************************/

// Implementation of Class CPopupBubbleWnd

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

// c++ constructor

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

//

CPopupBubbleWnd::CPopupBubbleWnd(CPopupBubbleCtrl& aParent)

: iParent(aParent),

iSupportTransparent(EFalse)

    {

    }

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

// c++ destructor

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

//

CPopupBubbleWnd::~CPopupBubbleWnd()

    {

    //delete bitmaps    

    iBitGc.ResetAndDestroy();

    iDevice.ResetAndDestroy();

    iBitmap.ResetAndDestroy();       

    }

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

// Symbian constructor

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

//

CPopupBubbleWnd* CPopupBubbleWnd::NewL(const TRect& aRect, CPopupBubbleCtrl& aParent)

    {

    CPopupBubbleWnd* self = CPopupBubbleWnd::NewLC(aRect, aParent);

    CleanupStack::Pop(); // self;

    return self;

    }

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

// Symbian constructor

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

//

CPopupBubbleWnd* CPopupBubbleWnd::NewLC(const TRect& aRect, CPopupBubbleCtrl& aParent)

    {

    CPopupBubbleWnd* self = new ( ELeave ) CPopupBubbleWnd(aParent);

    CleanupStack::PushL( self );

    self->ConstructL(aRect);

    return self;

    }

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

// Symbian second-phase constructor

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

//

void CPopupBubbleWnd::ConstructL(const TRect& aRect)

    {

    RWindowGroup& wg = CCoeEnv::Static()->RootWin();

    CreateWindowL( wg );

    SetComponentsToInheritVisibility();

    Window().SetRequiredDisplayMode( EColor16MA );

    TInt err = Window().SetTransparencyAlphaChannel();

    iSupportTransparent = ( KErrNone == err );

    Window().SetBackgroundColor( TRgb(0,0,0,0) );

    //create bitmaps

    for(TInt i = 0; i<ELastItem; i++)

        {

        CFbsBitmap* bitmap = new (ELeave) CFbsBitmap(); // Bitmap

        CleanupStack::PushL(bitmap);

        iBitmap.AppendL(bitmap); //take ownership

        CleanupStack::Pop(bitmap);

        iBitmap[i]->Create(aRect.Size(), EColor16MA);

        CFbsBitmapDevice* device = CFbsBitmapDevice::NewL(iBitmap[i]); //BitmapDevice

        CleanupStack::PushL(device);

        iDevice.AppendL(device); //take ownership

        CleanupStack::Pop(device);

        CFbsBitGc* bitgc = CFbsBitGc::NewL(); // GraphicsContext

        CleanupStack::PushL(bitgc);

        iBitGc.AppendL(bitgc); //take ownership

        CleanupStack::Pop(bitgc);

        }

    MakeVisible( ETrue );    

    SetRect(aRect);

    ActivateL();

    }

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

// Draw this control

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

//

void CPopupBubbleWnd::Draw(const TRect& aRect) const

    {    

    if ( !iParent.AbleToDraw() )

        {

        return;

        }

    CWindowGc& gc = SystemGc();

    if ( !SupportTransparent() )

        {

        gc.Clear( aRect ); 

        }    

    DrawTransparentBackground( aRect );

    if ( iParent.iForgroundBmp )

        {

        TRect innerRect = aRect;

        innerRect.Shrink( KShrinkSize, 0 );

        TRect iconRect;

        iconRect.iTl = TPoint( innerRect.iTl.iX + iParent.iIconOffset.iWidth, 

                innerRect.iTl.iY + iParent.iIconOffset.iHeight );

        iconRect.SetWidth( iParent.iIconSize.iWidth );

        iconRect.SetHeight( iParent.iIconSize.iHeight );

        if( iParent.iForgroundBmp->SizeInPixels() != iconRect.Size() )

            {

            AknIconUtils::SetSize( iParent.iForgroundBmp, iconRect.Size(), EAspectRatioNotPreserved );

            }

        TRect srcRect( TPoint( 0, 0 ), iParent.iForgroundBmp->SizeInPixels() );

        if( iParent.iForgroundBmpMask )

            {

            if( iParent.iForgroundBmpMask->SizeInPixels() != iconRect.Size() )

                {

                AknIconUtils::SetSize( iParent.iForgroundBmpMask, iconRect.Size(), EAspectRatioNotPreserved);

                }

            gc.SetBrushStyle( CGraphicsContext::ENullBrush );

            gc.BitBltMasked( iconRect.iTl, 

                              iParent.iForgroundBmp, 

                              srcRect,

                              iParent.iForgroundBmpMask,

                              EFalse);

            }

        else

            {

            gc.BitBlt( iconRect.iTl,

                        iParent.iForgroundBmp,

                        srcRect );

            }            

        }

    if ( iParent.iText && iParent.iText->Length() > 0 )

        {

        gc.SetBrushStyle( CGraphicsContext::ENullBrush );

        TAknLayoutText textLayout;

        textLayout.LayoutText(Rect(), iParent.iTextFormat);

        TRgb color( KRgbBlack );  // sane default for nonskinned case

        if ( AknsUtils::AvkonSkinEnabled() )

            {

            AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),

                                   color, KAknsIIDQsnTextColors, iParent.iTextColorIndex );

            }

         textLayout.DrawText(gc, *(iParent.iText), ETrue, color);

        }    

    }

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

// Resize this control

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

//

void CPopupBubbleWnd::SizeChanged()

    {

    TRect rect = Rect();        

    iRect[EMiddleItem] = rect;    

    iRect[EMiddleItem].Shrink( KShrinkSize, 0 );

    // horizon

    if( rect.iTl.iY == iRect[EMiddleItem].iTl.iY && rect.iBr.iY == iRect[EMiddleItem].iBr.iY )

        {

        iRect[ELeftItem] = TRect( rect.iTl, TPoint( iRect[EMiddleItem].iTl.iX, iRect[EMiddleItem].iBr.iY ) );

        iRect[ERightItem] = TRect( TPoint( iRect[EMiddleItem].iBr.iX, iRect[EMiddleItem].iTl.iY), rect.iBr );    

        }

    else if( rect.iTl.iX == iRect[EMiddleItem].iTl.iX &&  rect.iBr.iX == iRect[EMiddleItem].iBr.iX )

        {

        iRect[ELeftItem] = TRect( rect.iTl, TPoint( iRect[EMiddleItem].iBr.iX, iRect[EMiddleItem].iTl.iY ) );

        iRect[ERightItem] = TRect( TPoint( iRect[EMiddleItem].iTl.iX, iRect[EMiddleItem].iBr.iY), rect.iBr );            

        }     

    SizeImage( iParent.iFirstBmpId, iRect[ELeftItem], iBitmap[ELeftItem], iDevice[ELeftItem], iBitGc[ELeftItem] );

    SizeImage( iParent.iMiddleBmpId, iRect[EMiddleItem], iBitmap[EMiddleItem], iDevice[EMiddleItem], iBitGc[EMiddleItem] );

    SizeImage( iParent.iLastBmpId, iRect[ERightItem], iBitmap[ERightItem], iDevice[ERightItem], iBitGc[ERightItem] );

    }

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

// Handle resource change

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

//

void CPopupBubbleWnd::HandleResourceChange( TInt aType )

    {

    if ( aType == KAknsMessageSkinChange )

        {

        // When skin changes, we need to update local bitmaps

        SizeChanged();

        }

    }

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

// Size images used for drawing

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

//

void CPopupBubbleWnd::SizeImage( TAknsItemID aId, TRect aRect, CFbsBitmap* aBitmap, CFbsBitmapDevice* aDevice, CFbsBitGc* aBitGc )

    {     

    MAknsSkinInstance* instance = AknsUtils::SkinInstance();

    TAknsItemType type = instance->GetCachedItemData( aId )->Type();

    if ( type == EAknsITMaskedBitmap )

        {

        CAknsMaskedBitmapItemData* itemData =

                static_cast<CAknsMaskedBitmapItemData*> ( instance->GetCachedItemData( aId ) );

        AknIconUtils::SetSize( itemData->Bitmap(), aRect.Size(), EAspectRatioNotPreserved );

        AknIconUtils::SetSize( itemData->Mask(), aRect.Size(), EAspectRatioNotPreserved );

        TDisplayMode bitmapmode = itemData->Bitmap()->DisplayMode();

        TDisplayMode maskmode = itemData->Mask()->DisplayMode();

        aBitmap->Resize( aRect.Size() );

        aDevice->Resize( aRect.Size() );

        aBitGc->Activate( aDevice );

        TRect entireImage( TPoint(0, 0), itemData->Bitmap()->SizeInPixels() );

        if (itemData->Mask())

            {

            aBitGc->BitBltMasked( TPoint(0, 0), itemData->Bitmap(), entireImage,

                    itemData->Mask(), ETrue );

            }

        else

            {

            aBitGc->BitBlt( TPoint(0, 0), itemData->Bitmap() );

            }

        TInt size = aBitmap->DataSize();

        TUint32* data = aBitmap->DataAddress();

        TDisplayMode mode = aBitmap->DisplayMode();

        iBitmap[ETempItem]->Resize( aRect.Size() );

        iDevice[ETempItem]->Resize( aRect.Size() );

        iBitGc[ETempItem]->Activate( iDevice[ETempItem] );

        iBitGc[ETempItem]->BitBlt( TPoint(0, 0), itemData->Mask() );

        TUint32* mask_data = iBitmap[ETempItem]->DataAddress(); 

         if (mode == EColor16MA)

             {

             for (TInt i = 0; i < size/sizeof( TUint32 ); i++)

                 {

                 TRgb colour;

                 colour.SetInternal( *(mask_data + i) );

                 if (colour != TRgb( 0x00, 0x00, 0x00, 0xFF ))

                     {

                     colour.SetInternal( *(data + i) );

                     colour.SetAlpha( KAlpha ); //semi transparent

                     *(data + i) = colour.Internal();

                     }

                 else

                     {

                     colour.SetInternal( *(data + i) );

                     colour.SetAlpha( 0x00 ); //fully transparent

                     *(data + i) = colour.Internal();                   

                     }

                 }           

             }

        }

    } 

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

// Draw transparent background

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

//

void CPopupBubbleWnd::DrawTransparentBackground( const TRect& aRect ) const

{

    CWindowGc& gc = SystemGc();

    for( TInt i=0; i<ELastItem; i++ )

        {

        if ( i == ETempItem )//skip temporary bitmap

            {

            continue;

            }

        if ( iBitmap[i] )//draw other bitmaps

            {

            gc.BitBlt( iRect[i].iTl, iBitmap[i] );

            }

        }

}

/*****************************************************************************/

// Implementation of Class CPopupBubbleCtrl

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

// CPopupBubbleCtrl::NewL

// Symbian constructor

// (other items were commented in a header).

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

//               

EXPORT_C CPopupBubbleCtrl* CPopupBubbleCtrl::NewL( const TRect& aRect,

                               CFepUiLayout* aUiLayout,

                               TInt aCtrlId )

    {

    CPopupBubbleCtrl* ctrl = new (ELeave)CPopupBubbleCtrl( aRect,aUiLayout,aCtrlId );

    CleanupStack::PushL( ctrl );

    ctrl->BaseConstructL();

    CleanupStack::Pop( ctrl );

    return ctrl;

    }

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

// CPopupBubbleCtrl::CPopupBubbleCtrl

// C++  constructor

// (other items were commented in a header).

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

//

EXPORT_C CPopupBubbleCtrl::CPopupBubbleCtrl( const TRect& aRect,

                         CFepUiLayout* aUiLayout,

                         TInt aCtrlId )

    :CFepUiBaseCtrl( aRect,aUiLayout,aCtrlId ),

     iTextColorIndex( KDefaultTextColorIndex )

    {

    SetControlType( ECtrlButton );

    SetHidenFlag( ETrue );

    }

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

// CPopupBubbleCtrl::CPopupBubbleCtrl

// C++  destructor

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

//

EXPORT_C CPopupBubbleCtrl::~CPopupBubbleCtrl()

    {

    if ( iText )

        {

        delete iText;

        iText = NULL;

        }      

    if( iForgroundBmp )

        {

        delete iForgroundBmp;

        iForgroundBmp = NULL;

        }

    if( iForgroundBmpMask )

        {

        delete iForgroundBmpMask;

        iForgroundBmpMask = NULL;

        }        

    }

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

// CPopupBubbleCtrl::SetBitmapParamL

// Set bitmap parameters used fot this bubble

// (other items were commented in a header).

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

//

EXPORT_C void CPopupBubbleCtrl::SetBitmapParamL(

                                    CFbsBitmap* aBmpId,

                                    CFbsBitmap* aMaskBmpId,     

                                 TAknsItemID aFirstBmpId,

                                 TAknsItemID aMiddleBmpId,

                                 TAknsItemID aLastBmpId)

    {

    if( iForgroundBmp )

        {

        delete iForgroundBmp;

        iForgroundBmp = NULL;

        }

    if( iForgroundBmpMask )

        {

        delete iForgroundBmpMask;

        iForgroundBmpMask = NULL;

        }    

    iForgroundBmp = aBmpId;

    iForgroundBmpMask = aMaskBmpId;

    iFirstBmpId = aFirstBmpId;

    iMiddleBmpId =  aMiddleBmpId;

    iLastBmpId = aLastBmpId;

    delete iWndControl;

    iWndControl = NULL;

    iWndControl = CPopupBubbleWnd::NewL( Rect(), *this );

    }

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

// CPopupBubbleCtrl::Hide

// Hide bubble control

// (other items were commented in a header).

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

//

EXPORT_C void CPopupBubbleCtrl::Hide( TBool aFlag )

    {

    if ( iWndControl )

        {

        iWndControl->MakeVisible( !aFlag );

        }

    CFepUiBaseCtrl::Hide( aFlag );    

    }

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

// CPopupBubbleCtrl::Draw

// Draw bubble control

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

//

EXPORT_C void CPopupBubbleCtrl::Draw()

    {

    if( !AbleToDraw() )

        {

        return;

        }    

    if( iWndControl )

        {

        iWndControl->DrawDeferred();

        }

    }

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

// CPopupBubbleCtrl::Move

// Move bubble control

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

//

EXPORT_C void CPopupBubbleCtrl::Move( const TPoint& aOffset )

    {

    //leave empty

    }

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

// CPopupBubbleCtrl::SetTextFormat

// Set text format used for text drawing

// (other items were commented in a header).

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

//

EXPORT_C void CPopupBubbleCtrl::SetTextFormat( TAknTextLineLayout aTextFormat )

    {

    iTextFormat = aTextFormat;                

    }

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

// CPopupBubbleCtrl::SetTextL

// Set bubble text

// (other items were commented in a header).

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

//

EXPORT_C void CPopupBubbleCtrl::SetTextL( const TDesC& aText )

    {

    delete iText;

    iText = NULL;

    iText = aText.AllocL();

    }