module.cpp

这是一个GPS相关的程序

		return( true );
	}

	return( false );
}

//---------------------------------------------------------
bool CSG_Module::Dlg_Parameters(CSG_Parameters *pParameters, const SG_Char *Caption)
{
	return( SG_UI_Dlg_Parameters(pParameters, Caption) );
}

//---------------------------------------------------------
#ifdef _SAGA_UNICODE

CSG_Parameters *	CSG_Module::Add_Parameters(const char *Identifier, const SG_Char *Name, const SG_Char *Description)
{	return( Add_Parameters(CSG_String(Identifier), Name, Description) );	}

CSG_Parameters *	CSG_Module::Get_Parameters(const char *Identifier)
{	return( Get_Parameters(CSG_String(Identifier)) );	}

bool				CSG_Module::Dlg_Parameters(const char *Identifier)
{	return( Dlg_Parameters(CSG_String(Identifier)) );	}

#endif


///////////////////////////////////////////////////////////
//														 //
//						Progress						 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
bool CSG_Module::Process_Get_Okay(bool bBlink)
{
	return( SG_UI_Process_Get_Okay(bBlink) );
}

//---------------------------------------------------------
void CSG_Module::Process_Set_Text(const SG_Char *Text)
{
	SG_UI_Process_Set_Text(Text);
}

//---------------------------------------------------------
bool CSG_Module::Set_Progress(int Position)
{
	return( Set_Progress(Position, 100.0) );
}

//---------------------------------------------------------
bool CSG_Module::Set_Progress(double Position, double Range)
{
	return( m_bShow_Progress ? SG_UI_Process_Set_Progress(Position, Range) : Process_Get_Okay(false) );
}


///////////////////////////////////////////////////////////
//														 //
//						Message							 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
void CSG_Module::Message_Dlg(const SG_Char *Text, const SG_Char *Caption)
{
	if( Caption && Caption[0] != '\0' )
	{
		SG_UI_Dlg_Message(Text, Caption);
	}
	else
	{
		SG_UI_Dlg_Message(Text, Get_Name());
	}
}

//---------------------------------------------------------
void CSG_Module::Message_Add(const SG_Char *Text, bool bNewLine)
{
	SG_UI_Msg_Add_Execution(Text, bNewLine);
}

//---------------------------------------------------------
bool CSG_Module::Error_Set(TSG_Module_Error Error_ID)
{
	switch( Error_ID )
	{
	default:
		return( Error_Set(LNG("[ERR] Unknown Error")) );
	    
	case MODULE_ERROR_Calculation:
		return( Error_Set(LNG("[ERR] Calculation Error")) );
	}
}

//---------------------------------------------------------
bool CSG_Module::Error_Set(const SG_Char *Error_Text)
{
	SG_UI_Msg_Add_Error(Error_Text);

	if( SG_UI_Process_Get_Okay(false) && !m_bError_Ignore )
	{
		switch( SG_UI_Dlg_Error(Error_Text, LNG("[ERR] Error: Continue anyway ?")) )
		{
		case 0: default:
			SG_UI_Process_Set_Okay(false);
			break;

		case 1:
			m_bError_Ignore	= true;
			break;
		}
	}

	return( SG_UI_Process_Get_Okay(false) );
}


///////////////////////////////////////////////////////////
//														 //
//				DataObjects / Garbage					 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
bool CSG_Module::_Garbage_Add_Item(CSG_Data_Object *pDataObject)
{
	if( pDataObject )
	{
		for(int i=0; i<m_nGarbage; i++)
		{
			if( pDataObject == m_Garbage[i] )
			{
				return( true );
			}
		}

		m_Garbage	= (CSG_Data_Object **)SG_Realloc(m_Garbage, (m_nGarbage + 1) * sizeof(CSG_Data_Object *));
		m_Garbage[m_nGarbage++]	= pDataObject;

		return( true );
	}

	return( false );
}

//---------------------------------------------------------
CSG_Data_Object * CSG_Module::Garbage_Del_Item(int i, bool bFromListOnly)
{
	CSG_Data_Object	*pDataObject	= NULL;

	if( i >= 0 && i < m_nGarbage )
	{
		if( bFromListOnly || !m_Garbage[i] )
		{
			pDataObject	= m_Garbage[i];
		}
		else if( m_Garbage[i] )
		{
			delete(m_Garbage[i]);
		}

		for(m_nGarbage--; i<m_nGarbage; i++)
		{
			m_Garbage[i]	= m_Garbage[i + 1];
		}

		m_Garbage	= (CSG_Data_Object **)SG_Realloc(m_Garbage, m_nGarbage * sizeof(CSG_Data_Object *));
	}

	return( pDataObject );
}

