// Implementation file for the definition of a characteristic type
/////////////////////////////////////////////////////////////////////
#include "StdAfx.h"

#include "Data\CTL_DatB.hpp"

#include "WControls\CTL_WCkB.hpp"

//External Modules
#include "CTL_ErO.hpp"
//End of External Modules

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define C_szTrueString	"True"
#define C_szFalseString	"False"

//Constructors / Destructor
//**************************************************************************************
CTL_Editor_BooleanData::CTL_Editor_BooleanData(CString csScriptName,
																							 CTL_Editor_DataList *_pclParentList,
																							 CTL_Editor_Data *pclCurrentBaseData /*= NULL*/)
												: CTL_Editor_Data(CTL_DATA_TYPE__BOOLEAN,
																					csScriptName,
																					_pclParentList,
																					pclCurrentBaseData)
{
	m_bISBitFieldCoded = FALSE;
}

//**************************************************************************************
CTL_Editor_BooleanData::CTL_Editor_BooleanData(tdBitFieldCoder tdMask,
																							 CString csScriptName,
																							 CTL_Editor_DataList *_pclParentList,
																							 CTL_Editor_Data *pclCurrentBaseData /*= NULL*/)
										: CTL_Editor_Data(CTL_DATA_TYPE__BOOLEAN,
																			csScriptName,
																			_pclParentList,
																			pclCurrentBaseData)
{
	m_tdMask = tdMask;
	m_bISBitFieldCoded = TRUE;
}

//**************************************************************************************
CTL_Editor_BooleanData::~CTL_Editor_BooleanData()
{

}

//**************************************************************************************
//Function called to Init the data
void CTL_Editor_BooleanData::m_fn_vInitData()
{

}

//**************************************************************************************
//Function called to read associated motor's data
void CTL_Editor_BooleanData::m_fn_vGetMotorData()
{
	BOOL bMustReadData =	TRUE;
	if ( m_pro_td_p_fn_bDataMustBeRead != NULL )
		bMustReadData &=	m_pro_td_p_fn_bDataMustBeRead(this);

	if ( bMustReadData )
	{
		if(m_pub_fn_pvGetMotorData())
		{
			unsigned char ucValue = *((unsigned char *)m_pub_fn_pvGetMotorData());

			if ( m_bISBitFieldCoded )
  			m_bCurrentState = ( (ucValue & m_tdMask) != 0 );
			else
				m_bCurrentState = ( ucValue != 0 );
		}
	}
}

//**************************************************************************************
//Function called to update associated motor's data
void CTL_Editor_BooleanData::m_fn_vUpdateMotorData(CTL_tdeUpdateReason eReason,
																									 long _lUserDefinedReason /*= 0*/)
{
	BOOL bMustWriteData = TRUE;
	if ( m_pro_td_p_fn_bDataMustBeWritten != NULL )
		bMustWriteData &=	m_pro_td_p_fn_bDataMustBeWritten(this);

	if ( bMustWriteData )
	{
		unsigned char *p_ucValue = (unsigned char *)m_pub_fn_pvGetMotorData();
		
		if ( m_bISBitFieldCoded )
		{
			//Only available with a one bit long bitfield coded on a char !!
			unsigned char ucValue = *p_ucValue;
			if ( m_bCurrentState )
			{
				if ( (ucValue & m_tdMask) == 0 ) //If bit must be changed
				{	   
					ucValue = ucValue ^ m_tdMask;
					*p_ucValue = ucValue;
				}
			}
			else
			{
				if ( (ucValue & m_tdMask) != 0 ) //If bit must be changed
				{
					tdBitFieldCoder tdInverseMask = 0xFF - m_tdMask;
					unsigned char ucModifiedValue = ucValue & tdInverseMask;
					*p_ucValue = ucModifiedValue;
				}
			}
		}
		else
		{
			*p_ucValue = (m_bCurrentState ? 1 : 0);
		}
		
		//Special changes
		m_fn_vDataHasBeenChanged(eReason, _lUserDefinedReason);
	}
}

//************************************************************************
//Function called to update data with another one
void CTL_Editor_BooleanData::m_fn_vUpdateData(CTL_Editor_Data *pclSourceData,
																							CTL_tdeUpdateReason eReason,
																							long _lUserDefinedReason /*= 0*/)
{
	ERROR_ASSERT(pclSourceData->m_pub_fn_tdeGetDataType() == m_pub_fn_tdeGetDataType());

	m_bCurrentState = ((CTL_Editor_BooleanData *)pclSourceData)->m_bCurrentState;
	
	m_fn_vUpdateMotorData(eReason, _lUserDefinedReason);
}

//************************************************************************
//Function called to get a string representing the value of the data
CStringList *CTL_Editor_BooleanData::m_fn_pcslFormatDataValueString()
{
	m_csStringList.RemoveAll();

	CString csStringToReturn;
	csStringToReturn.Format("%s",(m_bCurrentState) ? C_szTrueString : C_szFalseString);
	m_csStringList.AddTail(csStringToReturn);

	return &m_csStringList;
}

//************************************************************************
//Function called to set the value of the data acoording to a string representing it
void CTL_Editor_BooleanData::m_fn_vSetValueWithString(CStringList *pcslValueStringList)
{
	ERROR_ASSERT(pcslValueStringList->GetCount() == 1);
	CString csValueString = pcslValueStringList->GetHead();
	
	if ( csValueString.CompareNoCase(CString(C_szTrueString)) == 0)
		m_bCurrentState = TRUE;
	else
		m_bCurrentState = FALSE;

	m_fn_vUpdateMotorData();
}

//************************************************************************
//Function called to look if data has been modified (by motor for example)
void CTL_Editor_BooleanData::m_fn_vLookIfDataHasBeenModified()
{
	m_fn_vGetMotorData();

	m_pub_fn_vSetDataHasChanged( m_bCurrentState != m_bOldState );

	if ( m_pub_fn_bGetDataHasChanged() )
		m_bOldState = m_bCurrentState;
}

//Undo
//************************************************************************
//Function called to save the current Value (for Undo)
void CTL_Editor_BooleanData::m_fn_vKeepCurrentValue()
{
	m_bKeepedValueForUndo = m_bCurrentState;
}
 
//************************************************************************
//Function called to validate Undo for the current change
void CTL_Editor_BooleanData::m_fn_vRegisterUndoAction()
{
/*	if ( m_bKeepedValueForUndo != m_bCurrentState )
	{
		EdActors_ActorBooleanDataModif *pclModif = new EdActors_ActorBooleanDataModif(this, 
																																									m_bKeepedValueForUndo,
																																									m_bCurrentState);
		m_pclParentActor->m_clUndoManager.AskFor(pclModif);
	}
*/
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method	: mfn_bEqualsModifiedDataOldValue 
// Date		: 98/06/24
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description	:
// Author		: Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification	: 
// Date			:
// By			:
//////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CTL_Editor_BooleanData::mfn_bEqualsModifiedDataOldValue (CTL_Editor_Data *pModifiedData)
{
	ASSERT (pModifiedData);

	ERROR_ASSERT(pModifiedData->m_pub_fn_tdeGetDataType() == m_pub_fn_tdeGetDataType());
	return m_bCurrentState == ((CTL_Editor_BooleanData *)pModifiedData)->m_bOldState;
}



