/*

* 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:  Meeting Request viewer response field implementation

*

*/

#include "cesmrresponseitem.h"

#include "nmrlayoutmanager.h"

#include "nmrbitmapmanager.h"

#include "nmrcolormanager.h"

#include "cmrimage.h"

#include "cmrlabel.h"

#include <esmrgui.rsg>

// DEBUG

#include "emailtrace.h"

namespace // codescanner::namespace

    {

    const TInt KMaxLinesInResponseTopicItem( 1 );

    const TInt KEdge(8);

    } // unnamed namespace

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

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

// CESMRResponseItem::NewL

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

//

CESMRResponseItem* CESMRResponseItem::NewL( TESMRCommand aCmd,

                                            const TDesC& aItemText,

                                            TBool aHasIcon )

    {

    FUNC_LOG;

    CESMRResponseItem* self = CESMRResponseItem::NewLC( aCmd,

                                                        aItemText,

                                                        aHasIcon );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRResponseItem::NewL

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

//

CESMRResponseItem* CESMRResponseItem::NewLC( TESMRCommand aCmd,

                                             const TDesC& aItemText,

                                             TBool aHasIcon )

    {

    FUNC_LOG;

    CESMRResponseItem* self = new (ELeave) CESMRResponseItem( aCmd );

    CleanupStack::PushL( self );

    self->ConstructL( aItemText, aHasIcon );

    return self;

    }

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

// CESMRResponseItem::~CESMRResponseItem

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

//

CESMRResponseItem::~CESMRResponseItem()

    {

    FUNC_LOG;

    delete iSelectionLabel;

    delete iIcon;

    delete iItemText;

    }

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

// CESMRResponseItem::CESMRResponseItem

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

//

CESMRResponseItem::CESMRResponseItem(TESMRCommand aCmd)

: iCmd (aCmd)

    {

    FUNC_LOG;

    //do nothing

    }

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

// CESMRResponseItem::ConstructL

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

//

void CESMRResponseItem::ConstructL( const TDesC& aItemText, TBool aHasIcon )

    {

    FUNC_LOG;

    iSelectionLabel = CMRLabel::NewL( this );

    iSelectionLabel->SetTextL( aItemText );

    // Response item might not have icon. e.g. topic line

    iHasIcon = aHasIcon;

    if( aHasIcon )

        {

        iIcon = IconL( EFalse );

        }

    }

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

// CESMRResponseItem::Draw

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

//

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

    {

    FUNC_LOG;

    NMRColorManager::SetColor( *iSelectionLabel, 

                               NMRColorManager::EMRMainAreaTextColor );

    if( iHighlighted )

        {

        CWindowGc& gc = SystemGc();

        TRect rect = aRect;

        TBool enableEdges(ETrue);

        CFbsBitmap* selector = NULL;

        CFbsBitmap* selectorMask = NULL;

        TSize corner(KEdge, KEdge);

        NMRBitmapManager::GetSkinBasedBitmap( 

                NMRBitmapManager::EMRBitmapListTopLeft, 

                selector, selectorMask, corner );

        if( selector && selectorMask && enableEdges)

            {

            //corner TL

            gc.BitBltMasked( rect.iTl, selector, corner, selectorMask, EFalse );

            //side L

            TSize side(KEdge, (rect.Height() - 2 * KEdge) );

            NMRBitmapManager::GetSkinBasedBitmap( 

                    NMRBitmapManager::EMRBitmapListLeft, 

                    selector, selectorMask, side );

            gc.BitBltMasked( TPoint(rect.iTl.iX, rect.iTl.iY + KEdge),

                             selector, side, selectorMask, EFalse );

            //corner BL

            NMRBitmapManager::GetSkinBasedBitmap( 

                    NMRBitmapManager::EMRBitmapListBottomLeft, 

                    selector, selectorMask, corner );

            gc.BitBltMasked( TPoint(rect.iTl.iX, 

                            rect.iTl.iY + KEdge + side.iHeight),

                            selector, corner, selectorMask, EFalse );

            //top

            TSize top( (rect.Width() - 2 * KEdge) , KEdge);

            NMRBitmapManager::GetSkinBasedBitmap( 

                    NMRBitmapManager::EMRBitmapListTop, 

                    selector, selectorMask, top );

            gc.BitBltMasked( TPoint(rect.iTl.iX + KEdge, rect.iTl.iY),

                             selector, top, selectorMask, EFalse );

            //center

            TSize center( top.iWidth, side.iHeight);

            NMRBitmapManager::GetSkinBasedBitmap( 

                    NMRBitmapManager::EMRBitmapListCenter, 

                    selector, selectorMask, center );

            gc.BitBltMasked( TPoint(rect.iTl.iX + KEdge, rect.iTl.iY + KEdge),

                             selector, center, selectorMask, EFalse );

            //bottom

            NMRBitmapManager::GetSkinBasedBitmap( 

                    NMRBitmapManager::EMRBitmapListBottom, 

                    selector, selectorMask, top );

            gc.BitBltMasked( TPoint(rect.iTl.iX + KEdge, 

                            rect.iTl.iY + side.iHeight + KEdge),

                            selector, top, selectorMask, EFalse );

            //corner TR

            NMRBitmapManager::GetSkinBasedBitmap( 

                    NMRBitmapManager::EMRBitmapListTopRight, 

                    selector, selectorMask, corner );

            gc.BitBltMasked( TPoint(rect.iTl.iX + KEdge + top.iWidth, 

                            rect.iTl.iY),

                            selector, corner, selectorMask, EFalse );

            //side R

            NMRBitmapManager::GetSkinBasedBitmap( 

                    NMRBitmapManager::EMRBitmapListRight, 

                    selector, selectorMask, side );

            gc.BitBltMasked( TPoint(rect.iTl.iX + KEdge + top.iWidth, 

                            rect.iTl.iY + KEdge),

                            selector, side, selectorMask, EFalse );

            //corner Br

            NMRBitmapManager::GetSkinBasedBitmap( 

                    NMRBitmapManager::EMRBitmapListBottomRight, 

                    selector, selectorMask, corner );

            gc.BitBltMasked( TPoint(rect.iTl.iX + KEdge + top.iWidth, 

                            rect.iTl.iY + KEdge + side.iHeight),

                            selector, corner, selectorMask, EFalse );

            }

        else if(!enableEdges)

            {

            //center

            TSize center( rect.Width(), rect.Height() );

            NMRBitmapManager::GetSkinBasedBitmap( 

                    NMRBitmapManager::EMRBitmapListCenter, 

                    selector, selectorMask, center );

            gc.BitBltMasked( TPoint(rect.iTl.iX, rect.iTl.iY), 

                    selector, center, selectorMask, EFalse );

            }

        else // This should NOT be called ever.

            {

            gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

            gc.SetPenStyle( CGraphicsContext::ENullPen );

            gc.SetBrushColor( KRgbGreen );

            rect.SetSize( TSize(rect.Size().iWidth - 1,

                                rect.Size().iHeight ) );

            gc.DrawRect( rect );

            }

        delete selector;

        delete selectorMask;

        }

    }

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

// CESMRResponseItem::CountComponentControls

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

//

TInt CESMRResponseItem::CountComponentControls() const

    {

    FUNC_LOG;

    TInt itemCount = 0;

    if( iSelectionLabel )

        {

        itemCount++;

        }

    if( iIcon )

        {

        itemCount++;

        }

    return itemCount;

    }

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

// CESMRResponseItem::ComponentControl

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

//

CCoeControl* CESMRResponseItem::ComponentControl( TInt aInd ) const

    {

    FUNC_LOG;

    CCoeControl* control = NULL;

    if ( aInd == 0 )

        {

        control = iSelectionLabel;

        }

    if ( aInd == 1 )

        {

        control = iIcon;

        }

    return control;

    }

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

// CESMRResponseItem::SizeChanged

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

//

void CESMRResponseItem::SizeChanged()

    {

    FUNC_LOG;

    TRect rect( this->Rect() );

    // Icon exists, this is answer item ( accept / tentative / decline )

    if( iIcon )

        {

        // Icon

        TAknWindowComponentLayout iconLayout = 

            NMRLayoutManager::GetWindowComponentLayout( 

                    NMRLayoutManager::EMRLayoutCheckboxIcon );

        AknLayoutUtils::LayoutImage( iIcon, rect, iconLayout );

        // Label 

        TAknTextComponentLayout labelLayout =

            NMRLayoutManager::GetTextComponentLayout( 

                    NMRLayoutManager::EMRTextLayoutCheckboxEditor );

        AknLayoutUtils::LayoutLabel( iSelectionLabel, rect, labelLayout );

        }

    else // There is no icon (this is the topic item)

        {

        TAknTextComponentLayout labelLayout =

            NMRLayoutManager::GetTextComponentLayout( 

                    NMRLayoutManager::EMRTextLayoutText );

        AknLayoutUtils::LayoutLabel( iSelectionLabel, rect, labelLayout );

        // SizeChange() is called when rect for ResponseItem is ready to be used.

        // If setting text to response topic label fails, no need to catch it.

        TRAP_IGNORE(SetTextToLabelL());

        }

    }

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

// CESMRResponseItem::SetContainerWindowL

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

//

void CESMRResponseItem::SetContainerWindowL( const CCoeControl& aContainer )

    {

    FUNC_LOG;

    CCoeControl::SetContainerWindowL( aContainer );

    TInt count( CountComponentControls() );

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

        {

        ComponentControl( i )->SetContainerWindowL( *this );

        }

    }

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

// CESMRResponseItem::IconL

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

//

CMRImage* CESMRResponseItem::IconL( TBool aChecked )

    {

    FUNC_LOG;

    NMRBitmapManager::TMRBitmapId iconID( 

            NMRBitmapManager::EMRBitmapCheckBoxOff );

    if( aChecked )

        {

        iconID = NMRBitmapManager::EMRBitmapCheckBoxOn;

        }

    CMRImage* icon = CMRImage::NewL( iconID, this );

    return icon;

    }

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

// CESMRResponseItem::SetHighlight

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

//

void CESMRResponseItem::SetHighlight()

    {

    FUNC_LOG;

    iHighlighted = ETrue;

    }

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

// CESMRResponseItem::RemoveHighlight

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

//

void CESMRResponseItem::RemoveHighlight()

    {

    FUNC_LOG;

    iHighlighted = EFalse;

    }

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

// CESMRResponseItem::ChangeIconL

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

//

void CESMRResponseItem::ChangeIconL( TBool aChecked )

    {

    FUNC_LOG;

    delete iIcon;

    iIcon = NULL;

    iIcon = IconL( aChecked );

    SizeChanged();

    }

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

// CESMRResponseItem::SetFont

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

//

void CESMRResponseItem::SetFont( const CFont* aFont )

    {

    FUNC_LOG;

    iSelectionLabel->SetFont( aFont );

    NMRColorManager::SetColor( *iSelectionLabel, 

                               NMRColorManager::EMRMainAreaTextColor );

    }

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

// CESMRResponseItem::SetTextL

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

//

void CESMRResponseItem::SetTextL( const TDesC& aItemText )

    {

    FUNC_LOG;

    // When this method is called for the first time(with valid text)

    // text is stored to member variable. This is done because

    // text needs to be wrapped again (orientation might have

    // changed) when SizeChanged() gets called.

    if( !iItemText &&  aItemText.Length() > 0 )

        {

        iOriginalTextLength = aItemText.Length();

        iItemText = HBufC::NewL( aItemText.Length() );

        *iItemText = aItemText;

        }

    else if( !iItemText &&  aItemText.Length() <= 0 )

        {

        // if there is no new text yet, there is nothing to do here.

        return;

        }

    SetTextToLabelL();

    }

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

// CESMRResponseItem::SetTextToLabelL

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

//

void CESMRResponseItem::SetTextToLabelL()

	{

	if( iItemText )

		{

		TInt lineCount = 1; // Default line count.

		// If this item has no icon, it may use two lines for the text

		if( !iIcon )

			{

			lineCount = KMaxLinesInResponseTopicItem;

			}

		// Text wrapping

		CArrayFixFlat<TInt>* widthArray =

							new (ELeave) CArrayFixFlat<TInt>( lineCount );

		CleanupStack::PushL( widthArray );

		for ( TInt i(0); i < lineCount; i++ )

			{

			// If this item has no icon, all the space is for text

			if( !iIcon )

				{

				TAknLayoutText layout = NMRLayoutManager::GetLayoutText( 

						Rect(), NMRLayoutManager::EMRTextLayoutText );            

				widthArray->AppendL( layout.TextRect().Width() );

				}

			else

				{

				// This layout leaves space for the icon to the left side

				TAknLayoutText layout = NMRLayoutManager::GetLayoutText( 

						Rect(), NMRLayoutManager::EMRTextLayoutTextEditor ); 	

				widthArray->AppendL( layout.TextRect().Width() );

				}

			}

		HBufC* wrappedText;

		// Set the font for the text

		const CFont* font = iSelectionLabel->Font();

		RBuf buffer; // codescanner::resourcenotoncleanupstack

		buffer.CreateL( iOriginalTextLength + widthArray->Count() );

		buffer.CleanupClosePushL();

		// Wrap the text

		AknTextUtils::WrapToStringAndClipL( *iItemText, *widthArray, *font, buffer );

		wrappedText = buffer.AllocLC();

		// Set the text to label

		iSelectionLabel->SetTextL( *wrappedText );

		CleanupStack::PopAndDestroy(3); // widthArray, wrappedText, buffer		

		}

	}

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

// CESMRResponseItem::ItemTextLineCount

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

//

TInt CESMRResponseItem::ItemTextLineCount()

    {

    FUNC_LOG;

    TInt retValue( KErrNotFound );

    if( iSelectionLabel )

        {

        retValue = iSelectionLabel->NumberOfLines();

        }

    return retValue;

    }

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

// CESMRResponseItem::CommandId

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

//

TESMRCommand CESMRResponseItem::CommandId() const

    {

    FUNC_LOG;

    return iCmd;

    }

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

// CESMRResponseItem::SetUnderlineL

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

//

void CESMRResponseItem::SetUnderlineL( TBool aUndreline )

    {

    iSelectionLabel->SetUnderlining( aUndreline );

    }