//---------------------------------------------------------
void CSG_Module::Garbage_Clear(void)
{
	if( m_nGarbage > 0 )
	{
		for(int i=0; i<m_nGarbage; i++)
		{
			if( m_Garbage[i] )
			{
				delete(m_Garbage[i]);
			}
		}

		SG_Free(m_Garbage);
	}

	m_nGarbage	= 0;
	m_Garbage	= NULL;
}


///////////////////////////////////////////////////////////
//														 //
//				DataObjects / GUI Interaction			 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
bool CSG_Module::DataObject_Add(CSG_Data_Object *pDataObject, bool bUpdate)
{
	return( m_bManaged && SG_UI_DataObject_Add(pDataObject, bUpdate)
		? true : _Garbage_Add_Item(pDataObject)
	);
}

//---------------------------------------------------------
bool CSG_Module::DataObject_Update(CSG_Data_Object *pDataObject, bool bShow)
{
	return( SG_UI_DataObject_Update(pDataObject, bShow, NULL) );
}

bool CSG_Module::DataObject_Update(CSG_Data_Object *pDataObject, double Parm_1, double Parm_2, bool bShow)
{
	CSG_Parameters	Parameters;

	if( pDataObject )
	{
		switch( pDataObject->Get_ObjectType() )
		{
		default:
			break;

		case DATAOBJECT_TYPE_Grid:
			Parameters.Add_Range(NULL, SG_T("METRIC_ZRANGE"), SG_T(""), SG_T(""),
				Parm_1 * ((CSG_Grid *)pDataObject)->Get_ZFactor(),
				Parm_2 * ((CSG_Grid *)pDataObject)->Get_ZFactor()
			);
			break;
		}

		return( SG_UI_DataObject_Update(pDataObject, bShow, &Parameters) );
	}

	return( false );
}

//---------------------------------------------------------
void CSG_Module::DataObject_Update_All(void)
{
	for(int i=0; i<Parameters.Get_Count(); i++)
	{
		if( Parameters(i)->is_Output() )
		{
			if( Parameters(i)->is_DataObject() )
			{
				DataObject_Update(Parameters(i)->asDataObject(), false);
			}
			else if( Parameters(i)->is_DataObject_List() )
			{
				for(int j=0; j<Parameters(i)->asList()->Get_Count(); j++)
				{
					DataObject_Update(Parameters(i)->asList()->asDataObject(j), false);
				}
			}
		}
	}
}

//---------------------------------------------------------
bool CSG_Module::DataObject_Get_Colors(CSG_Data_Object *pDataObject, CSG_Colors &Colors)
{
	return( SG_UI_DataObject_Colors_Get(pDataObject, &Colors) );
}

bool CSG_Module::DataObject_Set_Colors(CSG_Data_Object *pDataObject, const CSG_Colors &Colors)
{
	CSG_Colors	c(Colors);

	return( SG_UI_DataObject_Colors_Set(pDataObject, &c) );
}

bool CSG_Module::DataObject_Set_Colors(CSG_Data_Object *pDataObject, int nColors, int Palette, bool bRevert)
{
	CSG_Colors	c(nColors, Palette, bRevert);

	return( SG_UI_DataObject_Colors_Set(pDataObject, &c) );
}

//---------------------------------------------------------
bool CSG_Module::DataObject_Get_Parameters(CSG_Data_Object *pDataObject, CSG_Parameters &Parameters)
{
	return( SG_UI_DataObject_Params_Get(pDataObject, &Parameters) );
}

bool CSG_Module::DataObject_Set_Parameters(CSG_Data_Object *pDataObject, CSG_Parameters &Parameters)
{
	return( SG_UI_DataObject_Params_Set(pDataObject, &Parameters) );
}


///////////////////////////////////////////////////////////
//														 //
//						History							 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
void CSG_Module::_Set_Output_History(void)
{
	CSG_History	History;

	//-----------------------------------------------------
	History.Add_Entry(LNG("[HST] Created with module"), Get_Name());

	Parameters.Set_History(History);

	History.Assign(History_Supplement, true);

	//-----------------------------------------------------
	for(int i=0; i<Parameters.Get_Count(); i++)	// set output history...
	{
		CSG_Parameter	*p	= Parameters(i);

		if( p->is_Output() && p->is_DataObject() && p->asDataObject() )
		{
			p->asDataObject()->Get_History().Assign(History);
		}

		if( p->is_Output() && p->is_DataObject_List() )
		{
			for(int j=0; j<p->asList()->Get_Count(); j++)
			{
				p->asList()->asDataObject(j)->Get_History().Assign(History);
			}
		}
	}
}


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

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