/*

* Copyright (c) 2005-2006 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 wrapper for a label

*

*/

#include <e32base.h>

#include <coecntrl.h>

#include <barsread.h>

#include <gulcolor.h>

#include <utf.h>

#include <AknsUtils.h>

#include <AknPictographInterface.h> // for japanese variants.

#include <AknBidiTextUtils.h>

#include <AknUtils.h>

#include <AknLayoutFont.h>

#include "xnnodepluginif.h"

#include "xndompropertyvalue.h"

#include "xndomproperty.h"

#include "xndomlist.h"

#include "xnproperty.h"

#include "xncomponent.h"

#include "xnuienginepluginif.h"

#include "xncomponent.h"

#include "xncontroladapter.h"

#include "c_xnutils.h"

#include "xntype.h"

#include "xntextadapter.h"

#include "xncomponentnodeimpl.h"

#include "xnviewnodeimpl.h"

#include "xneditmode.h"

namespace XnText

    {

    const TUint8 KClip = 0x01;   

    const TUint8 KEllipse = 0x02; 

    const TUint8 KWrap = 0x04;    

    const TUint8 KOverflowVisible = 0x08; 

    const TUint8 KLtr = 0x10;     

    const TUint8 KConstructText = 0x20;

    _LIT8( tooltip, "tooltip" );

    _LIT8( clock, "clock" );

    }

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

// IsBitSet

// Test whether bit is set in a flag

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

static TBool IsBitSet(TUint8 aBit,TUint8 aFlag)

    {

    return ( aFlag & aBit );    

    }

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

// SetLabelTextL

// Prepares text to label, wraps or clips if needed

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

static void SetLabelTextL( CEikLabel& aLabel, const TDesC& aSource, TInt aMaxLineWidth, 

                           TInt aMaxLines, TUint8 aFlags, TBool aMeasureOnly = EFalse )    

    {   

    // By default, let the label do the logical to visual conversion                

    TBool conversion( ETrue );

    if( IsBitSet( XnText::KOverflowVisible, aFlags ) || aSource == KNullDesC )

        {        

        // no clipping or wrapping needed if,

        // overflow is visible

        // no text or no space,

        // or text fits to given space

        aLabel.SetTextL( aSource );                        

        }

    else

        {

        AknBidiTextUtils::TParagraphDirectionality dir( AknBidiTextUtils::EImplicit );

        const CFont* font( aLabel.Font() );

        HBufC* buffer( NULL );

        if( IsBitSet( XnText::KEllipse, aFlags ) )

    	    {	    

            buffer = aSource.AllocLC();

    	    TPtr ptr( buffer->Des() );

            AknBidiTextUtils::ConvertToVisualAndClipL(

    	                ptr, *font, aMaxLineWidth, aMaxLineWidth, dir );

            // The text is already in visual form, no need for conversion

            conversion = EFalse;            

            aLabel.SetTextL( *buffer );            

            CleanupStack::PopAndDestroy( buffer );	        	                                    

    	    }

    	else if( IsBitSet( XnText::KWrap, aFlags ) )

    	    {        	    

    	    if( aMaxLines > 0 )

    	        {

        	    CArrayFixFlat< TInt >* array = new ( ELeave ) CArrayFixFlat< TInt >( 8 );

        	    CleanupStack::PushL( array );

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

        	        {

        	        array->AppendL( aMaxLineWidth );

        	        }

                buffer = HBufC::NewLC( aSource.Length() + aMaxLines * 

                                        ( KAknBidiExtraSpacePerLine + 1 ) );

                TPtr ptr( buffer->Des() );

        	    AknBidiTextUtils::ConvertToVisualAndWrapToStringL(

        	                aSource, *array, *font, ptr, ETrue, dir );    	        

    	        }

            else

                {

        	    CArrayFixFlat< TPtrC >* array = new ( ELeave ) CArrayFixFlat< TPtrC >( 8 );

        	    CleanupStack::PushL( array );

                HBufC* temp = AknBidiTextUtils::ConvertToVisualAndWrapToArrayL(

                            aSource, aMaxLineWidth, *font, *array, dir );

                CleanupStack::PushL( temp );

                TInt lineCount( array->Count() );

                TInt bufLen = temp->Length() + ( lineCount - 1 );

                if ( bufLen > 0 )

                    {

                    buffer = HBufC::NewLC( bufLen );

                    TPtr ptr( buffer->Des() );

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

                        {

                        TPtrC line( array->At( i ) );

                        ptr.Append( line );

                        if( i + 1 < lineCount )

                            {

                            ptr.Append( '\n' );

                            }                    

                        }

                    CleanupStack::Pop();

                    CleanupStack::PopAndDestroy( temp );

                    CleanupStack::PushL( buffer );

                    }

                else

                    {

                    CleanupStack::PopAndDestroy( temp );

                    }

                }    	        

            // The text is already in visual form, no need for conversion

            conversion = EFalse;

            if ( buffer )

                {

                aLabel.SetTextL( *buffer );

                CleanupStack::PopAndDestroy( buffer );

                }

            CleanupStack::PopAndDestroy(); // array                                       

    	    }

        else

            {

            aLabel.SetTextL( aSource );            

            }    	                   

        } 

    if( !aMeasureOnly )

        {     

        // Text is truly set, set conversion and defer draw

        aLabel.UseLogicalToVisualConversion( conversion );                    

        }

    }

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

