parameters.cpp

这是一个GPS相关的程序

//---------------------------------------------------------
CSG_Parameter * CSG_Parameters::Get_Parameter(int iParameter)
{
	if( m_Parameters && iParameter >= 0 && iParameter < m_nParameters )
	{
		return( m_Parameters[iParameter] );
	}

	return( NULL );
}


///////////////////////////////////////////////////////////
//														 //
//						Callback						 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
void CSG_Parameters::Set_Callback_On_Parameter_Changed(TSG_PFNC_Parameter_Changed Callback)
{
	m_Callback	= Callback;
}

//---------------------------------------------------------
void CSG_Parameters::Set_Callback(bool bActive)
{
	m_bCallback	= bActive;
}

//---------------------------------------------------------
bool CSG_Parameters::_On_Parameter_Changed(CSG_Parameter *pSender)
{
	if( m_Callback && m_bCallback )
	{
		m_bCallback	= false;
		m_Callback(pSender);
		m_bCallback	= true;

		return( true );
	}

	return( false );
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
bool CSG_Parameters::Set_Parameter(const SG_Char *Identifier, CSG_Parameter *pSource)
{
	CSG_Parameter	*pTarget;

	if( pSource != NULL && (pTarget = Get_Parameter(Identifier)) != NULL && pSource->Get_Type() == pTarget->Get_Type() )
	{
		switch( pTarget->Get_Type() )
		{
		default:
			return( pTarget->Assign(pSource) );

		case PARAMETER_TYPE_DataObject_Output:
		case PARAMETER_TYPE_Grid:
		case PARAMETER_TYPE_Table:
		case PARAMETER_TYPE_Shapes:
		case PARAMETER_TYPE_TIN:
			return( pTarget->Set_Value(pSource->asDataObject()) );
		}
	}

	return( false );
}

//---------------------------------------------------------
bool CSG_Parameters::Set_Parameter(const SG_Char *Identifier, int Type, int Value)
{
	CSG_Parameter	*pTarget;

	if( (pTarget = Get_Parameter(Identifier)) != NULL && Type == pTarget->Get_Type() )
	{
		pTarget->Set_Value(Value);

		return( true );
	}

	return( false );
}

//---------------------------------------------------------
bool CSG_Parameters::Set_Parameter(const SG_Char *Identifier, int Type, double Value)
{
	CSG_Parameter	*pTarget;

	if( (pTarget = Get_Parameter(Identifier)) != NULL && Type == pTarget->Get_Type() )
	{
		pTarget->Set_Value(Value);

		return( true );
	}

	return( false );
}

//---------------------------------------------------------
bool CSG_Parameters::Set_Parameter(const SG_Char *Identifier, int Type, void *Value)
{
	CSG_Parameter	*pTarget;

	if( (pTarget = Get_Parameter(Identifier)) != NULL && Type == pTarget->Get_Type() )
	{
		pTarget->Set_Value(Value);

		return( true );
	}

	return( false );
}

//---------------------------------------------------------
bool CSG_Parameters::Set_Parameter(const SG_Char *Identifier, int Type, const SG_Char *Value)
{
	CSG_Parameter	*pTarget;

	if( (pTarget = Get_Parameter(Identifier)) != NULL && Type == pTarget->Get_Type() )
	{
		pTarget->Set_Value(Value);

		return( true );
	}

	return( false );
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
int CSG_Parameters::Assign(CSG_Parameters *pSource)
{
	int			i;
	CSG_Parameter	*pParameter;

	if( pSource )
	{
		Destroy();

		m_pOwner	= pSource->Get_Owner();

		Set_Identifier	(pSource->Get_Identifier());
		Set_Name		(pSource->Get_Name());
		Set_Description	(pSource->Get_Description());

		m_Callback	= pSource->m_Callback;
		m_bCallback	= pSource->m_bCallback;

		if( pSource->Get_Count() > 0 )
		{
			for(i=0; i<pSource->Get_Count(); i++)
			{
				_Add(pSource->Get_Parameter(i));
			}

			for(i=0; i<pSource->Get_Count(); i++)
			{
				if( Get_Parameter(i) && (pParameter = pSource->Get_Parameter(i)->Get_Parent()) != NULL )
				{
					Get_Parameter(i)->m_pParent	= Get_Parameter(pParameter->Get_Identifier());
				}
			}

			if( pSource->m_pGrid_System )
			{
				m_pGrid_System	= Get_Parameter(pSource->m_pGrid_System->Get_Identifier());
			}
		}

		return( m_nParameters );
	}

	return( -1 );
}

//---------------------------------------------------------
int CSG_Parameters::Assign_Values(CSG_Parameters *pSource)
{
	int			i, n;
	CSG_Parameter	*pParameter;

	if( pSource )
	{
		for(i=0, n=0; i<pSource->Get_Count(); i++)
		{
			pParameter	= Get_Parameter(pSource->Get_Parameter(i)->Get_Identifier());

			if( pParameter && pParameter->Get_Type() == pSource->Get_Parameter(i)->Get_Type() )
			{
				pParameter->Assign(pSource->Get_Parameter(i));
				n++;
			}
		}

		return( n );
	}

	return( 0 );
}


///////////////////////////////////////////////////////////
//														 //
//						Serialize						 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
#define PARAMETER_ENTRIES_BEGIN				SG_T("[PARAMETER_ENTRIES_BEGIN]")
#define PARAMETER_ENTRIES_END				SG_T("[PARAMETER_ENTRIES_END]")
#define PARAMETER_ENTRY_BEGIN				SG_T("[PARAMETER_ENTRY_BEGIN]")
#define PARAMETER_ENTRY_END					SG_T("[PARAMETER_ENTRY_END]")

//---------------------------------------------------------
bool CSG_Parameters::Serialize(const SG_Char *File_Name, bool bSave)
{
	bool		bResult	= false;
	CSG_File	Stream;

	if( Stream.Open(File_Name, bSave ? SG_FILE_W : SG_FILE_R, true) )
	{
		bResult	= Serialize(Stream, bSave);
	}

	return( bResult );
}

//---------------------------------------------------------
bool CSG_Parameters::Serialize(CSG_File &Stream, bool bSave)
{
	if( Stream.is_Open() )
	{
		//-------------------------------------------------
		if( bSave )
		{
			Stream.Printf(SG_T("\n%s\n"), PARAMETER_ENTRIES_BEGIN);

			for(int i=0; i<m_nParameters; i++)
			{
				if(	m_Parameters[i]->is_Serializable() )
				{
					Stream.Printf(SG_T("%s\n"), PARAMETER_ENTRY_BEGIN);
					Stream.Printf(SG_T("%s\n"), m_Parameters[i]->m_Identifier.c_str());

					m_Parameters[i]->Serialize(Stream, true);

					Stream.Printf(SG_T("%s\n"), PARAMETER_ENTRY_END);
				}
			}

			Stream.Printf(SG_T("%s\n"), PARAMETER_ENTRIES_END);

			return( true );
		}

		//-------------------------------------------------
		else
		{
			CSG_Parameter	*pParameter;
			CSG_String		sLine;

			while( Stream.Read_Line(sLine) && sLine.Cmp(PARAMETER_ENTRIES_BEGIN) );

			if( !sLine.Cmp(PARAMETER_ENTRIES_BEGIN) )
			{
				while( Stream.Read_Line(sLine) && sLine.Cmp(PARAMETER_ENTRIES_END) )
				{
					if( !sLine.Cmp(PARAMETER_ENTRY_BEGIN) )
					{
						if( Stream.Read_Line(sLine) && (pParameter = Get_Parameter(sLine)) != NULL )
						{
							pParameter->Serialize(Stream, false);
						}
					}
				}

				return( true );
			}

			//---------------------------------------------
			else	// SAGA 1.x compatibility...
			{
				CSG_Parameter	*pParameter;
				CSG_String		sLine;

				Stream.Seek_Start();

				while( Stream.Read_Line(sLine) && sLine.Cmp(SG_T("SERIALIZE_PARAMETERS_VERSION_0.101")) );

				if( !sLine.Cmp(SG_T("SERIALIZE_PARAMETERS_VERSION_0.101")) )
				{
					while( Stream.Read_Line(sLine) )
					{
						if( !sLine.Cmp(SG_T("SERIALIZE_PARAMETER_BEGIN")) )
						{
							if( Stream.Read_Line(sLine) && (pParameter = Get_Parameter(sLine)) != NULL && Stream.Read_Line(sLine) )
							{
								bool	bOkay	= false;

								switch( sLine.asInt() )
								{
								case 1:		bOkay	= pParameter->Get_Type() == PARAMETER_TYPE_Bool;		break;
								case 2:		bOkay	= pParameter->Get_Type() == PARAMETER_TYPE_Int;			break;
								case 3:		bOkay	= pParameter->Get_Type() == PARAMETER_TYPE_Int;			break;
								case 4:		bOkay	= pParameter->Get_Type() == PARAMETER_TYPE_Double;		break;
								case 5:		bOkay	= pParameter->Get_Type() == PARAMETER_TYPE_Degree;		break;
								case 7:		bOkay	= pParameter->Get_Type() == PARAMETER_TYPE_Choice;		break;
								case 8:		bOkay	= pParameter->Get_Type() == PARAMETER_TYPE_String;		break;
								case 10:	bOkay	= pParameter->Get_Type() == PARAMETER_TYPE_FilePath;	break;
								case 12:	bOkay	= pParameter->Get_Type() == PARAMETER_TYPE_Color;		break;

								case 6:
									if( pParameter->Get_Type() == PARAMETER_TYPE_Range )
									{
										double	min, max;

										Stream.Read_Line(sLine);	// empty
										Stream.Read_Line(sLine);	Stream.Read_Line(sLine);	min	= sLine.asDouble();
										Stream.Read_Line(sLine);	Stream.Read_Line(sLine);	max	= sLine.asDouble();

										pParameter->asRange()->Set_Range(min, max);
									}
									break;
								}

								if( bOkay )
								{
									pParameter->Get_Data()->Serialize(Stream, false);
								}
							}

							while( Stream.Read_Line(sLine) && sLine.Cmp(SG_T("SERIALIZE_PARAMETER_END")) );
						}
					}

					return( true );
				}
			}		// SAGA 1.x compatibility...
			//---------------------------------------------
		}
	}

	return( false );
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
bool CSG_Parameters::DataObjects_Check(bool bSilent)
{
	bool	bInvalid, bResult	= true;
	CSG_String	s;

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