/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : WWSaveLoad                                                   *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/wwsaveload/parameter.cpp                     $*
 *                                                                                             *
 *                       Author:: Patrick Smith                                                *
 *                                                                                             *
 *                     $Modtime:: 7/16/01 11:18a                                              $*
 *                                                                                             *
 *                    $Revision:: 32                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#include "parameter.h"
#include "parametertypes.h"
#include "simpleparameter.h"
#include "wwstring.h"
#include "definitionclassids.h"


/////////////////////////////////////////////////////////////////////
//
// Construct
//
//	This is a virtual constructor that is capable of creating a new
// instance of any type of parameter used in the Editable system.
//
/////////////////////////////////////////////////////////////////////
ParameterClass *
ParameterClass::Construct (Type type, void *data, const char *name)
{
	ParameterClass *new_param = NULL;
	switch (type) {
		
		case TYPE_INT:
			new_param = new IntParameterClass (data, name);
			break;

		case TYPE_FLOAT:
			new_param = new FloatParameterClass (data, name);
			break;

		case TYPE_VECTOR2:
			new_param = new Vector2ParameterClass (data, name);
			break;

		case TYPE_VECTOR3:
			new_param = new Vector3ParameterClass (data, name);
			break;

		case TYPE_RECT:
			new_param = new RectParameterClass (data, name);
			break;

		case TYPE_COLOR:
			new_param = new ColorParameterClass (data, name);
			break;

		case TYPE_MATRIX3D:
			new_param = new Matrix3DParameterClass (data, name);
			break;

		case TYPE_BOOL:
			new_param = new BoolParameterClass (data, name);
			break;

		case TYPE_STRINGSDB_ID:
			new_param = new StringsDBEntryParameterClass (data, name);
			break;

		case TYPE_ANGLE:
			new_param = new AngleParameterClass (data, name);
			break;

		case TYPE_STRING:
			new_param = new StringParameterClass ((StringClass *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_FILENAME:
			new_param = new FilenameParameterClass ((StringClass *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_SOUND_FILENAME:
			new_param = new SoundFilenameParameterClass ((StringClass *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_ENUM:
			new_param = new EnumParameterClass ((int *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_GENERICDEFINITIONID:
			new_param = new GenericDefParameterClass ((int *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_GAMEOBJDEFINITIONID:
			new_param = new GameObjDefParameterClass ((int *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_WEAPONOBJDEFINITIONID:
			new_param = new WeaponObjDefParameterClass ((int *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_AMMOOBJDEFINITIONID:
			new_param = new AmmoObjDefParameterClass ((int *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_EXPLOSIONDEFINITIONID:
			new_param = new ExplosionObjDefParameterClass ((int *)data);
			new_param->Set_Name (name);
			break;		

		case TYPE_SOUNDDEFINITIONID:
			new_param = new SoundDefParameterClass ((int *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_MODELDEFINITIONID:
			new_param = new ModelDefParameterClass ((int *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_PHYSDEFINITIONID:
			new_param = new PhysDefParameterClass ((int *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_DEFINITIONIDLIST:
			new_param = new DefIDListParameterClass ((DynamicVectorClass<int> *)data);
			new_param->Set_Name (name);
			((DefIDListParameterClass *)new_param)->Set_Class_ID (CLASSID_GAME_OBJECTS);
			break;

		case TYPE_ZONE:
			new_param = new ZoneParameterClass ((OBBoxClass  *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_FILENAMELIST:
			new_param = new FilenameListParameterClass ((DynamicVectorClass<StringClass> *)data);
			new_param->Set_Name (name);
			break;

		case TYPE_SEPARATOR:
			new_param = new SeparatorParameterClass;
			new_param->Set_Name (name);
			break;
	}

	return new_param;
}

//*******************************************************************************************//
//
//	Start of StringParameterClass
//
//*******************************************************************************************//

/////////////////////////////////////////////////////////////////////
//
//	StringParameterClass
//
/////////////////////////////////////////////////////////////////////
StringParameterClass::StringParameterClass (StringClass *string)
	:	m_String (string)
{	
	return ;
}

/////////////////////////////////////////////////////////////////////
//
//	StringParameterClass
//
/////////////////////////////////////////////////////////////////////
StringParameterClass::StringParameterClass (const StringParameterClass &src)
	:	m_String (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const StringParameterClass &
StringParameterClass::operator= (const StringParameterClass &src)
{
	m_String = src.m_String;
	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
StringParameterClass::operator== (const StringParameterClass &src)
{
	bool retval = false;

	if (m_String != NULL && src.m_String != NULL &&
		 (m_String->Compare (*(src.m_String)) == 0)) {
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
StringParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = StringParameterClass::operator== ((const StringParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
StringParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_STRING)) {
		(*m_String) = ((StringParameterClass &)src).Get_String ();
	}

	ParameterClass::Copy_Value (src);
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	Get_String
//
/////////////////////////////////////////////////////////////////////
const char *
StringParameterClass::Get_String (void) const
{
	const char * string = NULL;
	if (m_String != NULL) {
		string = (*m_String);
	}
	return string;
}


/////////////////////////////////////////////////////////////////////
//
//	Set_String
//
/////////////////////////////////////////////////////////////////////
void
StringParameterClass::Set_String (const char * string)
{
	if (m_String != NULL) {
		Set_Modified ();
		(*m_String) = string;
	}

	return ;
}


//*******************************************************************************************//
//
//	Start of FilenameParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	FilenameParameterClass
//
/////////////////////////////////////////////////////////////////////
FilenameParameterClass::FilenameParameterClass (StringClass *string)
	:	StringParameterClass (string)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	FilenameParameterClass
//
/////////////////////////////////////////////////////////////////////
FilenameParameterClass::FilenameParameterClass (const FilenameParameterClass &src)
	:	StringParameterClass (src)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const FilenameParameterClass &
FilenameParameterClass::operator= (const FilenameParameterClass &src)
{
	StringParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
FilenameParameterClass::operator== (const FilenameParameterClass &src)
{
	return StringParameterClass::operator== (src);
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
FilenameParameterClass::operator== (const ParameterClass &src)
{
	return StringParameterClass::operator== (src);
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
FilenameParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_FILENAME)) {
		Set_String (((FilenameParameterClass &)src).Get_String ());
	}

	StringParameterClass::Copy_Value (src);
	return ;
}



//*******************************************************************************************//
//
//	Start of SoundFilenameParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	SoundFilenameParameterClass
//
/////////////////////////////////////////////////////////////////////
SoundFilenameParameterClass::SoundFilenameParameterClass (StringClass *string)
	:	FilenameParameterClass (string)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	SoundFilenameParameterClass
//
/////////////////////////////////////////////////////////////////////
SoundFilenameParameterClass::SoundFilenameParameterClass (const SoundFilenameParameterClass &src)
	:	FilenameParameterClass (src)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const SoundFilenameParameterClass &
SoundFilenameParameterClass::operator= (const SoundFilenameParameterClass &src)
{
	FilenameParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
SoundFilenameParameterClass::operator== (const SoundFilenameParameterClass &src)
{
	return FilenameParameterClass::operator== (src);
}



//*******************************************************************************************//
//
//	Start of EnumParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	EnumParameterClass
//
/////////////////////////////////////////////////////////////////////
EnumParameterClass::EnumParameterClass (int *value)
	:	m_Value (value)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	EnumParameterClass
//
/////////////////////////////////////////////////////////////////////
EnumParameterClass::EnumParameterClass (const EnumParameterClass &src)
	:	m_Value (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const EnumParameterClass &
EnumParameterClass::operator= (const EnumParameterClass &src)
{
	m_List.Delete_All ();

	m_Value	= src.m_Value;
	m_List	= src.m_List;
	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
EnumParameterClass::operator== (const EnumParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
EnumParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = EnumParameterClass::operator== ((const EnumParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
EnumParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_ENUM)) {
		(*m_Value) = ((EnumParameterClass &)src).Get_Selected_Value ();
	}

	ParameterClass::Copy_Value (src);
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	Add_Value
//
/////////////////////////////////////////////////////////////////////
void
EnumParameterClass::Add_Value (const char *display_name, int value)
{
	m_List.Add (ENUM_VALUE(display_name, value));
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	Add_Value
//
/////////////////////////////////////////////////////////////////////
void __cdecl 
EnumParameterClass::Add_Values (const char *first_name, int first_value, ...)
{
	m_List.Add (ENUM_VALUE(first_name, first_value));

	va_list arg_list;
	va_start (arg_list, first_value);

	//
	//	Add all the params on the stack (until we found
	// the terminator)
	//
	bool more_params = true;	
	while (more_params) {

		//
		//	Get the string param
		//
		const char *name = va_arg (arg_list, const char *);
		if (name == NULL) {
			more_params = false;
		} else {
			
			//
			//	Add the string/id pair to the enum list
			//
			int value = va_arg (arg_list, int);
			m_List.Add (ENUM_VALUE(name, value));
		}		
	}
	
	va_end (arg_list);
	return ;
}



//*******************************************************************************************//
//
//	Start of PhysDefParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	PhysDefParameterClass
//
/////////////////////////////////////////////////////////////////////
PhysDefParameterClass::PhysDefParameterClass (int *id)
	:	m_Value (id)
{	
	return ;
}

/////////////////////////////////////////////////////////////////////
//
//	PhysDefParameterClass
//
/////////////////////////////////////////////////////////////////////
PhysDefParameterClass::PhysDefParameterClass (const PhysDefParameterClass &src)
	:	m_Value (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const PhysDefParameterClass &
PhysDefParameterClass::operator= (const PhysDefParameterClass &src)
{
	m_Value = src.m_Value;
	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
PhysDefParameterClass::operator== (const PhysDefParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
PhysDefParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = PhysDefParameterClass::operator== ((const PhysDefParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
PhysDefParameterClass::Copy_Value (const ParameterClass &/*src*/)
{
	//
	//	We don't allow the value to be copied
	//
	return ;
}


//*******************************************************************************************//
//
//	Start of ModelDefParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	ModelDefParameterClass
//
/////////////////////////////////////////////////////////////////////
ModelDefParameterClass::ModelDefParameterClass (int *id)
	:	m_Value (id)
{	
	return ;
}

/////////////////////////////////////////////////////////////////////
//
//	ModelDefParameterClass
//
/////////////////////////////////////////////////////////////////////
ModelDefParameterClass::ModelDefParameterClass (const ModelDefParameterClass &src)
	:	m_Value (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const ModelDefParameterClass &
ModelDefParameterClass::operator= (const ModelDefParameterClass &src)
{
	m_Value = src.m_Value;
	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ModelDefParameterClass::operator== (const ModelDefParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ModelDefParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = ModelDefParameterClass::operator== ((const ModelDefParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
ModelDefParameterClass::Copy_Value (const ParameterClass &/*src*/)
{
	//
	//	We don't allow the value to be copied
	//
	return ;
}


//*******************************************************************************************//
//
//	Start of DefParameterClass
//
//*******************************************************************************************//

/////////////////////////////////////////////////////////////////////
//
//	DefParameterClass
//
/////////////////////////////////////////////////////////////////////
DefParameterClass::DefParameterClass (int *id)
	:	m_Value (id)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	DefParameterClass
//
/////////////////////////////////////////////////////////////////////
DefParameterClass::DefParameterClass (const DefParameterClass &src)
	:	m_Value (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const DefParameterClass &
DefParameterClass::operator= (const DefParameterClass &src)
{
	m_Value = src.m_Value;
	DefParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
DefParameterClass::operator== (const DefParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
DefParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = DefParameterClass::operator== ((const DefParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
DefParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Get_Type () == Get_Type ()) {
		(*m_Value) = ((DefParameterClass &)src).Get_Value ();
	}

	ParameterClass::Copy_Value (src);
	return ;
}



//*******************************************************************************************//
//
//	Start of GenericDefParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	GenericDefParameterClass
//
/////////////////////////////////////////////////////////////////////
GenericDefParameterClass::GenericDefParameterClass (int *id)
	:	m_ClassID (0),
		DefParameterClass (id)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	GenericDefParameterClass
//
/////////////////////////////////////////////////////////////////////
GenericDefParameterClass::GenericDefParameterClass (const GenericDefParameterClass &src)
	:	m_ClassID (0),
		DefParameterClass (src)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const GenericDefParameterClass &
GenericDefParameterClass::operator= (const GenericDefParameterClass &src)
{
	DefParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
GenericDefParameterClass::operator== (const GenericDefParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
GenericDefParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = GenericDefParameterClass::operator== ((const GenericDefParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
GenericDefParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_GENERICDEFINITIONID)) {
		(*m_Value) = ((GenericDefParameterClass &)src).Get_Value ();
	}

	ParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of GameObjDefParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	GameObjDefParameterClass
//
/////////////////////////////////////////////////////////////////////
GameObjDefParameterClass::GameObjDefParameterClass (int *id)
	:	DefParameterClass (id)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	GameObjDefParameterClass
//
/////////////////////////////////////////////////////////////////////
GameObjDefParameterClass::GameObjDefParameterClass (const GameObjDefParameterClass &src)
	:	DefParameterClass (src)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const GameObjDefParameterClass &
GameObjDefParameterClass::operator= (const GameObjDefParameterClass &src)
{
	DefParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
GameObjDefParameterClass::operator== (const GameObjDefParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
GameObjDefParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = GameObjDefParameterClass::operator== ((const GameObjDefParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
GameObjDefParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_GAMEOBJDEFINITIONID)) {
		(*m_Value) = ((GameObjDefParameterClass &)src).Get_Value ();
	}

	ParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of WeaponObjDefParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	WeaponObjDefParameterClass
//
/////////////////////////////////////////////////////////////////////
WeaponObjDefParameterClass::WeaponObjDefParameterClass (int *id)
	:	GameObjDefParameterClass (id)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	WeaponObjDefParameterClass
//
/////////////////////////////////////////////////////////////////////
WeaponObjDefParameterClass::WeaponObjDefParameterClass (const WeaponObjDefParameterClass &src)
	:	GameObjDefParameterClass (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const WeaponObjDefParameterClass &
WeaponObjDefParameterClass::operator= (const WeaponObjDefParameterClass &src)
{
	m_Value = src.m_Value;
	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
WeaponObjDefParameterClass::operator== (const WeaponObjDefParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
WeaponObjDefParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = WeaponObjDefParameterClass::operator== ((const WeaponObjDefParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
WeaponObjDefParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_WEAPONOBJDEFINITIONID)) {
		(*m_Value) = ((WeaponObjDefParameterClass &)src).Get_Value ();
	}

	GameObjDefParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of AmmoObjDefParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	AmmoObjDefParameterClass
//
/////////////////////////////////////////////////////////////////////
AmmoObjDefParameterClass::AmmoObjDefParameterClass (int *id)
	:	GameObjDefParameterClass (id)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	AmmoObjDefParameterClass
//
/////////////////////////////////////////////////////////////////////
AmmoObjDefParameterClass::AmmoObjDefParameterClass (const AmmoObjDefParameterClass &src)
	:	GameObjDefParameterClass (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const AmmoObjDefParameterClass &
AmmoObjDefParameterClass::operator= (const AmmoObjDefParameterClass &src)
{
	m_Value = src.m_Value;
	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
AmmoObjDefParameterClass::operator== (const AmmoObjDefParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
AmmoObjDefParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = AmmoObjDefParameterClass::operator== ((const AmmoObjDefParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
AmmoObjDefParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_AMMOOBJDEFINITIONID)) {
		(*m_Value) = ((AmmoObjDefParameterClass &)src).Get_Value ();
	}

	GameObjDefParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of ExplosionObjDefParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	ExplosionObjDefParameterClass
//
/////////////////////////////////////////////////////////////////////
ExplosionObjDefParameterClass::ExplosionObjDefParameterClass (int *id)
	:	GameObjDefParameterClass (id)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	ExplosionObjDefParameterClass
//
/////////////////////////////////////////////////////////////////////
ExplosionObjDefParameterClass::ExplosionObjDefParameterClass (const ExplosionObjDefParameterClass &src)
	:	GameObjDefParameterClass (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const ExplosionObjDefParameterClass &
ExplosionObjDefParameterClass::operator= (const ExplosionObjDefParameterClass &src)
{
	m_Value = src.m_Value;
	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ExplosionObjDefParameterClass::operator== (const ExplosionObjDefParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ExplosionObjDefParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = ExplosionObjDefParameterClass::operator== ((const ExplosionObjDefParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
ExplosionObjDefParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_AMMOOBJDEFINITIONID)) {
		(*m_Value) = ((ExplosionObjDefParameterClass &)src).Get_Value ();
	}

	GameObjDefParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of SoundDefParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	SoundDefParameterClass
//
/////////////////////////////////////////////////////////////////////
SoundDefParameterClass::SoundDefParameterClass (int *id)
	:	DefParameterClass (id)
{	
	return ;
}

/////////////////////////////////////////////////////////////////////
//
//	SoundDefParameterClass
//
/////////////////////////////////////////////////////////////////////
SoundDefParameterClass::SoundDefParameterClass (const SoundDefParameterClass &src)
	:	DefParameterClass (src)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const SoundDefParameterClass &
SoundDefParameterClass::operator= (const SoundDefParameterClass &src)
{
	DefParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
SoundDefParameterClass::operator== (const SoundDefParameterClass &src)
{
	bool retval = false;

	if (m_Value != NULL && src.m_Value != NULL &&
		 (*m_Value) == (*src.m_Value))
	{
		retval = true;
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
SoundDefParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = SoundDefParameterClass::operator== ((const SoundDefParameterClass &)src);
	}

	return retval;
}


//*******************************************************************************************//
//
//	Start of ScriptParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	ScriptParameterClass
//
/////////////////////////////////////////////////////////////////////
ScriptParameterClass::ScriptParameterClass (StringClass *name, StringClass *params)
	:	m_ScriptName (name),
		m_ScriptParams (params)
{	
	return ;
}

/////////////////////////////////////////////////////////////////////
//
//	ScriptParameterClass
//
/////////////////////////////////////////////////////////////////////
ScriptParameterClass::ScriptParameterClass (const ScriptParameterClass &src)
	:	m_ScriptName (NULL),
		m_ScriptParams (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const ScriptParameterClass &
ScriptParameterClass::operator= (const ScriptParameterClass &src)
{
	m_ScriptName	= src.m_ScriptName;
	m_ScriptParams = src.m_ScriptParams;
	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ScriptParameterClass::operator== (const ScriptParameterClass &src)
{
	bool retval = false;

	//
	//	Data valid?
	//
	if (	(m_ScriptName != NULL) && (src.m_ScriptName != NULL) &&
			(m_ScriptParams != NULL) && (src.m_ScriptParams != NULL))
	{
	
		//
		//	Simple string compares should workd
		//
		if (	(m_ScriptName->Compare (*(src.m_ScriptName)) == 0) &&
				(m_ScriptParams->Compare (*(src.m_ScriptParams)) == 0))
		{
			retval = true;
		}
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ScriptParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = ScriptParameterClass::operator== ((const ScriptParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
ScriptParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_SCRIPT)) {
		(*m_ScriptName)	= ((ScriptParameterClass &)src).Get_Script_Name ();
		(*m_ScriptParams)	= ((ScriptParameterClass &)src).Get_Params ();
	}

	ParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of DefIDListParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	DefIDListParameterClass
//
/////////////////////////////////////////////////////////////////////
DefIDListParameterClass::DefIDListParameterClass (DynamicVectorClass<int> *list)
	:	m_IDList (list),
		m_ClassID (0),
		m_SelectedClassID (NULL)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	DefIDListParameterClass
//
/////////////////////////////////////////////////////////////////////
DefIDListParameterClass::DefIDListParameterClass (const DefIDListParameterClass &src)
	:	m_IDList (NULL),
		m_ClassID (0),
		m_SelectedClassID (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const DefIDListParameterClass &
DefIDListParameterClass::operator= (const DefIDListParameterClass &src)
{
	m_IDList				= src.m_IDList;
	m_ClassID			= src.m_ClassID;
	m_SelectedClassID	= src.m_SelectedClassID;

	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
DefIDListParameterClass::operator== (const DefIDListParameterClass &src)
{
	bool retval = false;

	//
	//	Data valid?
	//
	if ((m_IDList != NULL) && (src.m_IDList != NULL))
	{
		//
		//	Class IDs the same?
		//
		if (m_ClassID == src.m_ClassID) {

			int count1 = m_IDList->Count ();
			int count2 = src.m_IDList->Count ();

			//
			//	Are the lists the same?
			//
			retval = (count1 == count2);
			for (int index = 0; (index < count1) && retval; index ++) {
				int value1 = (*m_IDList)[index];
				int value2 = (*src.m_IDList)[index];
				retval &= (value1 == value2);
			}
		}
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
DefIDListParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = DefIDListParameterClass::operator== ((const DefIDListParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
DefIDListParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_DEFINITIONIDLIST)) {
		DefIDListParameterClass real_src = (DefIDListParameterClass &)src;
		
		m_ClassID				= real_src.m_ClassID;		
		(*m_IDList)				= (*real_src.m_IDList);

		if (m_SelectedClassID != NULL && real_src.m_SelectedClassID != NULL) {
			(*m_SelectedClassID)	= (*real_src.m_SelectedClassID);
		}
	}

	ParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of ZoneParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	ZoneParameterClass
//
/////////////////////////////////////////////////////////////////////
ZoneParameterClass::ZoneParameterClass (OBBoxClass *box)
	:	m_OBBox (box)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	ZoneParameterClass
//
/////////////////////////////////////////////////////////////////////
ZoneParameterClass::ZoneParameterClass (const ZoneParameterClass &src)
	:	m_OBBox (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const ZoneParameterClass &
ZoneParameterClass::operator= (const ZoneParameterClass &src)
{
	m_OBBox = src.m_OBBox;

	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ZoneParameterClass::operator== (const ZoneParameterClass &src)
{
	bool retval = false;

	//
	//	Are the OBBoxes the same?
	//
	if ((m_OBBox != NULL) && (src.m_OBBox != NULL)) {
		retval = (*m_OBBox) == (*src.m_OBBox);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ZoneParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = ZoneParameterClass::operator== ((const ZoneParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
ZoneParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_ZONE)) {
		ZoneParameterClass real_src = (ZoneParameterClass &)src;
		
		(*m_OBBox)	= (*real_src.m_OBBox);
	}

	ParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of FilenameListParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	FilenameListParameterClass
//
/////////////////////////////////////////////////////////////////////
FilenameListParameterClass::FilenameListParameterClass (DynamicVectorClass<StringClass> *list)
	:	m_FilenameList (list)		
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	FilenameListParameterClass
//
/////////////////////////////////////////////////////////////////////
FilenameListParameterClass::FilenameListParameterClass (const FilenameListParameterClass &src)
	:	m_FilenameList (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const FilenameListParameterClass &
FilenameListParameterClass::operator= (const FilenameListParameterClass &src)
{
	m_FilenameList	= src.m_FilenameList;

	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
FilenameListParameterClass::operator== (const FilenameListParameterClass &src)
{
	bool retval = false;

	//
	//	Data valid?
	//
	if ((m_FilenameList != NULL) && (src.m_FilenameList != NULL))
	{
		int count1 = m_FilenameList->Count ();
		int count2 = src.m_FilenameList->Count ();

		//
		//	Are the lists the same?
		//
		retval = (count1 == count2);
		for (int index = 0; (index < count1) && retval; index ++) {
			StringClass &filename1 = (*m_FilenameList)[index];
			StringClass &filename2 = (*src.m_FilenameList)[index];
			retval &= (::stricmp (filename1, filename2) == 0);
		}
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
FilenameListParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = FilenameListParameterClass::operator== ((const FilenameListParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
FilenameListParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_FILENAMELIST)) {
		FilenameListParameterClass real_src = (FilenameListParameterClass &)src;		
		(*m_FilenameList) = (*real_src.m_FilenameList);
	}

	ParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of ScriptListParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	ScriptListParameterClass
//
/////////////////////////////////////////////////////////////////////
ScriptListParameterClass::ScriptListParameterClass
(
	DynamicVectorClass<StringClass> *name_list,
	DynamicVectorClass<StringClass> *param_list
)
	:	m_NameList (name_list),
		m_ParamList (param_list)
{	
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	ScriptListParameterClass
//
/////////////////////////////////////////////////////////////////////
ScriptListParameterClass::ScriptListParameterClass (const ScriptListParameterClass &src)
	:	m_NameList (NULL),
		m_ParamList (NULL)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const ScriptListParameterClass &
ScriptListParameterClass::operator= (const ScriptListParameterClass &src)
{
	m_NameList	= src.m_NameList;
	m_ParamList	= src.m_ParamList;

	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ScriptListParameterClass::operator== (const ScriptListParameterClass &src)
{
	bool retval = false;

	//
	//	Data valid?
	//
	if (	(m_NameList != NULL) && (src.m_NameList != NULL) &&
			(m_ParamList != NULL) && (src.m_ParamList != NULL))
	{
		retval = Are_Lists_Identical (*m_NameList, *(src.m_NameList));
		retval &= Are_Lists_Identical (*m_ParamList, *(src.m_ParamList));
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Are_Lists_Identical
//
/////////////////////////////////////////////////////////////////////
bool
ScriptListParameterClass::Are_Lists_Identical
(
	DynamicVectorClass<StringClass> &list1,
	DynamicVectorClass<StringClass> &list2
)
{
	int count1 = list1.Count ();
	int count2 = list2.Count ();

	//
	//	Do a string compare on every entry
	//
	bool retval = (count1 == count2);
	for (int index = 0; (index < count1) && retval; index ++) {
		StringClass &string1 = list1[index];
		StringClass &string2 = list2[index];
		retval &= (::stricmp (string1, string2) == 0);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
ScriptListParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = ScriptListParameterClass::operator== ((const ScriptListParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
ScriptListParameterClass::Copy_Value (const ParameterClass &src)
{
	if (src.Is_Type (ParameterClass::TYPE_SCRIPTLIST)) {
		ScriptListParameterClass &real_src = (ScriptListParameterClass &)src;		
		(*m_NameList)	= (*real_src.m_NameList);
		(*m_ParamList)	= (*real_src.m_ParamList);
	}

	ParameterClass::Copy_Value (src);
	return ;
}


//*******************************************************************************************//
//
//	Start of SeparatorParameterClass
//
//*******************************************************************************************//


/////////////////////////////////////////////////////////////////////
//
//	SeparatorParameterClass
//
/////////////////////////////////////////////////////////////////////
SeparatorParameterClass::SeparatorParameterClass (const SeparatorParameterClass &src)
{
	(*this) = src;
	return ;
}


/////////////////////////////////////////////////////////////////////
//
//	operator=
//
/////////////////////////////////////////////////////////////////////
const SeparatorParameterClass &
SeparatorParameterClass::operator= (const SeparatorParameterClass &src)
{
	ParameterClass::operator= (src);
	return *this;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
SeparatorParameterClass::operator== (const SeparatorParameterClass &src)
{
	return true;
}


/////////////////////////////////////////////////////////////////////
//
//	operator==
//
/////////////////////////////////////////////////////////////////////
bool
SeparatorParameterClass::operator== (const ParameterClass &src)
{
	bool retval = false;

	if (src.Get_Type () == Get_Type ()) {
		retval = SeparatorParameterClass::operator== ((const SeparatorParameterClass &)src);
	}

	return retval;
}


/////////////////////////////////////////////////////////////////////
//
//	Copy_Value
//
/////////////////////////////////////////////////////////////////////
void
SeparatorParameterClass::Copy_Value (const ParameterClass &src)
{
	ParameterClass::Copy_Value (src);
	return ;
}