/*
* Copyright (c) 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:   Mesh visual
*
*/



#include "alf/alfmeshvisual.h"
#include "alf/alfproceduralmesh.h"
#include "alf/alfm3gmesh.h"
#include "alf/alfcontrol.h"
#include "alflogger.h"
#include "alf/alfgencomponent.h"
#include "alf/alfconstants.h"
#include "alf/alfimage.h"
#include "alf/alftexture.h"
#include "alfskinnableimage.h"
#include "alf/alfenv.h"

#include <uiacceltk/HuiUtil.h>

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

struct CAlfMeshVisual::TMeshVisualPrivateData
    {
    CAlfMesh* iMesh; // own
    CAlfSkinnableImage* iImage;
    CAlfSkinnableImage* iSecondaryImage;    
    CAlfSkinnableImage* iSpecularImage;
    };

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//

EXPORT_C CAlfMeshVisual* CAlfMeshVisual::AddNewL(
    CAlfControl& aOwnerControl,
    CAlfLayout* aParentLayout )
    {
    CAlfMeshVisual* text = STATIC_CAST(CAlfMeshVisual*,
        aOwnerControl.AppendVisualL(EAlfVisualTypeMesh, aParentLayout));
    return text;
    }

EXPORT_C CAlfMeshVisual::CAlfMeshVisual()
    {
    }

EXPORT_C void CAlfMeshVisual::ConstructL(CAlfControl& aOwner)
    {
    CAlfVisual::ConstructL(aOwner);
    
    iMeshVisualData = new (ELeave) TMeshVisualPrivateData;
    iMeshVisualData->iMesh = NULL;
    iMeshVisualData->iImage = NULL;
    iMeshVisualData->iSecondaryImage = NULL;
    iMeshVisualData->iSpecularImage = NULL;
    
    iMeshVisualData->iImage = new (ELeave) CAlfSkinnableImage(&aOwner.Env());
    iMeshVisualData->iSecondaryImage = new (ELeave) CAlfSkinnableImage(&aOwner.Env());
    iMeshVisualData->iSpecularImage = new (ELeave) CAlfSkinnableImage(&aOwner.Env());
    }

EXPORT_C CAlfMeshVisual::~CAlfMeshVisual()
    {
    if ( iMeshVisualData )
        {
        delete iMeshVisualData->iMesh;
        iMeshVisualData->iMesh = NULL;
        
        delete iMeshVisualData->iImage;
        iMeshVisualData->iImage = NULL;

        delete iMeshVisualData->iSecondaryImage;
        iMeshVisualData->iSecondaryImage = NULL;

        delete iMeshVisualData->iSpecularImage;
        iMeshVisualData->iSpecularImage = NULL;
        }
        
    delete iMeshVisualData;
    iMeshVisualData = NULL;
    }
    
EXPORT_C void CAlfMeshVisual::CreateMeshL(TInt aMeshType)
    {
    // Destroy the old mesh object.
    if( iMeshVisualData->iMesh )
        {
        delete iMeshVisualData->iMesh;
        iMeshVisualData->iMesh = NULL;
        }
    
    // Create a new mesh object.
    if ( aMeshType == EAlfMeshTypeProcedural )
        {
        iMeshVisualData->iMesh = CAlfProceduralMesh::NewL( *Comms() );
        }
    if ( aMeshType == EAlfMeshTypeM3G )
        {
        iMeshVisualData->iMesh = CAlfM3GMesh::NewL( *Comms(), Env() );
        }        
    }
    
EXPORT_C void CAlfMeshVisual::SetImage(const TAlfImage& aImage)
    {    
    iMeshVisualData->iImage->SetImage(aImage);// This texturizes skin graphics if needed
    
    TAlfImageParams params(iMeshVisualData->iImage->Image());

    TPckgC<TAlfImageParams> buf(params);
    TInt err = Comms()->DoCmdNoReply(EAlfMeshVisualSetImage, buf );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::SetImage ignore error %d", err )
        }
    }
    
EXPORT_C const TAlfImage& CAlfMeshVisual::Image() const
    {
    return iMeshVisualData->iImage->Image();
    }