// CopyBitmapData

// Copies a data from source bitmap to target bitmap.

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

//

static TInt CopyBitmapData(

    CFbsBitmap& aTarget,

    const CFbsBitmap& aSource,

    TPoint aSourcePoint)

	{

    TSize targetSize(aTarget.SizeInPixels());

    TSize sourceSize(aSource.SizeInPixels());

    TInt lineLength(targetSize.iWidth);

    TInt maxSourceLineLength(sourceSize.iWidth - aSourcePoint.iX);

    if(lineLength > maxSourceLineLength)

        {

        lineLength = maxSourceLineLength;

        }

    TInt rowCount(targetSize.iHeight);

    TInt maxSourceRowCount(sourceSize.iHeight - aSourcePoint.iY);

    if(rowCount > maxSourceRowCount)

        {

        rowCount = maxSourceRowCount;

        }

    // Get bitmap display mode

	TDisplayMode displayMode(aSource.DisplayMode());

    // Create buffer for a scan line

	HBufC8* scanLine = HBufC8::New(

        aSource.ScanLineLength(lineLength, displayMode));

    if(!scanLine)

    	{

    	return KErrNoMemory;

    	}

	TPtr8 scanPtr(scanLine->Des());

    // Copy all rows to destination bitmap

	for(TInt row(0); row < rowCount; row++)

		{

		aSource.GetScanLine(scanPtr,

            TPoint(aSourcePoint.iX, aSourcePoint.iY + row),

            lineLength, displayMode);

		aTarget.SetScanLine(scanPtr, row);

		}

    delete scanLine;

	return KErrNone;

	}        

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

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

// CXnTextAdapter::NewL

// Symbian static 1st phase constructor

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

//

CXnTextAdapter* CXnTextAdapter::NewL(CXnControlAdapter* aParent, CXnNodePluginIf& aNode)

    {

	CXnTextAdapter* self = new( ELeave ) CXnTextAdapter( aParent, aNode );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;	

    }

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

// CXnTextAdapter::CXnTextAdapter

// C++ default constructor

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

//

CXnTextAdapter::CXnTextAdapter(CXnControlAdapter* aParent, CXnNodePluginIf& aNode)

    : iParent( aParent ), iNode( aNode )

    {

    }

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

// CXnTextAdapter::~CXnTextAdapter

// C++ destructor

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

//

