/*

* 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:   Implements CHuiVisual class. Visuals are graphical entities 

*                visible on a display.

*

*/

#include "uiacceltk/HuiVisual.h"  // Class definition

#include "uiacceltk/HuiLayout.h"

#include "uiacceltk/HuiControl.h"

#include "uiacceltk/HuiControlGroup.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiDisplay.h"

#include "uiacceltk/HuiRoster.h"

#include "uiacceltk/HuiTransformation.h"

#include "uiacceltk/HuiDrawing.h"

#include "HuiRenderPlugin.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiStatic.h"

#include "uiacceltk/HuiProbe.h"

#include "uiacceltk/huidropshadow.h"

#include "HuiRosterImpl.h"

#include "HuiFxEffect.h"

#include "HuiFxEffectParser.h"

#include "alflogger.h"

#include "HuiCmdBufferBrush.h"

#include "huicanvasrenderbuffer.h"

struct CHuiVisual::THuiVisualPrivateData

    {

public: // Functions

    // Constructor: initialize the data

    THuiVisualPrivateData() : iTacticons(), iDropShadow(NULL)

        {

        iEffect = NULL;

        iEffectParser = NULL;

        }

    // Destructor: destruct the data

    ~THuiVisualPrivateData()

        {

        iTacticons.Close();

        delete iDropShadow;

        delete iEffectParser;

        delete iEffect;

        }

    // structs

    struct TTacticon

        {

        TInt iFeedbackType;

        TInt iEventType;

        };

    // Data

    RArray<TTacticon> iTacticons;

    CHuiFxEffect* iEffect;

    CHuiFxEffectParser* iEffectParser;

    MHuiEffectable *iEffectable;

    CHuiCanvasRenderBuffer* iStoredRenderBuffer;

    TBool iStoredRenderBufferModificationsEnabled;

    TBool iFreezed;

    };

class CHuiEffectable : public CBase, public MHuiEffectable

    {

public: // from MHuiEffectable

    CHuiEffectable(CHuiVisual *aVisual) : iVisual(aVisual) { }

    void EffectSetEffect(CHuiFxEffect* aEffect);

    TReal32 EffectOpacityTarget() const;

    void EffectSetOpacity(TReal32 aOpacity);

    void EffectDrawSelf( CHuiGc &aGc, const TRect & aDisplayRect) const;

    THuiRealRect EffectDisplayRect() const __SOFTFP;

    void SetLoadingEffect(TBool aLoading);    

    void EffectSetSource( TBool aIsInput1 );

    TBool EffectGetSource() const;

private:

    CHuiVisual *iVisual;

    TBool iIsInput1;

    };

void CHuiEffectable::EffectSetEffect(CHuiFxEffect* aEffect)

    {

    iVisual->SetEffect(aEffect);

    }

void CHuiEffectable::EffectSetSource( TBool aIsInput1 )

    {

    iIsInput1 = aIsInput1;

    }

TBool CHuiEffectable::EffectGetSource() const

    {

    return iIsInput1;

    }

TReal32 CHuiEffectable::EffectOpacityTarget() const

    {

    return iVisual->iOpacity.Target();

    }

void CHuiEffectable::EffectSetOpacity(TReal32 aOpacity)

    {

    iVisual->iOpacity.Set( aOpacity );

    }

void CHuiEffectable::EffectDrawSelf( CHuiGc &aGc, const TRect & aDisplayRect) const

    {

    iVisual->DrawSelf(aGc, aDisplayRect);

    }

THuiRealRect CHuiEffectable::EffectDisplayRect() const __SOFTFP

    {

    return iVisual->DisplayRect();

    }

void CHuiEffectable::SetLoadingEffect(TBool aLoading)

    {

    iVisual->SetLoadingEffect(aLoading);

    }

/// Descriptor that is returned when the tag is queried and no tag has been

/// been defined for a visual.

_LIT8(KHuiVisualUndefinedTag, "");

EXPORT_C MHuiVisualOwner::~MHuiVisualOwner()

    {

    }

EXPORT_C CHuiCanvasRenderBuffer *CHuiVisual::StoredRenderBuffer() const

    {

    return iVisualData->iStoredRenderBuffer;

    }

EXPORT_C void CHuiVisual::SetStoredRenderBuffer(CHuiCanvasRenderBuffer *aRenderBuffer)

    {

    if (iVisualData->iStoredRenderBufferModificationsEnabled)

        {

        if (iVisualData->iStoredRenderBuffer)

            {

            iVisualData->iStoredRenderBuffer->UnInitialize();

            }

        delete iVisualData->iStoredRenderBuffer;

        iVisualData->iStoredRenderBuffer = aRenderBuffer;

        }

    }

EXPORT_C void CHuiVisual::SetStoredRenderBufferModificationsEnabled(TBool aEnabled)

    {

    iVisualData->iStoredRenderBufferModificationsEnabled = aEnabled;

    }

