/*

* 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:   Control base class.

*

*/

#include "alf/alfcontrol.h"

#include "alf/alfcontrolgroup.h"

#include "alf/alfdisplay.h"

#include "alf/alfroster.h"

#include "alf/alfenv.h"

#include "alf/alfvisualfactory.h"

#include "alfclient.h"

#include "alf/alfgencomponent.h"

#include "alf/alfconstants.h"

#include "alf/alftimedvalue.h"

#include "alflogger.h"

#include <uiacceltk/HuiUtil.h>

#include <eikappui.h>

// Private structure

struct CAlfControl::TPrivateData

    {

    CAlfEnv* iEnv;                      // Not owned.

    CAlfControlGroup* iOwnerGroup;      // Not owned.

    CAlfDisplay* iBoundDisplay;         // Not owned.

    TInt iId;                           // Owned.

    TInt iHostId;                       // Owned.

    TInt iRole;                         // Owned.

    RPointerArray<CAlfVisual> iVisuals; // Not owned.

    CAlfControl* iHost;                 // Not owned.

    struct SConnection

        {

        CAlfControl* iControl;          // Not owned.

        TInt iRole;                     // Owned.

        };

    RArray<SConnection> iConnections;   // Owned.

    TBool iFocusing;                    // Owned.

    TBool iHasFocus;                    // Owned.

    CAlfGenComponent* iComms;           // Owned

    };

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

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

// Constructor

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

//

EXPORT_C CAlfControl::CAlfControl()

    {

    }

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

// ConstructL

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

//

EXPORT_C void CAlfControl::ConstructL(CAlfEnv& aEnv)

    {

    iData = new (ELeave) TPrivateData;

    iData->iEnv = &aEnv;

    iData->iFocusing = EFalse;

    //iData->iId = CAlfStatic::GenerateId();  

    // NULL data

    iData->iOwnerGroup = NULL;

    iData->iBoundDisplay = NULL;

    iData->iId = 0;

    iData->iHostId = 0;

    iData->iRole = 0;

    iData->iVisuals.Reset();

    iData->iHost = NULL;

    iData->iConnections.Reset();

    iData->iHasFocus = EFalse;

    iData->iComms = 0;

    iData->iComms = CAlfGenComponent::NewL(aEnv,

            EAlfCntrlCreate, 

            0, 

            KNullDesC8);

    iData->iId = Identifier(); // to have unique value 

    }

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

// Destructor.

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

//

EXPORT_C CAlfControl::~CAlfControl()

    {

    if ( iData )

        { 

        // Cancel scheduled commands for this control.

        Env().CancelCustomCommands(this);

        Env().CancelCommands(this);

        if(iData->iHost)

            {

            iData->iHost->RemoveConnection(this);

            iData->iHost = NULL;

            }

        for(TInt i = iData->iConnections.Count() - 1; i >= 0; --i)

            {

            RemoveConnection(iData->iConnections[i].iControl);

            }

        iData->iConnections.Reset();

        // The visuals are owned by the control.

        iData->iVisuals.ResetAndDestroy();

        delete iData->iComms;

        }

    delete iData;

    iData = NULL;

    }

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

// Returns server handle

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

//

EXPORT_C TInt CAlfControl::Identifier() const

    {

    return iData->iComms->Identifier();

    }

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

// Returns the env

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

//

EXPORT_C CAlfEnv& CAlfControl::Env() const

    {

    return *iData->iEnv;

    }

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

// Returns control group that this control is in.

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

//

EXPORT_C CAlfControlGroup* CAlfControl::ControlGroup() const

    {

    return iData->iOwnerGroup;

    }

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

// Sets the control group

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

//   

void CAlfControl::SetControlGroup(CAlfControlGroup& aOwnerGroup)

    {

    iData->iOwnerGroup = &aOwnerGroup;

    }

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

// Returns bound display

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

//     

EXPORT_C CAlfDisplay* CAlfControl::Display() const

    {

    return iData->iBoundDisplay;

    }

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

// Sets bound display

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

//   

EXPORT_C void CAlfControl::BindDisplay(CAlfDisplay& aDisplay)

    {

    iData->iBoundDisplay = &aDisplay;

    }    

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

// Sets control ID.

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

//

EXPORT_C void CAlfControl::SetId(TInt aId)

    {

    iData->iId = aId;

    }

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

