/*
* Copyright (c)  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:   ?Description
*
*/



#include "alf/alflinevisual.h"
#include "alf/alfcontrol.h"
#include "alf/alfimage.h"
#include "alf/alftexture.h"
#include "alf/alfcurvepath.h"
#include "alf/alfgencomponent.h"
#include "alf/alfmappingfunctions.h"
#include "alflogger.h"
#include "alf/alfconstants.h"
#include "alfskinnableimage.h"
#include "alf/alfenv.h"

#include <uiacceltk/HuiUtil.h>

struct CAlfLineVisual::TLineVisualPrivateData
    {
    TAlfTimedValue iThickness;
    TAlfTimedValue iShadowThickness;
    TAlfTimedValue iStartPos;
    TAlfTimedValue iEndPos;
    CAlfCurvePath* iPath;
    TAlfOwnership iOwnership;
    CAlfSkinnableImage* iImage;
    };

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

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

EXPORT_C CAlfLineVisual::CAlfLineVisual()
    {
    }

EXPORT_C void CAlfLineVisual::ConstructL(CAlfControl& aOwner)
    {
    CAlfVisual::ConstructL(aOwner);
    
    iLineVisualData = new (ELeave) TLineVisualPrivateData;
    
    iLineVisualData->iPath = NULL;
    iLineVisualData->iImage = NULL;
    
    iLineVisualData->iImage = new (ELeave) CAlfSkinnableImage(&aOwner.Env());
    }

EXPORT_C CAlfLineVisual::~CAlfLineVisual()
    {
    if ( iLineVisualData )
        {
        delete iLineVisualData->iImage;
        iLineVisualData->iImage = NULL;
        
        if ( iLineVisualData->iOwnership == EAlfHasOwnership )
            {
            delete iLineVisualData->iPath;
            }
        iLineVisualData->iPath = NULL;
        }
    delete iLineVisualData;
    iLineVisualData = NULL;
    }

EXPORT_C void CAlfLineVisual::SetPath(CAlfCurvePath* aPath, 
                                      TAlfOwnership aOwnership)
    {
    TInt curvePathHandle = 0;
    if ( aPath )
        {
        MAlfMappingFunction* mappingFunction = aPath;
        curvePathHandle = mappingFunction->MappingFunctionIdentifier();
        } 


    TInt2 params( curvePathHandle, aOwnership );
    TPckgC<TInt2> inBuf( params );

    TInt err = Comms()->DoCmdNoReply(EAlfLineVisualSetPath, inBuf );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfLineVisual::SetPath panic error %d", err )
        USER_INVARIANT();
        }
    
    // Destroy the old one if owned.
    if ( iLineVisualData->iOwnership == EAlfHasOwnership )
        {
        delete iLineVisualData->iPath;
        }
    
    iLineVisualData->iPath = aPath;
    iLineVisualData->iOwnership = aOwnership;
    }

EXPORT_C CAlfCurvePath* CAlfLineVisual::Path()
    {
    return iLineVisualData->iPath;
    }

EXPORT_C void CAlfLineVisual::SetImage(const TAlfImage& aImage)
    {
    iLineVisualData->iImage->SetImage(aImage);// This texturizes skin graphics if needed
    
    TAlfImageParams params(iLineVisualData->iImage->Image());

    TPckgC<TAlfImageParams> buf(params);

    TInt err = Comms()->DoCmdNoReply(EAlfLineVisualSetImage, buf );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfLineVisual::SetImage ignore error %d", err )
        }
    }
    
EXPORT_C const TAlfImage& CAlfLineVisual::Image() const
    {
    return iLineVisualData->iImage->Image();
    }

EXPORT_C void CAlfLineVisual::SetAlphaFunction(MAlfMappingFunction* aFunction)
    {
    TInt mappingFunctionHandle = 0;
    if ( aFunction )
        {
        mappingFunctionHandle = aFunction->MappingFunctionIdentifier();
        }
        
    TPckgC<TInt> inBuf( mappingFunctionHandle );
    
    TInt err = Comms()->DoCmdNoReply(EAlfLineVisualSetAlphaFunction, inBuf );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfLineVisual::SetAlphaFunction panic error %d", err )
        USER_INVARIANT();
        }
    }

EXPORT_C void CAlfLineVisual::SetWidthFunction(MAlfMappingFunction* aFunction)
    {
    TInt mappingFunctionHandle = 0;
    if ( aFunction )
        {
        mappingFunctionHandle = aFunction->MappingFunctionIdentifier();
        }
    TPckgC<TInt> inBuf( mappingFunctionHandle );
    
    TInt err =Comms()->DoCmdNoReply(EAlfLineVisualSetWidthFunction, inBuf );
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfLineVisual::SetWidthFunction panic error %d", err )
        USER_INVARIANT();
        }
    }