EXPORT_C void CHuiVisual::SetFreezeState(TBool aEnabled)

    {

    iVisualData->iFreezed = aEnabled;

    }

TBool CHuiVisual::Freezed() const

{

    return iVisualData->iFreezed;

}

EXPORT_C CHuiVisual* CHuiVisual::AddNewL(CHuiControl& aOwnerControl,

                                         CHuiLayout* aParentLayout)

    {

    CHuiVisual* visual = STATIC_CAST(CHuiVisual*,

        aOwnerControl.AppendVisualL(EHuiVisualTypeVisual, aParentLayout));

    return visual;

    }

EXPORT_C CHuiVisual::CHuiVisual(MHuiVisualOwner& aOwner)

        : iOpacity(1.f),

          iOwner(&aOwner), 

          // Set the maximum size to unlimited.

          iMaxSize(TSize(KMaxTInt, KMaxTInt)),

          iPadding(0), 

          iDisplayRectFrameNumber(KMaxTUint),

          iDisplayRectTargetFrameNumber(KMaxTUint)

    {

    HUI_PROBE_ASSOCIATE_WITH_CURRENT_SESSION

    HUI_PROBE_REPORT_CONSTRUCTED

    iOpacity.SetStyle(EHuiTimedValueStyleLinear);

    }

EXPORT_C void CHuiVisual::ConstructL()

    {

    iVisualData = new (ELeave) THuiVisualPrivateData;

    iVisualData->iEffectable = new CHuiEffectable(this);

    iVisualData->iStoredRenderBuffer = NULL;

    }

EXPORT_C CHuiVisual::~CHuiVisual()

    {

    // Cancel scheduled commands for this visual.

    Env().CancelCommands(this);

	// Update previous dirty rect to relevant displays so that the visual can be erased

    if(Display())

        {        

        CHuiRoster& roster = Display()->Roster();

		// Check if this roster is shared between several displays and add previous dirty to all 

		// of them

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

        	{ 

        	CHuiDisplay* display = &Env().Display(i);

        	if (&(display->Roster()) == &roster)

        		{

				TRect empty;

        		display->CombineAndAddDirtyRegion(previousDirtyRect, empty);

        		}

        	}	

        }

    // If this is a root-level visual, it must be hidden on the display.

    if(iDisplay)

        {

        iDisplay->Roster().HideVisual(this);

        }

    // If the visual is still attached to a layout, it is time to remove it.

    if(iLayout)

        {

        iLayout->Remove(this);

        }

    // If the visual is attached to some visual as external content visual,

    // remove the link from the parent visual

    if (Flags() & EHuiVisualFlagDrawOnlyAsExternalContent)

    	{

    	TRAP_IGNORE(CHuiStatic::Env().Display(0).RosterImpl().RemoveExternalContentVisualFromParentL(this));

    	}

    delete iBrushes;

    delete iTag;

    delete iTransform;

    delete iVisualData->iEffectable;

    if (iVisualData->iStoredRenderBuffer)

        {

        iVisualData->iStoredRenderBuffer->UnInitialize();

        }

    delete iVisualData->iStoredRenderBuffer;

    delete iVisualData;

    iOwner = NULL;

    iDisplay = NULL;

    iLayout = NULL;

    HUI_PROBE_REPORT_DESTRUCTED

    }

EXPORT_C void CHuiVisual::RemoveAndDestroyAllD()

    {

    ASSERT(iOwner != NULL);

    iOwner->VisualDestroyed(*this);

    delete this;

    }

EXPORT_C CHuiLayout* CHuiVisual::Layout() const

    {

    return iLayout;

    }

void CHuiVisual::SetLayout(CHuiLayout* aLayout)

    {

    iLayout = aLayout;

    }

EXPORT_C CHuiEnv& CHuiVisual::Env() const

    {

    return Owner().Env();

    }

EXPORT_C CHuiSkin& CHuiVisual::Skin() const

    {

    return Owner().Env().Skin();

    }

EXPORT_C CHuiDisplay* CHuiVisual::Display() const

    {

    const CHuiVisual* iter = this;

    while(iter)

        {

        if(iter->iDisplay)

            {

            return iter->iDisplay;

            }

        iter = iter->Layout();

        }

    // Not shown on any display.

    return NULL;

    }

void CHuiVisual::SetDisplay(CHuiDisplay* aDisplay)

    {

    iDisplay = aDisplay;

    }

EXPORT_C void CHuiVisual::SetFlag(THuiVisualFlags aFlag)

    {

    SetFlags(aFlag);

    }

EXPORT_C void CHuiVisual::SetFlags(TInt aAnyFlags)

    {

    const TInt oldFlags = iFlags;

    iFlags |= aAnyFlags;

    if(!CHuiStatic::Renderer().Allows(EHuiRenderPluginAllow3DProjection))

        {

        // The rendering plugin does not support 3D projection.

        ClearFlag(EHuiVisualFlag3DProjection);

        }

    HandleFlagsChanged( oldFlags );

    }