// Returns control ID.

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

//

EXPORT_C TInt CAlfControl::Id() const

    {

    return iData->iId;

    }

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

// Appends new visual

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

//

EXPORT_C TInt CAlfControl::Append(CAlfVisual* aVisual, CAlfLayout* aParentLayout)

    {

    TInt err = KErrNone;

    ASSERT(aVisual); // must not be null

    if(&aVisual->Owner() != this) // ownership cannot be altered here

        {

        return KErrNotSupported;

        }

    // prevent adding visual several times

    for (TInt i = iData->iVisuals.Count()-1;i>=0;i--)

        {

        if (iData->iVisuals[i] == aVisual)

            {

            return KErrAlreadyExists;

            }

        }

    // Append the visual to the visuals array.

    err = iData->iVisuals.Append(aVisual);

    if ( err )

        {

        __ALFLOGSTRING1( "CAlfControl::Append return error %d", err )

        return err;

        }

    if(aParentLayout)

        { // once parent layout has been set, the visual has already relation in shape 

          // server side, tell the layout that theres no need to synch that info to server 

          // anymore (latter param)

        err = aParentLayout->Append(aVisual, ETrue);  

        if ( err != KErrNone )

            {

            __ALFLOGSTRING1( "CAlfControl::Append return error %d", err )

            // Do cleanup

            iData->iVisuals.Remove(iData->iVisuals.Find(aVisual));

            return err;

            }

        }

     /*   

    if ( iData->iInformServerAboutAppendRemove )

        {

        TInt2 params(aVisual->Identifier(), aParentLayout ? aParentLayout ->Identifier() : 0 );

        TPckgC<TInt2> inPckg(params);

        TBuf8<1> dum;

        TInt err = iData->iComms->DoSynchronousCmd( EAlfCntrlAppendVisual, inPckg , dum );

        if ( err != KErrNone )

            {

            __ALFLOGSTRING1( "CAlfControl::Append return error %d", err )

            // Do cleanup

            if ( aParentLayout )

                {

                aParentLayout->Remove(aVisual);  

                }

            iData->iVisuals.Remove(iData->iVisuals.Find(aVisual));

            return err;

            }

        }*/

    TRAP(err, VisualAddedL(aVisual));

    if ( err != KErrNone )

        {

        __ALFLOGSTRING1( "CAlfControl::Append return error %d", err )

        // Do cleanup

        if ( aParentLayout )

            {

            aParentLayout->Remove(aVisual);

            }

        Remove( aVisual );

        }

    return err;

    }

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

// Removes visual

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

//

EXPORT_C void CAlfControl::Remove(CAlfVisual* aVisual)

    {

    /*

    if ( iData->iInformServerAboutAppendRemove && aVisual)

        {

        TPckgC<TInt> inPckg(aVisual->Identifier());

        TBuf8<1> dum;

        iData->iComms->DoSynchronousCmd( EAlfCntrlRemoveVisual, inPckg , dum );

        }*/

    TInt index = iData->iVisuals.Find(aVisual);

    if(index != KErrNotFound)

        {

        VisualRemoved(aVisual);

        iData->iVisuals.Remove(index);

        }

    }

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

// Creates and appends new visual

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

//

EXPORT_C CAlfVisual* CAlfControl::AppendVisualL(TAlfVisualType aVisualType,

                                                CAlfLayout* aParentLayout,

                                                TInt aImplementationUid )

    {

    CAlfVisual* visual = AlfVisualFactory::NewVisualLC(aVisualType, 

                                        aParentLayout, *this, *iData->iEnv, aImplementationUid);

    TInt err = Append(visual, aParentLayout);

    User::LeaveIfError( err );

    CleanupStack::Pop(visual);

    return visual;

    }

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

// Creates and appends new layout

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

//

EXPORT_C CAlfLayout* CAlfControl::AppendLayoutL(TAlfLayoutType aLayoutType,

                                                CAlfLayout* aParentLayout,

                                                TInt aImplementationUid)

    {

    CAlfLayout* layout = AlfVisualFactory::NewLayoutLC(aLayoutType,

                        aParentLayout, *this, *iData->iEnv, aImplementationUid);

    TInt err = Append(layout, aParentLayout);

    User::LeaveIfError( err );

    CleanupStack::Pop(layout);

    return layout;

    }

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

// Returns indexed visual

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