CXnTextAdapter::~CXnTextAdapter()

    {    

    delete iLabel;

    delete iText;

    if( iFont && iReleaseFont )

        {

        CWsScreenDevice* dev = iCoeEnv->ScreenDevice();

        dev->ReleaseFont( iFont ); 

        }

    if( iPictographInterface )

    	{

    	delete iPictographInterface;

    	}

    delete iBackgroundBitmap;

    }

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

// CXnTextAdapter::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXnTextAdapter::ConstructL()

    {

    iGc = &SystemGc();

    iLabel = new ( ELeave ) CEikLabel;

    iLabel->SetContainerWindowL( *iParent );

    iLabel->SetTextL( KNullDesC );

    CXnControlAdapter::ConstructL( iNode );

    iPictographInterface = CAknPictographInterface::NewL( *iLabel, *this );

    iLabel->EnablePictographsL( *iPictographInterface );

    SetTextPropertiesL( iNode );

    UpdateTextL( iNode.GetPCData() );    

	}

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

// CXnTextAdapter::ConstructTextL

// Construct the text component according to properties.

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

//    

void CXnTextAdapter::ConstructTextL()

    {   

    if( !iText )        

        {

        // CEikLabel will panic in ::Draw if text is not set

        SetLabelTextL( *iLabel, KNullDesC, 0, 0, 0 );

        return;

        }

    if( !( iFlags & XnText::KConstructText ) )

        {

        return;

        }

    TRect rect( iNode.Rect() );

	SetLineSpacingL( rect.Height() );

	TInt flags( iFlags );

    // Now we must restrict side into parent        

    flags = RestrictSizeL();

    SetLabelTextL( *iLabel, *iText, iLabel->Rect().Width(), iMaxLines, flags );                       

    }

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

// CXnTextAdapter::SetTextPropertiesL

// Sets text properties, such as color, font, etc.

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

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

//