EXPORT_C void CHuiVisual::ClearFlag(THuiVisualFlags aFlag)

    {

    ClearFlags( aFlag );

    }

EXPORT_C void CHuiVisual::ClearFlags(TInt aAnyFlags)

    {

    const TInt oldFlags = iFlags;

    iFlags &= ~aAnyFlags;

    HandleFlagsChanged( oldFlags );

    }

EXPORT_C MHuiVisualOwner& CHuiVisual::Owner() const

    {

    ASSERT(iOwner != NULL);

    return *iOwner;

    }

EXPORT_C void CHuiVisual::SetOwner(MHuiVisualOwner& aOwner)

    {

    iOwner = &aOwner;

    }

EXPORT_C TInt CHuiVisual::Count() const

    {

    return 0;

    }

EXPORT_C CHuiVisual& CHuiVisual::Visual(TInt /*aIndex*/) const

    {

    USER_INVARIANT();

    return *(CHuiVisual*)this; // never reached

    }

EXPORT_C void CHuiVisual::SetOrigin(THuiVisualHOrigin aHoriz, THuiVisualVOrigin aVert)

    {

    ClearFlags(EHuiVisualFlagHOriginCenter | EHuiVisualFlagHOriginRight);

    switch(aHoriz)

        {

        case EHuiVisualHOriginCenter:

            SetFlag(EHuiVisualFlagHOriginCenter);

            break;

        case EHuiVisualHOriginRight:

            SetFlag(EHuiVisualFlagHOriginRight);

            break;

        default:

            break;

        }

    ClearFlags(EHuiVisualFlagVOriginCenter | EHuiVisualFlagVOriginBottom);

    switch(aVert)

        {

        case EHuiVisualVOriginCenter:

            SetFlag(EHuiVisualFlagVOriginCenter);

            break;

        case EHuiVisualVOriginBottom:

            SetFlag(EHuiVisualFlagVOriginBottom);

            break;

        default:

            break;

        }

    }

EXPORT_C THuiVisualHOrigin CHuiVisual::HorizontalOrigin() const

    {

    if(iFlags & EHuiVisualFlagHOriginCenter)

        {

        return EHuiVisualHOriginCenter;

        }

    if(iFlags & EHuiVisualFlagHOriginRight)

        {

        return EHuiVisualHOriginRight;

        }

    return EHuiVisualHOriginLeft;

    }

EXPORT_C THuiVisualVOrigin CHuiVisual::VerticalOrigin() const

    {

    if(iFlags & EHuiVisualFlagVOriginCenter)

        {

        return EHuiVisualVOriginCenter;

        }

    if(iFlags & EHuiVisualFlagVOriginBottom)

        {

        return EHuiVisualVOriginBottom;

        }

    return EHuiVisualVOriginTop;

    }

EXPORT_C void CHuiVisual::AlignByOrigin(THuiRealPoint& aPointInPixels, TBool aUndo) const

    {

    TInt factor = (aUndo? -1 : 1);

    THuiRealPoint itemSize(0.f, 0.f); 

    TInt horizOrig = HorizontalOrigin();

    TInt vertOrig = VerticalOrigin();

    // The position of the origin depends whether the coordinates are mirrored.    

    if(LocalBaseUnit().iX.iMagnitude < 0)

        {

        if(horizOrig == EHuiVisualHOriginLeft)

            {

            horizOrig = EHuiVisualHOriginRight;

            }

        else if(horizOrig == EHuiVisualHOriginRight)

            {

            horizOrig = EHuiVisualHOriginLeft;

            }

        else

            {

            // For PC-lint

            }

        }

    if(LocalBaseUnit().iY.iMagnitude < 0)

        {

        if(vertOrig == EHuiVisualVOriginTop)

            {

            vertOrig = EHuiVisualVOriginBottom;

            }

        else if(vertOrig == EHuiVisualVOriginBottom)

            {

            vertOrig = EHuiVisualVOriginTop;

            }

        else

            {

            // For PC-lint

            }

        }

    if(horizOrig != EHuiVisualHOriginLeft ||

        vertOrig != EHuiVisualVOriginTop)

        {

        // Need the size of the visual for aligning to non-top/left corner.

        itemSize = LocalPointInPixels(Size().RealNow());

        }

    switch(horizOrig)

        {

        case EHuiVisualHOriginCenter:

            aPointInPixels.iX -= factor * itemSize.iX / 2.f;

            break;

        case EHuiVisualHOriginRight:

            aPointInPixels.iX -= factor * itemSize.iX;

            break;

        default:

            break;

        }

    switch(vertOrig)

        {

        case EHuiVisualVOriginCenter:

            aPointInPixels.iY -= factor * itemSize.iY / 2.f;

            break;

        case EHuiVisualVOriginBottom:

            aPointInPixels.iY -= factor * itemSize.iY;

            break;

        default:

            break;

        }

    }

EXPORT_C const THuiTimedPoint& CHuiVisual::Pos() const

    {

    return iPos;

    }