/*

* Copyright (c) 2009 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:  Discreet popup drawer

*

*/

#include <AknBidiTextUtils.h>

#include "akndiscreetpopupcontrol.h"

#include <AknIconUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <gulicon.h>

#include "akndiscreetpopupdrawer.h"

const TInt KTextBufSize( 255 );

const TInt KMaxNumOfLines( 2 );

// Help structure for layout data

class TPopupLayoutData

    {

public:

    TUint16 iWindowVariety;

    TUint16 iIconVariety;

    TUint16 i1stRowVariety;

    TUint16 i2ndRowVariety;

    };

// Layout data indexes in layout data array

const TInt KLayoutUnresolved( -1 );

const TInt KLayout2RowsIcon( 0 );

const TInt KLayout2Rows( 1 );

const TInt KLayout1RowIcon( 2 );

const TInt KLayout1Row( 3 );

const TInt KLayout2RowsWrappedIcon( 4 );

const TInt KLayout2RowsWrapped( 5 );

// Layout data array

static const TPopupLayoutData KPopupLayoutData[] =

    {

    { 0, 0, 0, 0 },

    { 0, 0, 1, 1 },

    { 0, 1, 2, 0 },

    { 0, 1, 3, 0 },

    { 0, 4, 4, 4 },

    { 0, 0, 5, 5 }

    };

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

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

// CAknDiscreetPopupDrawer::NewL

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

//

