/*

* Copyright (c) 2006-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 of CHuiTextMesh. CHuiTextMesh stores a cached 

*                version of a text string.

*

*/

#include <AknUtils.h>

#include "alf/alfconstants.h"

#include "uiacceltk/HuiTextMesh.h"

#include "uiacceltk/HuiStatic.h"

#include "uiacceltk/HuiFont.h"

#include "uiacceltk/HuiTexture.h"

#include "uiacceltk/HuiGc.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/huitextstylemanager.h"

#include "uiacceltk/huitextstyle.h"

#include "uiacceltk/HuiDisplay.h"

#include "HuiRosterImpl.h"

CHuiTextMesh::CHuiTextMesh()

        : iTextStyleId(0),

          iLineSpacing(0),        

          iTextMeshScale(1.0),        

          iLineMode(ELineModeTruncate),

          iMaxLineWidth(KMaxTInt),

          iScaledMaxLineWidth(KMaxTInt),

          iMaxLineCount(KMaxTInt),          

          iRasterizedShadow(EFalse)

    {

    }

void CHuiTextMesh::ConstructL()

    {

    // Register as observer

    CHuiStatic::Env().iActionObservers.AppendL(*this);

    RPointerArray<CHuiDisplay> displays = CHuiStatic::Env().Displays();

    for(TInt i = 0; i<displays.Count(); i++)

        {

        displays[i]->iVisibleAreaObservers.AppendL(*this);

        if (displays[i]->IsDisplayTypeTvOut())

            {

            displays[i]->iDeletionObservers.AppendL(*this);

            }

        }

    ReleaseFont();

    CalculateTvOutScales();

    }

CHuiTextMesh::~CHuiTextMesh()

    {

    // Remove observers

    CHuiStatic::Env().iActionObservers.RemoveIfFound(*this);

    RPointerArray<CHuiDisplay> displays = CHuiStatic::Env().Displays();

    for(TInt i = 0; i<displays.Count(); i++)

        {

        displays[i]->iVisibleAreaObservers.RemoveIfFound(*this);

        if (displays[i]->IsDisplayTypeTvOut())

            {

            displays[i]->iDeletionObservers.RemoveIfFound(*this);

            }

        }

    delete iString;

    iPictographInterface = NULL;

    }

void CHuiTextMesh::Reset()

    {

    delete iString; 

    iString = 0;

    }

void CHuiTextMesh::SetLineMode(TLineMode aLineMode)

    {

    iLineMode = aLineMode;

    }

CHuiTextMesh::TLineMode CHuiTextMesh::LineMode() const

    {

    return iLineMode;

    }

TBool CHuiTextMesh::SetMaxLineWidth(TInt aMaxLineWidth)

    {

    // Note: this do not tell if only scaling has been changed.

    TBool isDifferent = (iMaxLineWidth != aMaxLineWidth);

    iMaxLineWidth = aMaxLineWidth;

    // Max line width has to be scaled to get proper line wrapping

    if(iTextMeshScale != 1 && aMaxLineWidth != KMaxTInt)

        {

        // Scale width with Y-scale to retain correct font proportions

        iScaledMaxLineWidth = HUI_ROUND_FLOAT_TO_INT( aMaxLineWidth * iTextMeshScale );

        } 

    return isDifferent;

    }

TInt CHuiTextMesh::MaxLineWidth() const

    {

    if(iTextMeshScale != 1)

        {

        return iScaledMaxLineWidth;

        } 

    return iMaxLineWidth;

    }

TBool CHuiTextMesh::SetMaxLineCount(TInt aMaxLineCount)

    {

    TBool isDifferent = (iMaxLineCount != aMaxLineCount);

    iMaxLineCount = aMaxLineCount;

    return isDifferent;

    }

TInt CHuiTextMesh::MaxLineCount() const

    {

    return iMaxLineCount;

    }

void CHuiTextMesh::SetFontL(const THuiFont& aFont, TBool aRefreshTextures)

    {

    THuiTextStyle* textStyle = CHuiStatic::Env().TextStyleManager().TextStyle(iTextStyleId);

    textStyle->SetFont(aFont);

    if(iString && aRefreshTextures)

        {

        BuildL(ETrue);

        }

    }

void CHuiTextMesh::SetTextL(const TDesC& aText, TBool aRasterize)

    {

    delete iString; iString = 0;

    iString = aText.AllocL();

    // Rasterize text into textures.

    BuildL(aRasterize);    

    }

const TDesC* CHuiTextMesh::Text() const

    {

    return iString;

    }

void CHuiTextMesh::EnableRasterizedShadow(const TBool aIsEnabled)

    {

    TBool isChanged = ETrue;

    if ( (iRasterizedShadow && aIsEnabled) || 

         ( !iRasterizedShadow && !aIsEnabled ) )

        {

        isChanged = EFalse;

        }

    iRasterizedShadow = aIsEnabled;

    if(isChanged && iString)

        {

        // Status of rasterized shadow has changed.

        // Assuming the sharp shadow is prerendered.

        TRAP_IGNORE(BuildL(ETrue))

        }

    }