EXPORT_C void CAlfMeshVisual::SetSecondaryImage(const TAlfImage& aImage)
    {
    iMeshVisualData->iSecondaryImage->SetImage(aImage);// This texturizes skin graphics if needed
    
    TAlfImageParams params(iMeshVisualData->iSecondaryImage->Image());

    TPckgC<TAlfImageParams> buf(params);
    TInt err = Comms()->DoCmdNoReply(EAlfMeshVisualSetSecondaryImage, buf );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::SetSecondaryImage ignore error %d", err )
        }
    }
    
EXPORT_C const TAlfImage& CAlfMeshVisual::SecondaryImage() const
    {
    return iMeshVisualData->iSecondaryImage->Image();
    }

EXPORT_C void CAlfMeshVisual::SetSpecularImage(const TAlfImage& aImage)
    {
    // This functionality applies to procedural mesh only.
    if(Mesh().MeshType() == EAlfMeshTypeProcedural)
        {    
        CAlfProceduralMesh& mesh = static_cast<CAlfProceduralMesh&>(Mesh());
        iMeshVisualData->iSpecularImage->SetImage(aImage);// This texturizes skin graphics if needed
        
        TAlfImageParams params(iMeshVisualData->iSpecularImage->Image());

        TPckgC<TAlfImageParams> buf(params);
        TInt err = Comms()->DoCmdNoReply(EAlfMeshVisualSetSpecularImage, buf );
        
        if ( err )
            {
            __ALFLOGSTRING1( "CAlfMeshVisual::SetSpecularImage ignore error %d", err )
            }
            
        mesh.SetSpecularImage( iMeshVisualData->iSpecularImage->Image() );        
        }
    }
    
EXPORT_C const TAlfImage& CAlfMeshVisual::SpecularImage() const
    {
    return iMeshVisualData->iSpecularImage->Image();
    }

EXPORT_C CAlfMesh& CAlfMeshVisual::Mesh()
    {
    // Create a default mesh
    if ( !iMeshVisualData->iMesh )
        {
        TRAPD( err, CreateMeshL(EAlfMeshTypeProcedural) );
        if ( err )
            {
            __ALFLOGSTRING1( "CAlfMeshVisual::Mesh panic error %d", err )
            USER_INVARIANT();
            }
        }
    return *iMeshVisualData->iMesh;
    }
    
EXPORT_C CAlfProceduralMesh* CAlfMeshVisual::ProceduralMesh() const
    {
    if(iMeshVisualData->iMesh && (iMeshVisualData->iMesh->MeshType() == EAlfMeshTypeProcedural))
        {
        return static_cast<CAlfProceduralMesh*>(iMeshVisualData->iMesh);
        }    
    return NULL;
    }

EXPORT_C CAlfM3GMesh* CAlfMeshVisual::M3GMesh() const
    {
    if(iMeshVisualData->iMesh && (iMeshVisualData->iMesh->MeshType() == EAlfMeshTypeM3G))
        {
        return static_cast<CAlfM3GMesh*>(iMeshVisualData->iMesh);
        }    
    return NULL;    
    }
    
EXPORT_C TAlfTimedValue CAlfMeshVisual::SecondaryAlpha() const
    {
    TAlfTimedValue result;
    TPckg<TAlfTimedValue> buf(result);
    TInt err = Comms()->DoSynchronousCmd( EAlfMeshVisualSecondaryAlpha, KNullDesC8, buf);
    
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::SecondaryAlpha panic error %d", err )
        USER_INVARIANT();
        }
    
    return result;  
    }
    
EXPORT_C void CAlfMeshVisual::SetSecondaryAlpha( const TAlfTimedValue& aSecondaryAlpha )
    {
    TPckgC<TAlfTimedValue> buf(aSecondaryAlpha);

    TInt err = Comms()->DoCmdNoReply( EAlfMeshVisualSetSecondaryAlpha, buf );
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::SetSecondaryAlpha panic error %d", err )
        USER_INVARIANT();
        }
    }
    
    
