/*
* 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:  Visual item class
*
*/


#include <mul/mulvisualitem.h>

#include <mul/imulvarianttype.h>
#include <mul/mulvarianttype.h>

#include <osn/ustring.h>
#include <stdexcept>

#include <e32math.h>	// for Pow function
#include "mul/mulmodelutility.h"

using namespace osncore;
using namespace std;

namespace Alf
    {
// ---------------------------------------------------------------------------
// Defination of class MulAttribute
// ---------------------------------------------------------------------------
//
class MulVisualItem::MulAttribute
    {
public: //Constructor and destructor

	/**
	 * C++ constructor.
	 */
	MulAttribute():mValue(NULL),mFlag(0)
		{
		}
		
	/**
	 * C++ constructor.
	 *
	 * @param aValue value of the attribute
	 * @param aAttributeFlags property of this attribute
	 */
	 MulAttribute( IMulVariantType* aValue, int aAttributeFlags = 0 )
	 	{
	 	mValue = aValue;
	 	mFlag = aAttributeFlags;
	 	}

	/**
	 * Copy constructor.
	 *
	 * @param aAttribute existing attribute
	 */
	MulAttribute( const MulAttribute& aAttribute )
	 	{
	 	mValue = aAttribute.mValue->Clone().release();
	 	mFlag = aAttribute.mFlag;
	 	}

	/**
	 * Destructor.
	 */
	~MulAttribute()
		{
		delete mValue;
		}	
	
public: //data
     
	IMulVariantType* mValue ; //own    
    int mFlag ; 
    
    };
    
// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVisualItem::MulVisualItem( )
	{				
	// Clearing dirty bit flags to 0;
	mBitAttrFlag1 = 0;
	mBitAttrFlag2 = 0;
	}

// ---------------------------------------------------------------------------
// Copy Constructor
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVisualItem::MulVisualItem( const MulVisualItem& aVisualItem )
	{	
	map<mulvisualitem::TVisualAttribute,MulAttribute*> mapToCopy = aVisualItem.mVisualItem;
	map<mulvisualitem::TVisualAttribute,MulAttribute*>::iterator itr;
	for( itr = mapToCopy.begin(); itr!= mapToCopy.end(); ++itr )
		{
		mVisualItem[itr->first] = new (EMM) MulAttribute( *itr->second );
		}
	mBitAttrFlag1 = aVisualItem.mBitAttrFlag1;
	mBitAttrFlag2 = aVisualItem.mBitAttrFlag2;
	}

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
OSN_EXPORT MulVisualItem::~MulVisualItem()
	{
	map<mulvisualitem::TVisualAttribute,MulAttribute* >::iterator itr;
	for( itr = mVisualItem.begin(); itr!= mVisualItem.end(); ++itr )
		{
		delete itr->second;
		itr->second = NULL;
		}
	mVisualItem.clear();
	}

// ---------------------------------------------------------------------------
// Add new attributes to visual item
// ---------------------------------------------------------------------------
//
//OSN_EXPORT void MulVisualItem::SetAttribute( mulvisualitem::TVisualAttribute aName, 
//											 const UString& aValue, int aAttributeFlags )
//	{
//	auto_ptr<MulVariantType> variantdata(new (EMM) MulVariantType( aValue ));
//	
//	SetAttribute( aName, variantdata.release(),aAttributeFlags,EDoesOwn);
//	}

// ---------------------------------------------------------------------------
// Add new attributes to visual item
// ---------------------------------------------------------------------------
//
OSN_EXPORT void MulVisualItem::SetAttribute( mulvisualitem::TVisualAttribute aName, 
                                             const TDesC& aValue, int aAttributeFlags )
    {
    auto_ptr<MulVariantType> variantdata(new (EMM) MulVariantType( aValue ));
    
    SetAttribute( aName, variantdata.release(),aAttributeFlags,EDoesOwn);
    }


// ---------------------------------------------------------------------------
// Add new attributes to visual item
// ---------------------------------------------------------------------------
//
OSN_EXPORT void MulVisualItem::SetAttribute( mulvisualitem::TVisualAttribute aName, 
											  int aValue,int aAttributeFlags )
	{	
	auto_ptr<MulVariantType> variantdata(new ( EMM ) MulVariantType( aValue ));
		
	SetAttribute(aName,variantdata.release(),aAttributeFlags,EDoesOwn);	
	}


// ---------------------------------------------------------------------------
// Add new attributes to visual item
// ---------------------------------------------------------------------------
//
OSN_EXPORT void MulVisualItem::SetAttribute( mulvisualitem::TVisualAttribute aName, IMulVariantType* aValue, 
		  									   int aAttributeFlags ,
		  									   TAttributeOwnership /*aAttributeOwership*/ )
	{
	map<mulvisualitem::TVisualAttribute,MulAttribute* >::iterator findIter = mVisualItem.find( aName );
	if( findIter != mVisualItem.end() )
		{
		delete findIter->second;
		findIter->second = NULL;
		mVisualItem.erase( aName );
		}
	mVisualItem[aName] = new (EMM) MulAttribute(aValue,aAttributeFlags );
	SetDirty(aName, true);
	}


// ---------------------------------------------------------------------------
// Is the input attribute dirty, to be queried before a redraw
// ---------------------------------------------------------------------------
//
OSN_EXPORT bool MulVisualItem::IsDirty(mulvisualitem::TVisualAttribute aAttr) const
{
	int i = (int)aAttr;
	TReal base  = 2.0;
	TReal r = 0.0;
	TReal val = 0.0;
	TInt err = KErrNone;

	// If mBitAttrflag is binary 101, AND'ing it with 100(attribute 3) will 
	// set 100 to return true for attribute 3 being dirty

	// if attribute index <18 check against mBitAttrFlag1, else check
	// against mBitAttrFlag2
	if(i < 18)
		{
		val = i;
		err = Math::Pow(r, base, val);
		if(KErrNone != err)
			return true;
			
		return mBitAttrFlag1 & (int)r;
		}
	else
		{
		val = (int)(mulvisualitem::KMul_n) - i;
		err = Math::Pow(r, base, val);
		if(KErrNone != err)
			return true;
		
		return mBitAttrFlag2 & (int)r;
		}
    
}
 

// ---------------------------------------------------------------------------
// Set the attribute as dirty in this Visual item based on input flag
// ---------------------------------------------------------------------------
//
void MulVisualItem::SetDirty(mulvisualitem::TVisualAttribute aAttr, bool aDirty)
{
	int i = (int)aAttr;
	TReal base  = 2.0;
	TReal r = 0.0;
	TReal val = i;
	TInt err = KErrNone;
	// If mBitAttrflag is binary 001, OR'ing it with 100(attribute 3) will 
	// set 101 to set bit for attribute 3 as 1 in dirty flag
	if(aDirty)
		{
		// if attribute index <18 operate on mBitAttrFlag1
		// else operate against mBitAttrFlag1
		if(i < 18)
			{ 
			err = Math::Pow(r,base,val);
			mBitAttrFlag1 |= (int)r;
			}
			else
			{
			err = Math::Pow(r,base,(TReal)((int)(mulvisualitem::KMul_n) - i));
			mBitAttrFlag2 |= (int)r;
			}
		}
	else
	{
		// if attribute index <18 operate on mBitAttrFlag1
		// else operate against mBitAttrFlag1
		if(i < 18)
		{
			err = Math::Pow(r,base,val);
			mBitAttrFlag1 &= ~(int)r;
		}
		else
		{
			err = Math::Pow(r, base,(TReal)((int)(mulvisualitem::KMul_n) - i));
			mBitAttrFlag2 &= ~(int)r;
		}
	}
	if(KErrNone != err)
		throw std::invalid_argument("Error setting dirty flag for attribute"); 
}


// ---------------------------------------------------------------------------
// ResetDirtyAttribute
// ---------------------------------------------------------------------------
//
void MulVisualItem::ResetDirtyAttribute(const MulVisualItem& aVisualItem)
{
	mBitAttrFlag1 = aVisualItem.mBitAttrFlag1;
	mBitAttrFlag2 = aVisualItem.mBitAttrFlag2;
}
// ---------------------------------------------------------------------------
// Attribute
// ---------------------------------------------------------------------------
//
OSN_EXPORT IMulVariantType* MulVisualItem::Attribute( mulvisualitem::TVisualAttribute aName ) const
	{
	map<mulvisualitem::TVisualAttribute,MulAttribute* >::const_iterator findIter = mVisualItem.find( aName );
	if( findIter != mVisualItem.end() )
		{		
		MulAttribute* attribute = findIter->second;
		IMulVariantType* attributeValue = attribute->mValue;
		return  attributeValue;
		}
	else
		{
		//throw std::invalid_argument("Invalid attribute name.");
		return NULL;
		}
	}

// ---------------------------------------------------------------------------
// AttributeAsInt
// ---------------------------------------------------------------------------
//
OSN_EXPORT int MulVisualItem::AttributeAsInt( mulvisualitem::TVisualAttribute aName ) const 
	{
	IMulVariantType* attributeValue = Attribute(aName);
	if( attributeValue ) 
	    {
	    return attributeValue->integer();
	    }
	throw std::invalid_argument("Invalid attribute name."); 
	}

// ---------------------------------------------------------------------------
// AttributeAsString
// ---------------------------------------------------------------------------
//
OSN_EXPORT const TDesC& MulVisualItem::AttributeAsString( mulvisualitem::TVisualAttribute aName ) const
	{
	IMulVariantType* attributeValue = Attribute(aName);
    if( attributeValue ) 
        {
        return attributeValue->DesC();
        }
	throw std::invalid_argument("Invalid attribute name."); 
	}

// ---------------------------------------------------------------------------
// ExistingAttributes
// ---------------------------------------------------------------------------
//
OSN_EXPORT const std::vector<mulvisualitem::TVisualAttribute> MulVisualItem::Attributes() const 
	{
	map<mulvisualitem::TVisualAttribute,MulAttribute* >::const_iterator itr;
	std::vector<mulvisualitem::TVisualAttribute> attributesName;
	for( itr = mVisualItem.begin(); itr!= mVisualItem.end(); ++itr )
		{
		attributesName.push_back( itr->first );
		}
	return attributesName;
	}

// ---------------------------------------------------------------------------
// Flag
// ---------------------------------------------------------------------------
//
int MulVisualItem::Flag( mulvisualitem::TVisualAttribute aName ) 
    {
     MulAttribute* attribute = mVisualItem.find( aName )->second;
     return attribute->mFlag;
    }

// ---------------------------------------------------------------------------
// RemoveAttribute
// ---------------------------------------------------------------------------
//
void MulVisualItem::RemoveAttribute( mulvisualitem::TVisualAttribute aName )
    {
    map<mulvisualitem::TVisualAttribute,MulAttribute* >::iterator findIter = mVisualItem.find( aName );
    if( findIter != mVisualItem.end() )
		{
		delete findIter->second;
		findIter->second = NULL;
		mVisualItem.erase( aName );
		}
    }

    }// namespace Alf	

//End of file