TBool CHuiTextMesh::RasterizedShadow() const

    {

    if ( iVisual )

        {

        return TBool(iVisual->DropShadowHandler());

        }

    return iRasterizedShadow;

    }

TSize CHuiTextMesh::Extents() const

    {

    TSize extents = iExtents;

    if(iTextMeshScale != 1)

        {

        extents.iHeight = iScaledExtents.iHeight;

        extents.iWidth = iScaledExtents.iWidth;

        }

    return extents;

    }

void CHuiTextMesh::ExpandRectWithShadow(TRect& /*aRect*/) const

    {

    }

void CHuiTextMesh::SetExtents(const TSize& aExtents)

    {

    TBool isChanged = (iExtents != aExtents);

    iExtents = aExtents;

    if(iTextMeshScale != 1 && isChanged)

        {

        iScaledExtents.iHeight = HUI_ROUND_FLOAT_TO_INT( aExtents.iHeight/iTextMeshScale );

        iScaledExtents.iWidth = HUI_ROUND_FLOAT_TO_INT( aExtents.iWidth/iTextMeshScale );

        }

    }

void CHuiTextMesh::InitPictographsL(CAknPictographInterface* aInterface)

    {

    iPictographInterface = aInterface;    

    }

void CHuiTextMesh::SetTextStyle(TInt aTextStyleId)

    {

    iTextStyleId = aTextStyleId;

    ReleaseFont(); 

    }

TInt CHuiTextMesh::TextStyle() const

	{

	return iTextStyleId;

	}

void CHuiTextMesh::BuildPictographsL()

    {        

    }

void CHuiTextMesh::SetLineSpacing(TInt aLineSpacingInPixels)

    {

    iLineSpacing = aLineSpacingInPixels;

    }

void CHuiTextMesh::ReleaseFont()

    {

    THuiTextStyle* textStyle = CHuiStatic::Env().TextStyleManager().TextStyle(iTextStyleId);

    textStyle->Font().ReleaseFont();

    }

void CHuiTextMesh::CalculateTvOutScales()

    {

    // Calculate the TV Out scales

    RPointerArray<CHuiDisplay> displays = CHuiStatic::Env().Displays();

    for(TInt i = 0; i<CHuiStatic::Env().DisplayCount(); i++)

        {

        if (displays[i]->IsDisplayTypeTvOut())

            {

            // Scale with height to retain correct font proportions

            iTextMeshScale = (TReal32)displays[i]->Size().iHeight / (TReal32)displays[i]->RosterImpl().Rect().Height();

            }

        }

    }

void CHuiTextMesh::NotifyDisplayVisibleAreaChanged(CHuiDisplay& aDisplay)

    {

    if (aDisplay.IsDisplayTypeTvOut())

        {

        iTextMeshScale = (TReal32)aDisplay.Size().iHeight / (TReal32)aDisplay.RosterImpl().Rect().Height();

        }

    ReleaseFont();

    }

void CHuiTextMesh::NotifyDisplayDeletion(CHuiDisplay& aDisplay)

    {

    if (iString && aDisplay.IsDisplayTypeTvOut())

        {

        iTextMeshScale = 1.0;

        ReleaseFont();

        ResetLines();

        ResetPictographLines();

        // Updates the mesh and the extents

        TRAP_IGNORE(BuildL(ETrue));

        }

    }

void CHuiTextMesh::HandleActionL(const THuiActionCommand& aActionCommand)

    {

    if(aActionCommand.Id() == KHuiActionNewTVOutDisplayUid.iUid)

        {

        // find the TvOut display

        RPointerArray<CHuiDisplay> displays = CHuiStatic::Env().Displays();

        for(TInt i = 0; i<displays.Count(); i++)

            {

            if (displays[i]->IsDisplayTypeTvOut())

                {

                // Register as observer

                displays[i]->iVisibleAreaObservers.AppendIfNotFoundL(*this);

                displays[i]->iDeletionObservers.AppendIfNotFoundL(*this);

                // calculate new scale factors

                CalculateTvOutScales();

                }

            }

        ReleaseFont();

        ResetLines();

        ResetPictographLines();

        // Updates the mesh and the extents

        if(Text() != NULL)

            {

            BuildL(ETrue);

            }

        }

    else if ( aActionCommand.Id() == KAknsMessageSkinChange )

        {

        // When the resolution/skin changes and this text visual is not in 

        // the roster, the change notification is not received through the normal

        // route aka CHuiVisual::NotifySkinChangedL() 

        //

        // Setting the iMaxLineWidth into -1 is a hack. It would be better to

        // set the iMeshUpdated into EFalse in the CHuiTextVisual, but this class

        // has no pointer to the owning text visual. The text visual calls the 

        // SetMaxLineWidth function before it draws this mesh so the "changed" 

        // notification is informed through that function call.

        iMaxLineWidth = -1;

        }

    else

        {

        // For PC lint

        }

    }

void CHuiTextMesh::SetRelatedVisual(CHuiVisual* aVisual)

    {

    iVisual = aVisual;

    }

void CHuiTextMesh::UpdateMeshL(const TDesC8& /*aBuffer*/)

    {

    }