EXPORT_C TAlfTimedValue CAlfMeshVisual::YawAngle() const
    {
    TAlfTimedValue result;
    TPckg<TAlfTimedValue> buf(result);
    TInt err = Comms()->DoSynchronousCmd( EAlfMeshVisualYawAngle, KNullDesC8, buf);
    
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::YawAngle panic error %d", err )
        USER_INVARIANT();
        }
    
    return result;  
    }
    
EXPORT_C void CAlfMeshVisual::SetYawAngle( const TAlfTimedValue& aYawAngle )
    {
    TPckgC<TAlfTimedValue> buf(aYawAngle);
    
    TInt err = Comms()->DoCmdNoReply( EAlfMeshVisualSetYawAngle, buf );
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::SetYawAngle panic error %d", err )
        USER_INVARIANT();
        }
    }
    
    
EXPORT_C TAlfTimedValue CAlfMeshVisual::PitchAngle() const
    {
    TAlfTimedValue result;
    TPckg<TAlfTimedValue> buf(result);
    TInt err = Comms()->DoSynchronousCmd( EAlfMeshVisualPitchAngle, KNullDesC8, buf);
    
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::PitchAngle panic error %d", err )
        USER_INVARIANT();
        }
    
    return result; 
    }
    
EXPORT_C void CAlfMeshVisual::SetPitchAngle( const TAlfTimedValue& aPitchAngle )
    {
    TPckgC<TAlfTimedValue> buf(aPitchAngle);

    TInt err = Comms()->DoCmdNoReply( EAlfMeshVisualSetPitchAngle, buf );
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::SetPitchAngle panic error %d", err )
        USER_INVARIANT();
        }
    }
    
    
EXPORT_C TAlfTimedValue CAlfMeshVisual::Scale() const
    {
    TAlfTimedValue result;
    TPckg<TAlfTimedValue> buf(result);
    TInt err = Comms()->DoSynchronousCmd( EAlfMeshVisualScale, KNullDesC8, buf);
    
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::Scale panic error %d", err )
        USER_INVARIANT();
        }
    
    return result; 
    }
    
EXPORT_C void CAlfMeshVisual::SetScale( const TAlfTimedValue& aScale )
    {
    TPckgC<TAlfTimedValue> buf(aScale);

    TInt err = Comms()->DoCmdNoReply( EAlfMeshVisualSetScale, buf );
    if (err)
        {
        __ALFLOGSTRING1( "CAlfMeshVisual::SetScale panic error %d", err )
        USER_INVARIANT();
        }
    }

// ---------------------------------------------------------------------------
// Place holder from CAlfVisual
// ---------------------------------------------------------------------------
//     
EXPORT_C void CAlfMeshVisual::RemoveAndDestroyAllD()
    {
    CAlfVisual::RemoveAndDestroyAllD();
    }
  
// ---------------------------------------------------------------------------
// Place holder from CAlfVisual
// ---------------------------------------------------------------------------
//  
EXPORT_C void CAlfMeshVisual::UpdateChildrenLayout(TInt aTransitionTime )
    {
    CAlfVisual::UpdateChildrenLayout( aTransitionTime );
    }
  
// ---------------------------------------------------------------------------
// Place holder from CAlfVisual
// ---------------------------------------------------------------------------
//  
EXPORT_C CAlfVisual* CAlfMeshVisual::FindTag(const TDesC8& aTag)
    {
    return CAlfVisual::FindTag( aTag );
    }

// ---------------------------------------------------------------------------
// Place holder from CAlfVisual
// ---------------------------------------------------------------------------
//  
EXPORT_C void CAlfMeshVisual::DoRemoveAndDestroyAllD()
    {
    CAlfVisual::DoRemoveAndDestroyAllD();
    }
    
// ---------------------------------------------------------------------------
//  future proofing  
// ---------------------------------------------------------------------------
//  
EXPORT_C void CAlfMeshVisual::PropertyOwnerExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
    {
    CAlfVisual::PropertyOwnerExtension(aExtensionUid,aExtensionParams);
    }