/*

* Copyright (c) 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:   Visual base class.

*

*/

#include "alf/alfvisual.h"

#include "alf/alfenv.h"

#include "alf/alflayout.h"

#include "alf/alfcontrol.h"

#include "alf/alfbrusharray.h"

#include "alfclient.h"

#include "alf/alfdisplay.h"

#include "alf/alfroster.h"

#include "alf/alfgencomponent.h"

#include "alf/alftimedvalue.h"

#include "alf/alfconstants.h"

#include "alflogger.h"

#include "alf/alfmappingfunctions.h"

#include "alf/alftransformation.h"

#include "alf/alfstatic.h"

#include "alf/alfutil.h"

#include "alf/alfdropshadow.h"

#include <uiacceltk/HuiUtil.h>

NONSHARABLE_CLASS(CAlfVisualOwnerNotification) : public CBase, public MAlfAsyncOpObserver

    {

public:

    CAlfVisualOwnerNotification( CAlfVisual& aVisual );

    ~CAlfVisualOwnerNotification();

protected:

    void AlfAsyncOpCompleted(TInt aCommandId, TInt aStatus);

private:

    CAlfVisual& iVisual;

    TInt iCommandId;

    TBuf8<1> iDumBuffer;

    };

CAlfVisualOwnerNotification::CAlfVisualOwnerNotification( CAlfVisual& aVisual )

 : iVisual( aVisual )

    {

    iCommandId = 0;

    TRAPD( err, iCommandId = iVisual.Comms()->DoAsynchronousCmdL( EAlfVisualLayoutUpdatedNotification, iDumBuffer, iDumBuffer, this ) );

    __ASSERT_ALWAYS( err == KErrNone, USER_INVARIANT() );

    }

CAlfVisualOwnerNotification::~CAlfVisualOwnerNotification()

    {

    TBuf8<1> dum;

    if ( iCommandId )

        {

        iVisual.Comms()->DoSynchronousCmd( EAlfVisualLayoutUpdatedNotificationCancel, dum, dum );

        iVisual.Comms()->CancelAsynchCmd( iCommandId );

        iCommandId = 0;

        }

    }

void CAlfVisualOwnerNotification::AlfAsyncOpCompleted(TInt /*aCommandId*/, TInt aStatus)

    {

    iCommandId = 0;

    if ( aStatus == KErrNone )

        {

        TRAPD( err, iCommandId = iVisual.Comms()->DoAsynchronousCmdL( EAlfVisualLayoutUpdatedNotification, iDumBuffer, iDumBuffer, this ) );

        __ASSERT_ALWAYS( err == KErrNone, USER_INVARIANT() );

        iVisual.Owner().VisualLayoutUpdated( iVisual );

        }

    }

// Private data

struct CAlfVisual::TPrivateData

    {

    CAlfLayout* iLayout;            // Not owned.

    CAlfDisplay* iDisplay;          // Not Owned.

    TAlfTimedValue iOpacity;        // Owned.

    CAlfControl* iOwner;            // Not owned.

    HBufC8* iTag;                   // Owned. 

    CAlfBrushArray* iBrushes;       // Owned.

    CAlfGenComponent* iComms;       // owned 

    CAlfTransformation* iTransform;  // Owned.  

    TAlfBoxMetric iPadding;// Owned

    CAlfVisualOwnerNotification* iVisualOwnerNotification; // Own

    CAlfDropShadow* iDropShadowHandler;

    };

// ======== MACRO DEFINITIONS ========

void AssertPaddingsWereSetUsingDeprecatedPixelAPIs(const TAlfBoxMetric& aMetric)

    {

    __ASSERT_DEBUG(

        (aMetric.iLeft.iMagnitude == aMetric.iRight.iMagnitude) && 

        (aMetric.iTop.iMagnitude == aMetric.iBottom.iMagnitude) &&

        (aMetric.iLeft.iUnit == EAlfUnitPixel) &&

        (aMetric.iRight.iUnit == EAlfUnitPixel) &&

        (aMetric.iTop.iUnit == EAlfUnitPixel) &&

        (aMetric.iBottom.iUnit == EAlfUnitPixel)

        , USER_INVARIANT());

#ifndef _DEBUG // Remove compile warnings

    TAlfBoxMetric tmp = aMetric;

    tmp = tmp;

#endif        

    }

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

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

// Constructor

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

//

EXPORT_C CAlfVisual::CAlfVisual()

    {

    }

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

// ConstructL

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

//

EXPORT_C void CAlfVisual::ConstructL(CAlfControl& aOwner)

    {

    iData = new (ELeave) TPrivateData;

    iData->iLayout = NULL;

    iData->iDisplay = NULL;

    iData->iOwner = &aOwner;

    iData->iTag = NULL;

    iData->iBrushes = NULL;

    iData->iComms = NULL;

    iData->iTransform = NULL;

    iData->iPadding = TAlfBoxMetric(TAlfMetric(0));

    iData->iVisualOwnerNotification = NULL;

    iData->iDropShadowHandler = NULL;

    }

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

