/*

* 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:   Line visual

*

*/

#ifndef C_ALFLINEVISUAL_H

#define C_ALFLINEVISUAL_H

#include <alf/alfvisual.h>

#include <alf/alfownership.h>

class CAlfControl;

class CAlfLayout;

class CAlfCurvePath;

class MAlfMappingFunction;

class TAlfImage;

class TRgb;

/**

 * Line visual draws a line along a curve path.

 *

 * A line visual will draw a bendy line that follows a specified

 * curve path. Width and alpha functions can be set to change the

 * opacity and thickness of the line along its length.

 *

 * Note that the Bitgdi renderer contains only a minimal implementation

 * of line drawing. There is no aliasing or shading on the line, and

 * thickness and alpha functions have no effect. The entire thickness of a Bitgdi

 * line is set by the initial thickness at point 0.

 * Usage:

 * 

 * @code

 * 

 * //Create curvepath, which can be used as a path for linevisual

 * CAlfCurvePath* path = CAlfCurvePath::NewL( &iEnv );

 * path->AppendArcL( TPoint(120, 120), TSize(60, 60), 180, 180 + 270, 0.5 );

 * path->AppendLineL( TPoint(120, 180), TPoint(20, 180), 0.5 );

 * 

 * //Create linevisual

 * CAlfLineVisual* line = CAlfLineVisual::AddNewL( control );

 * //set curvepath instance, with ownership transfered to visual

 * line->SetPath( path, EAlfHasOwnership );

 * 

 * //Line opacity function. Line visuals can use a mapping function to determine the opacity

 * //of the line along the path. 

 * //member variable : LinearMappingFunction linearFunc;

 * linearFunc.SetFactor( 1 );

 * //setlinevisual alpha function

 * line->SetAlphaFunction( &linearFunc );

 * 

 * //Similerly, line visuals can use a mapping function to determine the width of the

 * //line along the path. 

 * linearFunc.SetFactor( 60 );

 * line->SetWidthFunction( &linearFunc ); * 

 * 

 * @endcode

 * 

 * @lib alfclient.lib

 * @since S60 v3.2

 * @see CAlfCurvePath

 */

class CAlfLineVisual : public CAlfVisual

    {

public:

    /**

     * Constructor, which gives ownership to the control.

     *

     * @param aOwnerControl The control

     * @param aParentLayout If given, the parent layout.

     * @return New instance. Ownership NOT transreffed (owned by control)

     */

    IMPORT_C static CAlfLineVisual* AddNewL(CAlfControl& aOwnerControl,

                                            CAlfLayout* aParentLayout = 0);

    /**

     * Constructor.

     */

    IMPORT_C CAlfLineVisual();

    /**

     * Second-phase constructor.

     */

    IMPORT_C void ConstructL(CAlfControl& aOwner);

    /**

     * Destructor.

     */

    IMPORT_C virtual ~CAlfLineVisual();

    /**

     * Sets the path instance of the visual.

     *

     * @param aPath

     * @param aOwnership

     */

    IMPORT_C void SetPath(CAlfCurvePath* aPath, TAlfOwnership aOwnership);

    /**

     * Returns the path of the visual. The path can be modified via this

     * reference.

     *

     * @return Path. NULL if not set.

     */

    IMPORT_C CAlfCurvePath* Path();

    /**

     * Sets the image used by the line.

     */

    IMPORT_C void SetImage(const TAlfImage& aImage);

    /**

     * Returns the image used by the line.

     */

    IMPORT_C const TAlfImage& Image() const;

    /**

     * Sets the alpha mapping function that generates alpha values for the

     * path.

     */

    IMPORT_C void SetAlphaFunction(MAlfMappingFunction* aFunction);

    /**

     * Sets the width mapping function that generates width values for the

     * path.

     */

    IMPORT_C void SetWidthFunction(MAlfMappingFunction* aFunction);

    /** 

     * Thickness of the line. 

     */

    IMPORT_C const TAlfTimedValue& Thickness() const;

    IMPORT_C void SetThickness( const TAlfTimedValue& aThickness );

    /** 

     * Thickness of the shadow around the line. 

     */

    IMPORT_C const TAlfTimedValue& ShadowThickness() const;

    IMPORT_C void SetShadowThickness( const TAlfTimedValue& aShadowThickness );

    /** 

     * Current start position on the path. 

     */

    IMPORT_C const TAlfTimedValue& StartPos() const;

    IMPORT_C void SetStartPos( const TAlfTimedValue& aStartPos );

    /** 

     * Current end position on the path.

     */

    IMPORT_C const TAlfTimedValue& EndPos() const;

    IMPORT_C void SetEndPos( const TAlfTimedValue& aEndPos );

    /**

     * Sets the color of the line.

     */

    IMPORT_C void SetColor(const TRgb& aColor);

    /**

     * From CAlfVisual

     * @see CAlfVisual

     */

    IMPORT_C void RemoveAndDestroyAllD();

    IMPORT_C void UpdateChildrenLayout(TInt aTransitionTime = 0);

    IMPORT_C CAlfVisual* FindTag(const TDesC8& aTag);

protected:

    /**

     * From CAlfVisual

     * @see CAlfVisual

     */

    IMPORT_C void DoRemoveAndDestroyAllD();

    IMPORT_C void PropertyOwnerExtension(const TUid& aExtensionUid, TAny** aExtensionParams);

private: // data

    struct TLineVisualPrivateData;

    TLineVisualPrivateData* iLineVisualData;

    };

#endif // C_ALFLINEVISUAL_H