diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/coretoolkit/src/HuiTextMesh.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/coretoolkit/src/HuiTextMesh.cpp	Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,373 @@
+/*
+* 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*/)
+    {
+    }