// ConstructL

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

//

EXPORT_C void CAlfVisual::ConstructL(CAlfControl& aOwner, TInt aImplementationId, TInt aImplementationUid, const TDesC8& aConstructionParams )

    {

    ConstructL(aOwner);

    if (!iData->iComms)

        {

        iData->iComms = CAlfGenComponent::NewL(

            aOwner.Env(),

            aImplementationId, 

            aImplementationUid, 

            aConstructionParams);         

        }

    }

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

// Destructor

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

//

EXPORT_C CAlfVisual::~CAlfVisual()

    {

    if ( iData )

        {

        delete iData->iDropShadowHandler;

        iData->iDropShadowHandler = NULL;

        delete iData->iVisualOwnerNotification;

        iData->iVisualOwnerNotification = NULL;

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

        if(iData->iLayout)

            {

            iData->iLayout->Remove(this);

            }

        delete iData->iBrushes;

        iData->iBrushes = NULL;

        delete iData->iTransform;

        iData->iTransform = NULL;

        delete iData->iTag;

        iData->iTag = NULL;

        delete iData->iComms;

        }

    delete iData;

    iData = NULL;

    }

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

// Destroys a hierarchy of visuals, along with this visual. The visuals

// are first removed from their owner.

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

//

EXPORT_C void CAlfVisual::RemoveAndDestroyAllD()

    {

    TBuf8<1> dum;

    // Remove and destory from the server side

    TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualRemoveAndDestroyAll,KNullDesC8, dum);

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "CAlfVisual::RemoveAndDestroyAllD ignore error %d", err )

        }

    DoRemoveAndDestroyAllD();

    }

EXPORT_C void CAlfVisual::DoRemoveAndDestroyAllD()

    {

    __ASSERT_ALWAYS( iData->iOwner, USER_INVARIANT() );

    iData->iOwner->VisualDestroyed(*this);

    delete this;

    }

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

// Returns subsession identifier, 0 by default.

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

//

EXPORT_C TInt CAlfVisual::Identifier() const

    {

    return iData->iComms->Identifier();

    }

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

// Sets layout for the visual.

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

//

void CAlfVisual::SetLayout(CAlfLayout* aLayout)

    {

    iData->iLayout = aLayout;

    }

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

// Returns current opacity

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

//    

EXPORT_C const TAlfTimedValue& CAlfVisual::Opacity() const

    {

    TPckg<TAlfTimedValue> buf(iData->iOpacity);

    TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualGetOpacity, KNullDesC8, buf);

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "CAlfVisual::Opacity panic error %d", err )

        USER_INVARIANT();

        }

    return iData->iOpacity;

    }

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

// Sets opacity.

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

//

EXPORT_C void CAlfVisual::SetOpacity( const TAlfTimedValue& aOpacity )

    {

    TPckgC<TAlfTimedValue> buf(aOpacity);

    TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetOpacity, buf);

    if ( err == KErrNone )

        {

        iData->iOpacity = aOpacity;

        }

    else

        {

        __ALFLOGSTRING1( "CAlfVisual::SetOpacity panic error %d", err )

        USER_INVARIANT();

        }

    }

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

// Returns position

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

//

EXPORT_C TAlfTimedPoint CAlfVisual::Pos() const

    {

    TAlfTimedPoint point;

    TPckg<TAlfTimedPoint> buf(point);

    TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualPos, KNullDesC8, buf);

    if (err)

        {

        __ALFLOGSTRING1( "CAlfVisual::Pos panic error %d", err )

        USER_INVARIANT();

        }

    return point;

    }

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

// Sets the position of the visual.

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

//

EXPORT_C void CAlfVisual::SetPos(const TAlfRealPoint& aPos, TInt aTransitionTime)

    {

    TAlfVisualPos pos = { aPos, aTransitionTime };

    TPckgC<TAlfVisualPos> buf(pos);

    TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetPos, buf);

    if (err) // for now

        {

        __ALFLOGSTRING1( "CAlfVisual::SetPos panic error %d", err )

        USER_INVARIANT();

        }

    }

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

// Returns the size of the visual. 

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

//

EXPORT_C const TAlfTimedPoint CAlfVisual::Size() const

    {

    TAlfTimedPoint size;

    TPckg<TAlfTimedPoint> buf(size);

    TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualSize, KNullDesC8, buf);

    if (err)

        {

        __ALFLOGSTRING1( "CAlfVisual::Size panic error %d", err )

        USER_INVARIANT();

        }

    return size;    

    }

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

