/*

* Copyright (c) 2002-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

*

*/

// System includes

#include <utf.h>

#include <AknsUtils.h>

#include <AknUtils.h>

// User includes

#include "xnviewnodeimpl.h"

#include "xndompropertyvalue.h"

#include "xndomlist.h"

#include "xnproperty.h"

#include "xnnodepluginif.h"

#include "xntype.h" 

#include "c_xnutils.h"

#include "xnnewstickeradapter.h"

#include "xnnewstickercontrol.h"

#include "xnnewstickersvgcontrol.h"

#include "xncomponentnodeimpl.h"

// ============================= LOCAL FUNCTIONS ===============================

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

// GetIntPropertyL

// Gets an integer property from the node.

// Returns: aNode UI node

//          aproperty The property that is to be found

//          return The value of the property. If not found, KErrNotFound returned.

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

// 

static TInt GetIntPropertyL(

    CXnNodePluginIf& aNode,

    const TDesC8& aProperty)

    {

    CXnProperty* prop = aNode.GetPropertyL(aProperty);

    if(prop)

        {        

        CXnDomPropertyValue* value = 

            static_cast<CXnDomPropertyValue*>(prop->Property()->PropertyValueList().Item(0));

        if(CXnDomPropertyValue::ENumber == value->PrimitiveValueType())

            {

            TInt integer = static_cast<TInt>(prop->FloatValueL());

            return integer;

            }

        }

    return KErrNotFound;

    }

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

// 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;

	}        

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

// CXnNewstickerAdapter::CheckDisplayL

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

//

TBool CXnNewstickerAdapter::CheckDisplayL( CXnNodePluginIf& aNode )

    {

    if( iPowerSaveMode )

        {

        iDisplay = EFalse;

        return iDisplay;

        }

	CXnProperty* displayProp( aNode.DisplayL() );

	if( displayProp )

	    {

	    const TDesC8& display( displayProp->StringValue() );

	    if( display != XnPropertyNames::style::common::display::KBlock )

	        {

	        return EFalse;

	        }

	    }

	CXnProperty* visibilityProp( aNode.VisibilityL());

	if( visibilityProp )

	    {

	    const TDesC8& visibility( visibilityProp->StringValue() );

	    if( visibility != XnPropertyNames::style::common::visibility::KVisible )

	        {

	        return EFalse;

	        }

	    }

    CXnNodePluginIf* parent( aNode.ParentL() );

    TBool ret( ETrue );

    if( parent )

        {

        ret = CheckDisplayL( *parent );

        }

    iDisplay = ret;  

    return iDisplay;          

    }

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

// CXnNewstickerAdapter::SetNewstickerPropertiesL

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

//

void CXnNewstickerAdapter::SetNewstickerPropertiesL()

    {

    // scroll amount 

    TInt scrollamount = GetIntPropertyL( iNode, 

        XnPropertyNames::newsticker::KXnScrollAmount );   // px

    if( KErrNotFound == scrollamount )

        {

        scrollamount = KXnNewstickerScrollAmount;

        }

    CXnProperty* prop( iNode.GetPropertyL( XnPropertyNames::newsticker::KScrollBehaviour ) );

    if( prop )

        {

        if ( prop->StringValue() == XnPropertyNames::newsticker::scroll_behaviour::KAlternate )

            {

            scrollamount = 0;

            iScrollBehaviour = EAlternate;

            }

        else if ( prop->StringValue() == XnPropertyNames::newsticker::scroll_behaviour::KSlide )

            {

            iScrollBehaviour = ESlide;

            }

        else if ( prop->StringValue() == XnPropertyNames::newsticker::scroll_behaviour::KScrollAlternate )

            {

            iScrollBehaviour = EScrollAlternate;

            }

        else

            {

            iScrollBehaviour = EScroll;

            }

        }

    else

        {

        iScrollBehaviour = EScroll;

        }        

    iControl->SetScrollAmount( scrollamount );

    if( iScrollBehaviour == EScroll || iScrollBehaviour == ESlide )

        {                    

        // scroll delay

        TInt scrolldelay = GetIntPropertyL( iNode, 

            XnPropertyNames::newsticker::KXnScrollDelay );  // ms

        if( KErrNotFound == scrolldelay )

            {

            scrolldelay = KXnNewstickerInterval;

            }

        else 

            {

            scrolldelay *= 1000;    // change to microseconds

            }

        iInterval = scrolldelay;

        // start delay

        TInt startdelay = GetIntPropertyL( iNode, 

            XnPropertyNames::newsticker::KXnStartDelay ); // ms

        if( KErrNotFound == startdelay )

            {

            startdelay = KXnNewstickerDelay;

            }

        else 

            {

            startdelay *= 1000;    // change to microseconds

            }

        iDelay = startdelay;

        }

    else if( iScrollBehaviour == EScrollAlternate )

		{

        // scroll delay

        TInt scrolldelay = GetIntPropertyL( iNode, 

            XnPropertyNames::newsticker::KXnScrollDelay );  // ms

        if( KErrNotFound == scrolldelay )

            {

            scrolldelay = KXnNewstickerInterval;

            }

        else 

            {

            scrolldelay *= 1000;    // change to microseconds

            }

        iInterval = scrolldelay;

        TInt alternateTime( GetIntPropertyL( iNode, XnPropertyNames::newsticker::KDisplayTime ) );

        if( alternateTime == KErrNotFound )

            {

            alternateTime = 0;

            }

        alternateTime *= 1000; // change to ms                        

        iAlternateInterval = alternateTime;

        // start delay

        TInt startdelay = GetIntPropertyL( iNode, 

            XnPropertyNames::newsticker::KXnStartDelay ); // ms

        if( KErrNotFound == startdelay )

            {

            startdelay = 0;

            }

        else 

            {

            startdelay *= 1000;    // change to microseconds

            }

        iDelay = startdelay;

        }

    else // TScrollBehaviour::EAlternate

        {

        TInt alternateTime( GetIntPropertyL( iNode, XnPropertyNames::newsticker::KDisplayTime ) );

        if( alternateTime == KErrNotFound )

            {

            alternateTime = 0;

            }

        alternateTime *= 1000; // change to ms                        

        iDelay = 0;

        iInterval = alternateTime;

        }        

    //  animation time

    iAnimationTime = GetIntPropertyL( iNode, 

        XnPropertyNames::newsticker::KXnNewstickerAnimationDelay );  // ms

    if( KErrNotFound == iAnimationTime )

        {

        iAnimationTime = KAnimationTime;

        }

    else 

        {

        iAnimationTime *= 1000;    // change to microseconds

        }

    // _s60-scroll-loop property. True by default.

    CXnProperty* loopProp( iNode.GetPropertyL( XnPropertyNames::newsticker::KScrollLoop ) );

    if( loopProp && loopProp->StringValue() == XnPropertyNames::KFalse )

        {

        iControl->SetScrollLooping( EFalse );

        }

    else

        {

        iControl->SetScrollLooping( ETrue );

        }            

    CXnProperty* restartProperty( iNode.GetPropertyL( XnPropertyNames::newsticker::KRestartAfterUpdate ) );

    if ( restartProperty && restartProperty->StringValue() == XnPropertyNames::KTrue )

        {

        iRestartAfterUpdate = ETrue;

        }

     }

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

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