CAknDiscreetPopupDrawer* CAknDiscreetPopupDrawer::NewL( 

    CAknDiscreetPopupControl* aControl,

    const TDesC& aTitleText, 

    const TDesC& aBodyText, 

    CGulIcon* aIcon,

    const TAknsItemID& aSkinId,

    const TDesC& aBitmapFile,

    const TInt& aBitmapId,

    const TInt& aMaskId,

    const TBool& aAction )

    {

    CAknDiscreetPopupDrawer* self = 

        CAknDiscreetPopupDrawer::NewLC( aControl, 

                                        aTitleText, 

                                        aBodyText, 

                                        aIcon, 

                                        aSkinId, 

                                        aBitmapFile, 

                                        aBitmapId,

                                        aMaskId,

                                        aAction );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknDiscreetPopupDrawer::NewLC

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

//

CAknDiscreetPopupDrawer* CAknDiscreetPopupDrawer::NewLC(

    CAknDiscreetPopupControl* aControl,

    const TDesC& aTitleText, 

    const TDesC& aBodyText, 

    CGulIcon* aIcon,

    const TAknsItemID& aSkinId,

    const TDesC& aBitmapFile,

    const TInt& aBitmapId,

    const TInt& aMaskId,

    const TBool& aAction )

    {

    CAknDiscreetPopupDrawer* self 

        = new ( ELeave ) CAknDiscreetPopupDrawer( aControl, aIcon, aAction );

    CleanupStack::PushL( self );

    self->ConstructL( aTitleText, 

                      aBodyText, 

                      aSkinId, 

                      aBitmapFile, 

                      aBitmapId,

                      aMaskId );

    return self;

    }

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

// CAknDiscreetPopupDrawer::~CAknDiscreetPopupDrawer

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

//

CAknDiscreetPopupDrawer::~CAknDiscreetPopupDrawer()

    {

    delete iIcon;

    delete iBodyText;

    delete iTitleText;

    }

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

// CAknDiscreetPopupDrawer::LayoutPopup

// Sets popup and its components size and position.

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

//

TRect CAknDiscreetPopupDrawer::LayoutPopup()

    {

    ResolvePopupLayout();

    TPopupLayoutData data( KPopupLayoutData[ iPopupLayoutType ] );

    TRect popupRect;

    TRect popupBitmapRect;

    GetPopupRect( data.iWindowVariety, popupRect );

    // Calculate sub rects according to popup bitmap rect

    popupBitmapRect = TRect( 0, 0, popupRect.Width(), popupRect.Height() );

    // Possible icon rect

    if ( iPopupLayoutType == KLayout2RowsIcon 

        || iPopupLayoutType == KLayout1RowIcon

        || iPopupLayoutType == KLayout2RowsWrappedIcon )

        {

        iIconRect = RectFromLayout( popupBitmapRect, 

            AknLayoutScalable_Avkon::popup_discreet_window_g1( 

            data.iIconVariety ) );

        if( iIcon && iIcon->Bitmap() )

            {

            AknIconUtils::SetSize( iIcon->Bitmap(), iIconRect.Size() );

            }

        if( iIcon && iIcon->Mask() )

            {

            AknIconUtils::SetSize( iIcon->Mask(), iIconRect.Size() );

            }

        }

    // Title text font

    TextDataFromLayout(

            iTitleTextData,

            popupBitmapRect,

            AknLayoutScalable_Avkon::popup_discreet_window_t1(

                    data.i1stRowVariety ) );

    // Two rows - no wrapping

    if ( iPopupLayoutType == KLayout2RowsIcon 

        || iPopupLayoutType == KLayout2Rows )

        {

        // Body text font

        TextDataFromLayout(

                iBodyTextData,

                popupBitmapRect,

                AknLayoutScalable_Avkon::popup_discreet_window_t2(

                        data.i2ndRowVariety ) );

        }

    // Two wrapped rows

    else if ( iPopupLayoutType == KLayout2RowsWrappedIcon

            || iPopupLayoutType == KLayout2RowsWrapped )

        {

        // Body text

        TextDataFromLayout(

                iBodyTextData,

                popupBitmapRect,

                AknLayoutScalable_Avkon::popup_discreet_window_t3(

                        data.i2ndRowVariety ) );

        // Text should be wrapped if in two-row layout and no bodytext

        if ( iBodyText->Des() == KNullDesC )

            {

            TRAP_IGNORE( WrapTitleTextL() );

            }

        }

    return popupRect;

    }

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

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

//

    {

        {

        }

        {

        }

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

// CAknDiscreetPopupDrawer::CAknDiscreetPopupDrawer

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

//

CAknDiscreetPopupDrawer::CAknDiscreetPopupDrawer( 

    CAknDiscreetPopupControl* aControl, 

    CGulIcon* aIcon, 

    const TBool& aAction )

    :

    iControl( aControl ),

    iTitleText( NULL ),

    iBodyText( NULL ),

    iIcon( aIcon ),

    iPopupLayoutType( KLayoutUnresolved ),

    iAction( aAction )

    {

    }

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

// CAknDiscreetPopupDrawer::ConstructL

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

//

void CAknDiscreetPopupDrawer::ConstructL( const TDesC& aTitleText, 

                                          const TDesC& aBodyText,

                                          const TAknsItemID& aSkinId,

                                          const TDesC& aBitmapFile,

                                          const TInt& aBitmapId,

                                          const TInt& aMaskId )

    {

    // Body text to title text if title text is empty

    if ( aTitleText == KNullDesC && aBodyText != KNullDesC )

        {

        iTitleText = aBodyText.AllocL();

        }

    else

        {

        iTitleText = aTitleText.AllocL();

        iBodyText = aBodyText.AllocL();

        }

    if ( !iIcon )

        {

        iIcon = CreatePopupIconL( aSkinId, 

                                  aBitmapFile, 

                                  aBitmapId, 

                                  aMaskId );

        }

    }

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

// CAknDiscreetPopupDrawer::DrawTexts

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

//

    {

    aGc->SetBrushStyle( CGraphicsContext::ENullBrush );

    DrawBidiEnabledText( aGc, iTitleTextData, *iTitleText );

    if ( iBodyTextData.iTextRect != TRect() )

        {

        DrawBidiEnabledText( aGc, iBodyTextData, *iBodyText );

        }

    }

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

// CAknDiscreetPopupDrawer::ResolvePopupLayout

// Resolves popup layout type.

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

//

void CAknDiscreetPopupDrawer::ResolvePopupLayout()

    {

    // Layout already resolved, do nothing

    if ( iPopupLayoutType != KLayoutUnresolved )

        {

        return;

        }

    TBool withIcon( iIcon && iIcon->Bitmap() );

    TBool twoRowsText( 

        iTitleText->Des() != KNullDesC 

        && iBodyText->Des() != KNullDesC );

    // Two rows of text

    if ( twoRowsText )

        {

        if ( withIcon )

            {

            iPopupLayoutType = KLayout2RowsIcon;

            }

        else

            {

            iPopupLayoutType = KLayout2Rows;

            }

        }

    // One row of text

    else

        {

        if ( withIcon )

            {

            iPopupLayoutType = KLayout1RowIcon;

            }

        else

            {

            iPopupLayoutType = KLayout1Row;

            }

        // Check if text should be wrapped to two lines

        if ( TitleTextNeedsWrapping( iPopupLayoutType ) )

            {

            if ( withIcon )

                {

                iPopupLayoutType = KLayout2RowsWrappedIcon;

                }

            else

                {

                iPopupLayoutType = KLayout2RowsWrapped;

                }

            }

        }

    }

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

// CAknDiscreetPopupDrawer::EikonEnv

// Provides control eikon env.

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

//

    {

    if ( iControl )

        {

        return static_cast<CEikonEnv*>( iControl->ControlEnv() );

        }

    return NULL;

    }

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

// CAknDiscreetPopupDrawer::TitleTextNeedsWrapping

// Returns ETrue if title text needs wrapping.

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

//

TBool CAknDiscreetPopupDrawer::TitleTextNeedsWrapping( 

        const TInt& aLayoutType )

    {

    const CFont* textFont( NULL );

    TRect textRect;

    TRect popupRect;

    TPopupLayoutData data( KPopupLayoutData[ aLayoutType ] );

    GetPopupRect( data.iWindowVariety, popupRect );

    popupRect.Move( 0, 0 );

    textFont = FontFromLayout( 

        popupRect, 

        AknLayoutScalable_Avkon::popup_discreet_window_t1( 

        data.i1stRowVariety ), textRect );

    if ( textFont->TextCount( *iTitleText, textRect.Width() ) 

            < iTitleText->Length() )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CAknDiscreetPopupDrawer::WrapTitleTextL

// Wraps long text to two lines.

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

//

void CAknDiscreetPopupDrawer::WrapTitleTextL()

    {

    CArrayFixFlat<TInt>* lineWidths