/*
* 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 group
*
*/



#include "alf/alfcontrolgroup.h"
#include "alfcontrolgroupsubsession.h"
#include "alf/alfcontrol.h" 
#include "alf/alfenv.h"
#include "alfclient.h"
#include "alf/alftransformation.h"

#include <uiacceltk/HuiUtil.h>

// used flags
enum TAlfControlGroupFlags
    {
    EAlfControlGroupAllowInput =        0x01
    };

// private data
struct CAlfControlGroup::TPrivateData
    {
    RAlfControlGroupSubSession iControlGroupSubSession; // Owned
    TUint iFlags;                           // Owned.
    TInt iResourceId;                       // Owned.
    CAlfEnv* iEnv;                          // Not owned.
    RPointerArray<CAlfControl> iControls;   // Owned.
    CAlfTransformation* iTransform;         // Owned.
    CAlfDisplay* iBoundDisplay;				// Not owned.
    };

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

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CAlfControlGroup::CAlfControlGroup()
    {
    }


// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CAlfControlGroup::ConstructL(TInt aResourceId, CAlfEnv& aEnv)
    {
    iData = new (ELeave) TPrivateData;
    
    User::LeaveIfError(
        iData->iControlGroupSubSession.Open(aEnv.Client(), aResourceId) );
    
    iData->iFlags = EAlfControlGroupAllowInput;
    iData->iEnv = &aEnv;
    //iData->iOpacity.Set(1.0);
    iData->iResourceId = aResourceId;
    iData->iTransform = NULL;
    iData->iBoundDisplay = NULL;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CAlfControlGroup::~CAlfControlGroup()
    {
    if ( iData )
        {
        iData->iControls.ResetAndDestroy();
        
        delete iData->iTransform;
        iData->iTransform = NULL;
        
        iData->iControlGroupSubSession.Close();
        }
    
    delete iData;
    iData = NULL;
    }
  
// ---------------------------------------------------------------------------
// Returns server side handle
// ---------------------------------------------------------------------------
//  
TInt CAlfControlGroup::Identifier() const
    {
    return iData->iControlGroupSubSession.SubSessionHandle();
    }

// ---------------------------------------------------------------------------
// Binds this control group to the given display.
// ---------------------------------------------------------------------------
//
void CAlfControlGroup::BindDisplay(CAlfDisplay* aDisplay)
	{
	iData->iBoundDisplay = aDisplay;
	}

// ---------------------------------------------------------------------------
// Returns ID.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CAlfControlGroup::ResourceId() const
    {
    return iData->iResourceId;
    }

// ---------------------------------------------------------------------------
// Appends a control
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfControlGroup::AppendL(CAlfControl* aControl)
    {
    TInt err = KErrNone;
    
    User::LeaveIfError( iData->iControls.Append(aControl) );
        
    // Update server side:
    err = iData->iControlGroupSubSession.Append( aControl->Identifier() );
    if ( err != KErrNone )
        {
        iData->iControls.Remove( iData->iControls.Count()-1 );
        User::LeaveIfError( err );
        }
    
    // Show the appended control if the control group was shown.
    if ( iData->iBoundDisplay )
    	{
        TRAP( err, aControl->ShowL( *iData->iBoundDisplay ));    	
    	}

    // If a leave occurred remove the control from client and server side control group.
    if ( err != KErrNone )
        {        
        iData->iControlGroupSubSession.Remove( aControl->Identifier() );
        iData->iControls.Remove( iData->iControls.Count()-1 );
        User::LeaveIfError( err );
        }
    
    // Everything OK.
    aControl->SetControlGroup(*this);    
    }
 
// ---------------------------------------------------------------------------
// Removes a control
// ---------------------------------------------------------------------------
//   
EXPORT_C TInt CAlfControlGroup::Remove(CAlfControl* aControl)
    {
    // Update server side:
    TInt err = iData->iControlGroupSubSession.Remove( aControl->Identifier() );
    
    // Update own array if server side is OK.
    if ( err == KErrNone )
        {
        // If found on the server side, we must find it also from the client side.
        TInt index = iData->iControls.Find(aControl);
        __ASSERT_DEBUG( index != KErrNotFound, USER_INVARIANT() );
        if(index != KErrNotFound)
            {
            iData->iControls.Remove(index);
            }
        else
            {
            err = KErrNotFound;
            }
        }
    else
        {
        // If we cannot find it from the server side, we must not find it on the client side.
        __ASSERT_DEBUG( iData->iControls.Find(aControl) == KErrNotFound , USER_INVARIANT() );
        }
    
    if ( err == KErrNone )
        {
        CAlfControlGroup* dummy = NULL;
        aControl->SetControlGroup(*dummy);
        
        // Hide the control, if this control group has been visible
        if( iData->iBoundDisplay )
        	{
        	aControl->Hide( *iData->iBoundDisplay );
        	}
        }
    
    return err;
    }
   
// ---------------------------------------------------------------------------
// Accepts input?
// ---------------------------------------------------------------------------
// 
EXPORT_C TBool CAlfControlGroup::AcceptInput() const
    {
    return iData->iFlags&EAlfControlGroupAllowInput;
    }
    
// ---------------------------------------------------------------------------
// Set accepts input
// ---------------------------------------------------------------------------
// 
EXPORT_C void CAlfControlGroup::SetAcceptInput(TBool aAcceptInput) 
    {
    if ( aAcceptInput )
        {
        iData->iFlags|=EAlfControlGroupAllowInput;
        }
    else
        {
        iData->iFlags&=~EAlfControlGroupAllowInput;
        }
    }
   
// ---------------------------------------------------------------------------
// Finds control by ID
// ---------------------------------------------------------------------------
//  
EXPORT_C CAlfControl* CAlfControlGroup::FindControl(TInt aId, TBool aUserId) const
    {
    for(TInt i = 0; i < iData->iControls.Count(); ++i)
        {
        if( (aUserId?
            iData->iControls[i]->Id():
            iData->iControls[i]->Identifier()) 
                == aId)
            {
            return iData->iControls[i];
            }
        }
    return NULL;
    }

// ---------------------------------------------------------------------------
// Returns control count.
// ---------------------------------------------------------------------------
//    
EXPORT_C TInt CAlfControlGroup::Count() const
    {
    return iData->iControls.Count();
    }
    
// ---------------------------------------------------------------------------
// Returns indexed control
// ---------------------------------------------------------------------------
// 
EXPORT_C CAlfControl& CAlfControlGroup::Control(TInt aIndex) const
    {
    return *iData->iControls[aIndex];
    }

// ---------------------------------------------------------------------------
// Enables transformation.
// ---------------------------------------------------------------------------
// 
EXPORT_C void CAlfControlGroup::EnableTransformationL(TBool aIsTransformed)
    {
    if ( aIsTransformed && iData->iTransform )
        {
        // Already enabled
        return;
        }
    
    if ( !aIsTransformed && !iData->iTransform )
        {
        // Already disabled
        return;
        }
    
    if ( aIsTransformed )
        {
        iData->iTransform = CAlfTransformation::NewL(*iData->iEnv);
        }
   
    // use the server handle from the transformation object if present
    TInt transformationHandle = 
        iData->iTransform ? 
            iData->iTransform->ServerHandle() : 
            0 ;
            
    // send the message to the server
    TInt err = iData->iControlGroupSubSession.EnableTransformation(
        transformationHandle,
        aIsTransformed );
     
    if ( err == KErrNone && !aIsTransformed )
        {
        delete iData->iTransform;
        iData->iTransform = NULL;
        }
    
    if ( err != KErrNone )
        {
        delete iData->iTransform;
        iData->iTransform = NULL;
        User::Leave( err );
        }
    }
    
    
// ---------------------------------------------------------------------------
// Returns is transformation enabled
// ---------------------------------------------------------------------------
// 
EXPORT_C TBool CAlfControlGroup::IsTransformed() const
    {
    return iData->iTransform != 0;
    }
    
// ---------------------------------------------------------------------------
// Returns transformation
// ---------------------------------------------------------------------------
// 
EXPORT_C CAlfTransformation& CAlfControlGroup::Transformation()
    {
    __ASSERT_ALWAYS( iData->iTransform, USER_INVARIANT() );
    return *iData->iTransform;        
    }