//

EXPORT_C CAlfVisual& CAlfControl::Visual(TInt aIndex) const

    {

    return *iData->iVisuals[aIndex];

    }

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

// Returns visual count.

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

//

EXPORT_C TInt CAlfControl::VisualCount() const

    {

    return iData->iVisuals.Count();

    }

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

// Finds visual with given tag.

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

//

EXPORT_C CAlfVisual* CAlfControl::FindTag(const TDesC8& aTag) const

    {

    ASSERT(iData);

    for(TInt i = 0; i < iData->iVisuals.Count(); ++i)

        {

        if(iData->iVisuals[i]->TagMatches(aTag))

            {

            return iData->iVisuals[i];

            }

        }   

    return NULL;

    }

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

// Returns host.

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

//

EXPORT_C CAlfControl* CAlfControl::Host() const

    {

    return iData->iHost;

    }

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

// Sets host.

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

//

EXPORT_C void CAlfControl::SetHost(CAlfControl* aHost)

    {

    // do not call this function directly. This should be only called by the 

    // AddConnectionL and RemoveConnection functions.

    if ( aHost )

        {    

        // When adding a host, the host must be aware of this connection first.

        __ASSERT_ALWAYS( aHost->FindConnection(this) != KErrNotFound, USER_INVARIANT() );

        }

    TRAPD(err, HostChangingL(aHost));

    if(err != KErrNone)

        {

        if(aHost)

            {

            RemoveVisualsFromHostControl(*aHost);

            }

        return;

        }

    iData->iHost = aHost;

    }

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

// Adds control connection.

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

//

EXPORT_C void CAlfControl::AddConnectionL(CAlfControl* aConnectedControl, TInt aRole)

    {

    // check that the connection does not exist:

    if ( FindConnection( aConnectedControl ) != KErrNotFound )

        {

        User::Leave( KErrAlreadyExists );

        }

    TPrivateData::SConnection client;

    client.iControl = aConnectedControl;

    client.iRole = aRole;

    User::LeaveIfError(iData->iConnections.Append(client));

    // This control is now the client's host.

    aConnectedControl->SetHost(this);

    ConnectionAddedL(aConnectedControl, aRole);

    }

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

// Removes control connection

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

//

EXPORT_C void CAlfControl::RemoveConnection(CAlfControl* aConnectedControl)

    {

    for(TInt i = 0; i < iData->iConnections.Count(); ++i)

        {

        if(iData->iConnections[i].iControl == aConnectedControl)

            {

            aConnectedControl->SetHost(NULL);

            const TInt role = iData->iConnections[i].iRole;

            iData->iConnections.Remove(i);

            ConnectionRemoved(aConnectedControl, role);

            return;

            }

        }

    // The client must exist.

    USER_INVARIANT();

    }

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

// Returns connection count

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

//

EXPORT_C TInt CAlfControl::ConnectionCount() const

    {

    return iData->iConnections.Count();

    }

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

// Returns indexed connection.

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

//

EXPORT_C CAlfControl& CAlfControl::Connection(TInt aIndex) const

    {

    return *iData->iConnections[aIndex].iControl;

    }

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

// Returns ordinal-indexed connection.

// @deprecated

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

//

EXPORT_C CAlfControl& CAlfControl::ConnectionByOrdinal(TInt aOrdinal) const

    {

    // First look based on role.

    for(TInt i = 0; i < iData->iConnections.Count(); ++i)

        {

        if(iData->iConnections[i].iRole == aOrdinal + 1)

            {

            return *iData->iConnections[i].iControl;

            }

        }

    // Fall back to index.

    return Connection(aOrdinal);

    }

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

// Returns given connection index.

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

//

EXPORT_C TInt CAlfControl::FindConnection(const CAlfControl* aConnected) const

    {

    for(TInt i = 0; i < iData->iConnections.Count(); ++i)

        {

        if(iData->iConnections[i].iControl == aConnected)

            {

            return i;

            }

        }

    return KErrNotFound;

    }

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

// Returns connection role

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

//

EXPORT_C TInt CAlfControl::ConnectionRole(TInt aIndex) const

    {

    return iData->iConnections[aIndex].iRole;

    }

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

// Returns connection ordinal

// @deprecated

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

//

EXPORT_C TInt CAlfControl::ConnectionOrdinal(TInt aIndex) const

    {