// Sets the size of the visual.

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

//

EXPORT_C void CAlfVisual::SetSize(const TAlfRealSize& aSize, TInt aTransitionTime)

    {

    TAlfVisualSize size = { aSize, aTransitionTime };

    TPckgC<TAlfVisualSize> buf(size);

    TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetSize, buf );

    if (err) // for now

        {

        __ALFLOGSTRING1( "CAlfVisual::SetSize panic error %d", err )

        USER_INVARIANT();

        }

    }

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

// 

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

//  

EXPORT_C void CAlfVisual::SetFlag(TAlfVisualFlags aFlag)

    {

    TPckgC<TAlfVisualFlags> inBuf(aFlag);

    TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetFlag, inBuf );

    if (err) // for now

        {

        __ALFLOGSTRING1( "CAlfVisual::SetFlag panic error %d", err )

        USER_INVARIANT();

        }

    if ( aFlag == EAlfVisualFlagLayoutUpdateNotification && !iData->iVisualOwnerNotification )

        {

        iData->iVisualOwnerNotification = new CAlfVisualOwnerNotification( *this );

        __ASSERT_ALWAYS( iData->iVisualOwnerNotification , USER_INVARIANT() );

        }

    }

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

// 

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

//  

EXPORT_C void CAlfVisual::SetFlags(TUint aAnyFlags)

    {

    TPckgC<TUint> inBuf(aAnyFlags);

    TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetFlags, inBuf );

    if (err) // for now

        {

        __ALFLOGSTRING1( "CAlfVisual::SetFlags panic error %d", err )

        USER_INVARIANT();

        }

    if ( aAnyFlags & EAlfVisualFlagLayoutUpdateNotification && !iData->iVisualOwnerNotification )

        {

        iData->iVisualOwnerNotification = new CAlfVisualOwnerNotification( *this );

        __ASSERT_ALWAYS( iData->iVisualOwnerNotification , USER_INVARIANT() );

        }

    }

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

// 

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

//  

EXPORT_C void CAlfVisual::ClearFlag(TAlfVisualFlags aFlag)

    {

    TPckgC<TAlfVisualFlags> inBuf(aFlag);

    TInt err = iData->iComms->DoCmdNoReply( EAlfVisualClearFlag, inBuf );

    if (err) // for now

        {

        __ALFLOGSTRING1( "CAlfVisual::ClearFlag panic error %d", err )

        USER_INVARIANT();

        }

    if ( aFlag == EAlfVisualFlagLayoutUpdateNotification && iData->iVisualOwnerNotification )

        {

        delete iData->iVisualOwnerNotification;

        iData->iVisualOwnerNotification = NULL;

        }

    }

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

// 

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

//  

EXPORT_C void CAlfVisual::ClearFlags(TUint aAnyFlags)

    {

    TPckgC<TUint> inBuf(aAnyFlags);

    TInt err = iData->iComms->DoCmdNoReply( EAlfVisualClearFlags, inBuf );

    if (err) // for now

        {

        __ALFLOGSTRING1( "CAlfVisual::ClearFlags panic error %d", err )

        USER_INVARIANT();

        }

    if ( aAnyFlags & EAlfVisualFlagLayoutUpdateNotification && iData->iVisualOwnerNotification )

        {

        delete iData->iVisualOwnerNotification;

        iData->iVisualOwnerNotification = NULL;

        }

    }

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

// 

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

//  

EXPORT_C TUint CAlfVisual::Flags() const

    {

    TUint flags = 0;

    TPckg<TUint> outBuf(flags);

    TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualFlags, KNullDesC8, outBuf);

    if (err)

        {

        __ALFLOGSTRING1( "CAlfVisual::Flags panic error %d", err )

        USER_INVARIANT();

        }

    return flags; 

    }

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

// Returns layout

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

//    

EXPORT_C CAlfLayout* CAlfVisual::Layout() const

    {

    return iData->iLayout;

    }

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

// Returns env.

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

//

EXPORT_C CAlfEnv& CAlfVisual::Env() const

    {

    if (!iData || !iData->iOwner) // try to save what there's left to save

        {

        return CAlfStatic::Env();

        }

    return iData->iOwner->Env();

    }

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

// Returns tag.

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

//

EXPORT_C const TDesC8& CAlfVisual::Tag() const

    {

    if(iData && iData->iTag)

        {

        return *iData->iTag;

        }

    return KNullDesC8;

    }

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

// Returns display

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

// 

EXPORT_C CAlfDisplay* CAlfVisual::Display() const

    {

    const CAlfVisual* iter = this;

    while(iter)

        {

        if(iter->iData->iDisplay)

            {

            return iter->iData->iDisplay;

            }

        iter = iter->Layout();

        }

    // Not shown on any display.

    return NULL;

    }