// CXnNewstickerAdapter::NewL

// Symbian static 1st phase constructor

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

//

CXnNewstickerAdapter* CXnNewstickerAdapter::NewL(CXnControlAdapter* aParent, 

    CXnNodePluginIf& aNode)

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;	

    }

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

// CXnNewstickerAdapter::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CXnNewstickerAdapter::ConstructL()

    {

    CXnControlAdapter::ConstructL( iNode );

    iControl = CXnNewstickerControl::NewL( this );    

    iSvgControl = CXnNewstickerSvgControl::NewL( this );

    iPeriodicTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iPowerSaveMode = ETrue;

    iRestartAfterUpdate = EFalse;

    SetTextPropertiesL();

    SetNewstickerPropertiesL();

    RPointerArray<CXnNodePluginIf> children = iNode.ChildrenL();

    CleanupClosePushL( children );

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

        {

        CXnNodePluginIf* child( children[i] );

        CXnType* xnType = child->Type();

        // We only care for <title> nodes

        if ( xnType && xnType->Type() == XnPropertyNames::title::KTitle )

            {

            // Append  title, if one is given from the theme use that.

            // If no content yet available create empty title so that 

            // indexing is always current

            const TDesC8& pcData( child->GetPCData() );

            HBufC* pcData16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L( pcData );

            CleanupStack::PushL( pcData16 );

            TPtr ptr( pcData16->Des() );

            CXnUtils::CollapseWhiteSpace( iNode, ptr );

            if( ptr.Length() > 0 )

                {

                iControl->AppendTitleL( *pcData16 );

                }

            else

                {

                iControl->AppendTitleL( KNullDesC );

                }

            CleanupStack::PopAndDestroy( pcData16 );

            }

        }

    CleanupStack::PopAndDestroy( &children );

    }

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

// CXnNewstickerAdapter::CXnNewstickerAdapter

// C++ default constructor

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

//

CXnNewstickerAdapter::CXnNewstickerAdapter(CXnControlAdapter* /*aParent*/, 

    CXnNodePluginIf& aNode)

    : iState(ENotStarted), iNode(aNode)

    {

    }

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

// CXnNewstickerAdapter::~CXnNewstickerAdapter

// C++ destructor

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

//

CXnNewstickerAdapter::~CXnNewstickerAdapter()

    {           

    if( iPeriodicTimer )

        {

        iPeriodicTimer->Cancel();

        }

    delete iPeriodicTimer;

    if( iFont && iReleaseFont )

        {

        CWsScreenDevice* dev = iCoeEnv->ScreenDevice();

        dev->ReleaseFont( iFont ); 

        }

    delete iControl;

    if( iState == EAnimation )

        {

        TRAP_IGNORE( iSvgControl->StopL() );

        }

    delete iSvgControl;

    delete iBufferDevice;

	delete iDrawingBuffer;

	delete iBufferGc;

    delete iBackgroundBitmap;

    }

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

// CXnNewstickerAdapter::SetTextPropertiesL

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

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

//

void CXnNewstickerAdapter::SetTextPropertiesL()

    {

    if (iFont && iReleaseFont)

        {

        CWsScreenDevice* dev = iCoeEnv->ScreenDevice();

        dev->ReleaseFont(iFont); 

        iFont = NULL;

        }

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

    iControl->SetFont(iFont);

    TBool colorSet(EFalse);

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

    if (colorProperty != NULL)

        {

        CXnDomProperty* domProperty = colorProperty->Property();

        if(domProperty)

            {

            TRgb textColor;

            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)

                {

                iControl->SetTextColor(textColor);

                colorSet = ETrue;

                }

            }

        }

    if(!colorSet) // Use text skin color

        {

        MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();

        TRgb textColor;

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

            KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG6);