EXPORT_C const TAlfTimedValue& CAlfLineVisual::Thickness() const
    {
    TPckg<TAlfTimedValue> buf(iLineVisualData->iThickness);
    TInt err = Comms()->DoSynchronousCmd( EAlfLineVisualGetThickness, buf, buf);

    if ( err != KErrNone )
        {
        __ALFLOGSTRING1( "CAlfLineVisual::Thickness panic error %d", err )
        USER_INVARIANT();
        }
    
    return iLineVisualData->iThickness;
    }

EXPORT_C void CAlfLineVisual::SetThickness( const TAlfTimedValue& aThickness )
    {
    TPckgC<TAlfTimedValue> buf(aThickness);

    TInt err = Comms()->DoCmdNoReply( EAlfLineVisualSetThickness, buf );

    if ( err == KErrNone )
        {
        iLineVisualData->iThickness = aThickness;
        }
    else
        {
        __ALFLOGSTRING1( "CAlfLineVisual::SetThickness panic error %d", err )
        USER_INVARIANT();
        }
    }

EXPORT_C const TAlfTimedValue& CAlfLineVisual::ShadowThickness() const
    {
    TPckg<TAlfTimedValue> buf(iLineVisualData->iShadowThickness);
    TInt err = Comms()->DoSynchronousCmd( EAlfLineVisualGetShadowThickness, buf, buf);

    if ( err != KErrNone )
        {
        __ALFLOGSTRING1( "CAlfLineVisual::ShadowThickness panic error %d", err )
        USER_INVARIANT();
        }
    
    return iLineVisualData->iShadowThickness;
    }

EXPORT_C void CAlfLineVisual::SetShadowThickness( const TAlfTimedValue& aShadowThickness )
    {
    TPckgC<TAlfTimedValue> buf(aShadowThickness);
    
    TInt err = Comms()->DoCmdNoReply( EAlfLineVisualSetShadowThickness, buf );

    if ( err == KErrNone )
        {
        iLineVisualData->iShadowThickness = aShadowThickness;
        }
    else
        {
        __ALFLOGSTRING1( "CAlfLineVisual::SetShadowThickness panic error %d", err )
        USER_INVARIANT();
        }
    }

EXPORT_C const TAlfTimedValue& CAlfLineVisual::StartPos() const
    {
    TPckg<TAlfTimedValue> buf(iLineVisualData->iStartPos);
    TInt err = Comms()->DoSynchronousCmd( EAlfLineVisualGetStartPos, buf, buf);

    if ( err != KErrNone )
        {
        __ALFLOGSTRING1( "CAlfLineVisual::StartPos panic error %d", err )
        USER_INVARIANT();
        }
    
    return iLineVisualData->iStartPos;
    }

EXPORT_C void CAlfLineVisual::SetStartPos( const TAlfTimedValue& aStartPos )
    {
    TPckgC<TAlfTimedValue> buf(aStartPos);

    TInt err = Comms()->DoCmdNoReply( EAlfLineVisualSetStartPos, buf );

    if ( err == KErrNone )
        {
        iLineVisualData->iStartPos = aStartPos;
        }
    else
        {
        __ALFLOGSTRING1( "CAlfLineVisual::SetStartPos panic error %d", err )
        USER_INVARIANT();
        }
    }

EXPORT_C const TAlfTimedValue& CAlfLineVisual::EndPos() const
    {
    TPckg<TAlfTimedValue> buf(iLineVisualData->iEndPos);
    TInt err = Comms()->DoSynchronousCmd( EAlfLineVisualGetEndPos, buf, buf);

    if ( err != KErrNone )
        {
        __ALFLOGSTRING1( "CAlfLineVisual::EndPos panic error %d", err )
        USER_INVARIANT();
        }
    
    return iLineVisualData->iEndPos;
    }

EXPORT_C void CAlfLineVisual::SetEndPos( const TAlfTimedValue& aEndPos )
    {
    TPckgC<TAlfTimedValue> buf(aEndPos);

    TInt err = Comms()->DoCmdNoReply( EAlfLineVisualSetEndPos, buf );

    if ( err == KErrNone )
        {
        iLineVisualData->iEndPos = aEndPos;
        }
    else
        {
        __ALFLOGSTRING1( "CAlfLineVisual::SetEndPos panic error %d", err )
        USER_INVARIANT();
        }
    }

EXPORT_C void CAlfLineVisual::SetColor(const TRgb& aColor)
    {
    TPckgC<TRgb> buf(aColor);

    TInt err = Comms()->DoCmdNoReply(EAlfLineVisualSetColor, buf );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfLineVisual::SetColor ignore error %d", err )
        }
    }

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

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