TBool CXnTextAdapter::SetTextPropertiesL( CXnNodePluginIf& aNode )

    {

    // Store current state

    const CFont* font( iFont );

    TInt flags( iFlags );

    TInt maxLines( iMaxLines );

    if( iFont && iReleaseFont )

        {

        CWsScreenDevice* dev = iCoeEnv->ScreenDevice();

        dev->ReleaseFont( iFont ); 

        iFont = NULL;

        }

    // Find out the font and set it

    CXnUtils::CreateFontL( aNode, iFont, iReleaseFont );

    iLabel->SetFont( iFont );

    // Turn off all graphic context effects

    iLabel->SetUnderlining( EFalse );

    iLabel->SetStrikethrough( EFalse );

    //following data types are used due to we are handling text via CEikLabel instead of direct

    //font color and effects manipulation via graphics context.

    //We manipulate pen and brush colors indirectly via

    //Label's OverrideColorL method applying EColorControlBackground and EColorLabelText parameters

    //with corresponding RGB value.

    TRgb textColor;

    TRgb effectsColor;

    TBool textColorSet( EFalse );

    TBool effectsColorSet( EFalse );

    TBool effectsDevColorSet( EFalse );

    CXnProperty* colorProperty = aNode.GetPropertyL( XnPropertyNames::appearance::common::KColor );

    if( colorProperty != NULL )

        {

        CXnDomProperty* domProperty = colorProperty->Property();

        if( domProperty )

            {

            TInt error( KErrNotSupported );

            CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >

                                            ( domProperty->PropertyValueList().Item( 0 ) );

            if( value->IsAutoIdent() )

                {

                MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

                error = AknsUtils::GetCachedColor(skinInstance, textColor, KAknsIIDQsnTextColors,

                EAknsCIQsnTextColorsCG6);

                }

            else if( value->PrimitiveValueType() == CXnDomPropertyValue::ERgbColor )

                {

                textColor = value->RgbColorValueL();

                error = KErrNone;

                }

            else

            	{

                HBufC* colorString = colorProperty->StringValueL();

                CleanupStack::PushL( colorString );

                CXnUtils::StripQuotes( colorString );

                TInt index = 0;

                TAknsItemID skinID;

                TBool idResolved = CXnUtils::ResolveSkinItemIDL( colorString->Des(), skinID, index );

                if( idResolved )

                	{

                	MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

                	error = AknsUtils::GetCachedColor( skinInstance, textColor, skinID, index );

                	}

                else // use auto value if skin id is invalid.

                	{

	                MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

	                error = AknsUtils::GetCachedColor(skinInstance, textColor, KAknsIIDQsnTextColors,

	                EAknsCIQsnTextColorsCG6);

	                }

            	CleanupStack::PopAndDestroy( colorString );                	

            	}

            if (error == KErrNone)

                {

                textColorSet = ETrue;

                }

            }

        }

    CXnProperty* effectsProperty = aNode.GetPropertyL(XnPropertyNames::appearance::common::KTextEffects);

    if ( effectsProperty )

        {

        TInt error(KErrNotSupported);

        effectsDevColorSet = ETrue; //some color needed, device color by default

        CXnProperty* effectsColorProperty = aNode.GetPropertyL(XnPropertyNames::appearance::common::KEffectsColor);

        if (effectsColorProperty)

            {

            CXnDomProperty* domProperty = effectsColorProperty->Property();

            if( domProperty )

                {

                CXnDomPropertyValue* value = static_cast<CXnDomPropertyValue*>(domProperty->PropertyValueList().Item(0));

                    if (value->IsAutoIdent())

                        {

                        MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

                        error = AknsUtils::GetCachedColor(skinInstance, effectsColor, KAknsIIDQsnTextColors,

                        EAknsCIQsnTextColorsCG6);

                        }

                    else if (value->PrimitiveValueType() == CXnDomPropertyValue::ERgbColor)

                        {

                        effectsColor = value->RgbColorValueL();

                        error = KErrNone;

                        }

                        else

                        	{

                            HBufC* colorString = effectsColorProperty->StringValueL();

                            CleanupStack::PushL( colorString );

                            CXnUtils::StripQuotes( colorString );

                            TInt index = 0;

                            TAknsItemID skinID;

                            TBool idResolved = CXnUtils::ResolveSkinItemIDL( colorString->Des(), skinID, index );

                            if( idResolved )

                            	{

                            	MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

                            	error = AknsUtils::GetCachedColor( skinInstance, effectsColor, skinID, index );

                            	}

                            else // use auto value if skin id is invalid.

                            	{

            	                MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

            	                error = AknsUtils::GetCachedColor(skinInstance, effectsColor, KAknsIIDQsnTextColors,

            	                EAknsCIQsnTextColorsCG6);

            	                }

                        	CleanupStack::PopAndDestroy( colorString );                	

                        	}

                if ( error == KErrNone )

                	{

                    effectsColorSet = ETrue; //theme color found

                    effectsDevColorSet = EFalse;//device color not needed

                    }

                }

            }

        }

    if ( textColorSet )

        {

        if ( effectsColorSet )

            {//theme font color and theme effects color

            iLabel->OverrideColorL(EColorControlBackground, textColor);

            iLabel->OverrideColorL(EColorLabelText, effectsColor);

            }

        else if ( effectsDevColorSet )

            {//theme font color and device effects color

            iLabel->OverrideColorL(EColorControlBackground, textColor);

            }

        else

            {//theme font color, but no effects defined

            iLabel->OverrideColorL(EColorLabelText, textColor);

            }

        }

    else if ( effectsColorSet )

            {//device font color and theme effects color

            iLabel->OverrideColorL(EColorLabelText, effectsColor);

            }//else device font color and device effects color (default)

    CXnProperty* textDecorationProp = aNode.GetPropertyL( XnPropertyNames::appearance::common::KTextDecoration );