/*

* Copyright (c) 2007-2008 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:  Utility class for widgets visualization in terms of LCT data

*

*/

#ifndef MULVISUALUTILITY_H_

#define MULVISUALUTILITY_H_

#include <alf/alflayout.h>

#include <osn/ustring.h>

// Avkon Includes

#include <aknlayout2hierarchy.h>

#include <AknUtils.h>

#include <AknsConstants.h>

// OpenC Includes

#include <libc/string.h>

#include <libc/stdlib.h>

#include <vector>

using namespace osncore;

namespace Alf

	{

enum TMulCurrentOrientation

    {

    EMulPortrait,

    EMulLandScape

    };	

/**

 * Different visual types

 */

enum TMulLCTVisualType

    {

    EVisualImage = 0,

    EVisualText

    };

/**

 * Different attribute types

 */    

enum TMulCustomAttributeType

    {

    EAttributeNone,

    EAttributeCategory,

    EAttributeOpacity,

    EAttributeStyle,

    EAttributeFontthemecolor,

    EAttributeHAlign,

    EAttributeVAlign

    };

/**

 * Different Category types

 */    

enum TMulAttributeCategoryType

    {

    ECategoryInvalid,

    ECategoryData,

    ECategoryStaticData

    };

/**

 * Co-ordinate data

 */    

struct LCTData

	{

	    int mPosX;

	    int mPosY;

	    int mWidth;

	    int mHeight;

	    int mFontId;

	};

/**

 * LCT Id and variety

 */	

struct LCTPair

    {

    UString mLctId;

    int mVariety;

    };

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

// Class to hold  attributes name and value

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

//

class CustomAttributeStructure 

    {

public:

   /**

	* Constructor

	*

	* @param aName				Name of the Attribute

	* @param aTargetVal			Value the Attribute

	* @param aAttributeType		Name of the Attribute

	* @param aCategoryType		Name of the Attribute

	*

	*

	*/

    CustomAttributeStructure(const UString& aName, const UString& aTargetVal,

        TMulCustomAttributeType aAttributeType = EAttributeNone, 

        TMulAttributeCategoryType aCategoryType = ECategoryInvalid): 

            mName(aName),

            mTargetVal(aTargetVal),

            mAttributeType(aAttributeType), 

            mCategoryType(aCategoryType)

             {

             mLctPair.mLctId = UString("");

             mLctPair.mVariety = -1;

             } 

   /**

	* Constructor

	*

	* @param aName				Name of the Attribute

	* @param aLctInfo			LCT information of the custom attribute

	* @param aAttributeType		Name of the Attribute

	* @param aCategoryType		Name of the Attribute

	*

	*

	*/

    CustomAttributeStructure(const UString& aName, const LCTPair& aLctInfo,

        TMulCustomAttributeType aAttributeType = EAttributeNone, 

        TMulAttributeCategoryType aCategoryType = ECategoryInvalid): 

            mName(aName),

            mTargetVal(""),

            mAttributeType(aAttributeType), 

            mCategoryType(aCategoryType)

             {

             mLctPair.mLctId = aLctInfo.mLctId;

             mLctPair.mVariety = aLctInfo.mVariety;

             }   

   /**

	* Sets the name of the custom attribute

	*

	* @param aName	Name of the custom attribute

	* @return nothing

	*

	*/         

    void SetName(const UString& aName) {mName = aName;}

   /**

	* Sets the value the custom attribute

	*

	* @param aTarget	Value of the custom attribute

	* @return nothing

	*

	*/ 

    void SetTargetValue(const UString& aTarget) {mTargetVal = aTarget; }

   /**

	* Get the name of attribute

	*

	* 

	* @return Name of the attribute

	*

	*/

    const UString GetName() const {return mName; } 

   /**

	* Get the value of the attribute

	*

	* 

	* @return Value of the attribute

	*

	*/

    const UString GetTargetvalue() const {return mTargetVal;} 

   /**

	* Sets the attribute type the custom attribute

	*

	* @param aAttributeType		Attribute type of the custom attribute

	* @return nothing

	*

	*/ 

    void SetAttributeType(TMulCustomAttributeType aAttributeType) {mAttributeType = aAttributeType;}

   /**

	* Sets the Category type the custom attribute

	*

	* @param aCategoryType		Category type of the custom attribute

	* @return nothing

	*

	*/

    void SetCategoryType(TMulAttributeCategoryType aCategoryType) {mCategoryType = aCategoryType;} 

   /**

	* Get the attribute type of the attribute

	*

	* 

	* @return TMulCustomAttributeType

	*

	*/  

    TMulCustomAttributeType AttributeType() const {return mAttributeType;}

   /**

	* Get the category type of the attribute

	*

	* 

	* @return TMulAttributeCategoryType

	*

	*/ 

    TMulAttributeCategoryType CategoryType()const {return mCategoryType;}

   /**

	* Get the LCT information of attribute

	*

	* 

	* @return LCTPair

	*

	*/ 

    const LCTPair& GetLctPair() 

    {

    return mLctPair;

    }

private: 

   /**

	* Attribute name

	*/

    UString mName;

   /**

	* Attribute value

	*/

    UString mTargetVal;

   /**

	* Attribute type

	*/

    TMulCustomAttributeType mAttributeType;

   /**

	* Attribute  Category type

	*/

    TMulAttributeCategoryType mCategoryType;    

   /**

	* LCT Id and variety

	*/

    LCTPair mLctPair;

    };

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

// Class to hold a visual's attributes

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

//

class LCTVisualStructure

    {

public:

   /**

	* Default Constructor

	*

	*/

    LCTVisualStructure()

    {

    }    

   /**

	* Destructor

	*

	*/

    ~LCTVisualStructure()

    {

    for(int i =0; i < mAttributeStructure.size(); i++)

        {

        delete mAttributeStructure[i];

        }

    mAttributeStructure.clear();

    } 

   /**

	* Sets the LCT Id of the visual Structure (part of LCT information of Visual Structure)

	*

	* @param aId	LCT Id of Visual Structure

	* @return nothing

	*

	*/

    void SetLCTId(const UString& aId) {mLctPair.mLctId = aId;}

   /**

	* Sets the Variety Id of the visual Structure (part of LCT information of Visual Structure)

	*

	* @param aId	Variety Id of Visual Structure

	* @return nothing

	*

	*/

    void SetVarietyId(int aId) {mLctPair.mVariety = aId;}

   /**

	* Gets the LCT Id of the visual Structure (part of LCT information of Visual Structure)

	*

	* @return nothing

	*

	*/

    const UString GetLCTId() const {return mLctPair.mLctId; } 

   /**

	* Gets the Variety Id of the visual Structure (part of LCT information of Visual Structure)

	*

	* @return nothing

	*

	*/

    const int GetVarietyId() const {return mLctPair.mVariety;}

   /**

	* Sets the type of visual this structure contains (can be either image/text)

	*

	* @param aVisualType	EVisualImage/EVisualText

	* @return nothing

	*

	*/

    void SetVisualType(const TMulLCTVisualType aVisualType) {mVisualType = aVisualType; }

   /**

	* Gets the visual type of the visual Structure 

	*

	* @return TMulLCTVisualType

	*

	*/

    TMulLCTVisualType VisualType()const { return mVisualType;} 

   /**

	* Adds a Custom attribute structure to this visual structure

	*

	* @param	aAttr	Custom Attribute structure to be added

	*					

	*

	*/    

    void AddAttribute(CustomAttributeStructure* aAttr)

    {

    if(aAttr)

        mAttributeStructure.push_back(aAttr);

    }

   /**

	* Gets a Custom attribute structure at a specified index in this visual structure

	*

	* @param	aIndex	Index at which the attribute struct desired

	* @return   CustomAttributeStructure, NULL if no attribute is found

	*

	*/ 

    const CustomAttributeStructure* GetAttribute(int aIndex) const

    {

    if(aIndex >=0 && aIndex < mAttributeStructure.size())

        return mAttributeStructure[aIndex];

    else

        return NULL;

    }

   /**

	* Gets a Custom attribute structure by name in this visual structure

	*

	* @param	aAttrName	Name of the attribute struct desired

	* @return   CustomAttributeStructure, NULL if no attribute is found

	*					

	*

	*/  

    const CustomAttributeStructure* GetAttributeByName(const UString& aAttrName) const

    {

    for (vector<CustomAttributeStructure*>::const_iterator it = mAttributeStructure.begin(); 

            it!=mAttributeStructure.end(); ++it) 

    	{

    	if(!strcmp(((*it)->GetName()).getUtf8(),aAttrName.getUtf8()))

    		return *it;

    	} 

    return NULL;        

    } 

   /**

	* Gets the current attribute count

	*

	* @return total number of attributes

	*

	*/

    int AttributeCount() const

    {

    return mAttributeStructure.size();

    }

   /**

	* Sets the Id of the visual Structure 

	*

	* @param aId	Identifier of Visual Structure

	* @return nothing

	*

	*/

    void SetId(const UString& aId) {mId = aId;}

   /**

	* Gets the Id of the visual Structure 

	*

	* @return Identifier of the visual structure

	*

	*/   

    UString GetId() const { return mId; }

    void SetPositions(int x,int y)

	    {

	    mX = x;

	    mY = y;

	    }

    void SetDimensions(int width,int height)

	    {

	    mW = width;

	    mH = height;

	    }  

    int PositionX() const {return mX;}

    int PositionY() const {return mY;}

    int Width() const {return mW;}

    int Height() const {return mH;}

   /**

	* Gets the LCT Information of the visual Structure 

	*

	* @return LCTPair 

	*

	*/   

    const LCTPair& GetLctPair() 

    {

    return mLctPair;

    }

private:

   /**

	* Class to hold  attributes name and value

	*

	*/

    UString mId;

	/**

	 * LCT Id and variety

	 */ 

    LCTPair mLctPair;   

	/**

 	 * Type of Visual

     */

    TMulLCTVisualType mVisualType;

    /**

	* Array of attribute structures (owned)

	*

	*/

    std::vector<CustomAttributeStructure*> mAttributeStructure;

    int mX,mY,mW,mH;

    };

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

// Custom data type to hold information about different visuals

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

//

class LCTElementStructure

    {

public:

   /**

	* Destructor

	*

	*/

    ~LCTElementStructure()

    {

    for(int i =0; i < mVS.size(); ++i)

        {

        delete mVS[i];            

        }

    mVS.clear(); 

    }

   /**

	* Adds a Visual structure to this Element structure

	*

	* @param	aVStructure		VisualStructure to be added

	* @return 	nothing				

	*

	*/  

    void AddVisualStructure(LCTVisualStructure* aVStructure)

    {

    if(aVStructure)

    mVS.push_back(aVStructure);

    }   

   /**

	* Gets a Visual structure at a specified index in this visual structure

	*

	* @param	aIndex	Index at which the attribute struct desired

	* @return   LCTVisualStructure, NULL if no structure is found

	*

	*/    

    const LCTVisualStructure* GetVisualStruture(int aIndex)

    {

    if(aIndex >=0 && aIndex < mVS.size())

        return mVS[aIndex];

    else

        return NULL;

    }

    /**

	* Gets a Visual structure with specified name

	*

	* @param	aVisualName	name of the  visual structure

	* @return   LCTVisualStructure, NULL if no structure is found

	*

	*/