parameters_properties.cpp

这是一个GPS相关的程序

				break;

			case PARAMETER_TYPE_Choice:
			case PARAMETER_TYPE_Table_Field:
				m_pParameter->Set_Value(m_index);
				break;

			case PARAMETER_TYPE_Grid:
				m_pParameter->Set_Value((void *)m_choices.GetValue(m_index));
				break;

			case PARAMETER_TYPE_Grid_System:
				m_pParameter->Set_Value((void *)m_choices.GetValue(m_index));
				_Update_Grids(pPG);
				break;

			case PARAMETER_TYPE_Table:
			case PARAMETER_TYPE_Shapes:
			case PARAMETER_TYPE_TIN:
				m_pParameter->Set_Value((void *)m_choices.GetValue(m_index));
				_Update_TableFields(pPG);
				break;
			}
		}
	}

	return( true );
}

//---------------------------------------------------------
void CParameters_PG_Choice::_Update_Grids(wxPropertyGrid *pPG)
{
	int			i;
	CSG_Parameter	*pChild;
	wxPGId		Id;

	if( m_pParameter && m_pParameter->Get_Type() == PARAMETER_TYPE_Grid_System )
	{
		for(i=0; i<m_pParameter->Get_Children_Count(); i++)
		{
			pChild	= m_pParameter->Get_Child(i);

			switch( pChild->Get_Type() )
			{
			default:
				break;
				
			case PARAMETER_TYPE_Grid_List:
				break;

			case PARAMETER_TYPE_Grid:
				Id	= pPG->GetPropertyByName(pChild->Get_Identifier());

				if( Id.IsOk() )
				{
					((CParameters_PG_Choice *)Id.GetPropertyPtr())->Update();
				}
			}
		}
	}
}

//---------------------------------------------------------
void CParameters_PG_Choice::_Update_TableFields(wxPropertyGrid *pPG)
{
	int			i;
	CSG_Parameter	*pChild;
	wxPGId		Id;

	if( m_pParameter )
	{
		for(i=0; i<m_pParameter->Get_Children_Count(); i++)
		{
			pChild	= m_pParameter->Get_Child(i);

			if(	pChild->Get_Type() == PARAMETER_TYPE_Table_Field )
			{
				Id	= pPG->GetPropertyByName(pChild->Get_Identifier());

				if( Id.IsOk() )
				{
					((CParameters_PG_Choice *)Id.GetPropertyPtr())->Update();
				}
			}
		}
	}
}


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

//---------------------------------------------------------
#define GRIDSYSTEM_GET_COUNT		(int)(m_choices.IsOk() ? m_choices.GetCount() : 0)
#define GRIDSYSTEM_GET_SYSTEM(i)	(i >= 0 && i < GRIDSYSTEM_GET_COUNT ? (CSG_Grid_System *)m_choices.GetValue(i) : NULL)

//---------------------------------------------------------
CParameters_PG_GridSystem::CParameters_PG_GridSystem(CSG_Parameter *pParameter)
	: wxCustomPropertyClass(pParameter->Get_Name(), pParameter->Get_Identifier())
{
	m_pParameter	= pParameter;

	SetEditor(wxPGEditor_Choice);

	_Create();
}

//---------------------------------------------------------
CParameters_PG_GridSystem::~CParameters_PG_GridSystem(void)
{
	_Destroy();
}

//---------------------------------------------------------
void CParameters_PG_GridSystem::_Create(void)
{
	CWKSP_Grid_Manager	*pSystems;

	_Destroy();

	m_index	= -1;

	if( m_pParameter && m_pParameter->Get_Type() == PARAMETER_TYPE_Grid_System )
	{
		g_pData->Check_Parameter(m_pParameter);

		if( (pSystems = g_pData->Get_Grids()) != NULL )
		{
			if( pSystems->Get_Count() > 0 )
			{
				for(int i=0; i<pSystems->Get_Count(); i++)
				{
					m_choices.Add(pSystems->Get_System(i)->Get_Name().c_str(), (long)pSystems->Get_System(i)->Get_System());

					if( pSystems->Get_System(i)->Get_System()->is_Equal(*m_pParameter->asGrid_System()) )
					{
						m_index	= i;
					}
				}
			}

			m_choices.Add(LNG("[VAL] [not set]"), 0);
		}
	}

	if( GRIDSYSTEM_GET_COUNT == 0 )
	{
		m_choices.Add(LNG("[VAL] [no choice available]"), 0);
	}

	if( m_index < 0 )
	{
		m_index	= GRIDSYSTEM_GET_COUNT - 1;
	}

	SetValueFromInt(m_index);
}

//---------------------------------------------------------
void CParameters_PG_GridSystem::_Destroy(void)
{
	wxPGChoices	choices;

	m_choices.Assign(choices);

	m_index		= 0;
}

//---------------------------------------------------------
bool CParameters_PG_GridSystem::Update(void)
{
	_Create();

	return( true );
}

//---------------------------------------------------------
wxString CParameters_PG_GridSystem::GetValueAsString(int arg_flags) const
{
	if( m_choices.IsOk() && m_index >= 0 && m_index < (int)m_choices.GetCount() )
	{
		return( m_choices.GetLabel(m_index) );
	}

	return( _("<none>") );
}

//---------------------------------------------------------
bool CParameters_PG_GridSystem::SetValueFromInt(long value, int arg_flags)
{
	//-----------------------------------------------------
	if( arg_flags & wxPG_FULL_VALUE )
	{
		return( SetValueFromInt(GRIDSYSTEM_GET_COUNT > 0 ? m_choices.GetValues().Index(value) : 0) );
	}

	//-----------------------------------------------------
	bool	bChanged;

	if( GRIDSYSTEM_GET_COUNT > 0 )
	{
		bChanged	= m_index != value;
		m_index		= value;
		value		= (long)GRIDSYSTEM_GET_SYSTEM(m_index);

		wxCustomPropertyClass::SetValueFromInt(value, arg_flags);

		//-------------------------------------------------
		m_pParameter->Set_Value((void *)value);

		if( GetParent() && GetGrid() )
		{
			wxPGId	Id	= GetGrid()->GetFirstChild(GetId());

			while( Id.IsOk() )
			{
				if( SG_STR_CMP( SG_T("CParameters_PG_Choice"), Id.GetPropertyPtr()->GetClassName() ) == 0 )
				{
					((CParameters_PG_Choice *)Id.GetPropertyPtr())->Update();
				}

				Id	= GetGrid()->GetNextProperty(Id);
			}
		}
	}
	else
	{
		bChanged	= false;
	}

	return( bChanged );
}


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

//---------------------------------------------------------
CParameters_PG_DoublesValue::CParameters_PG_DoublesValue(void)
{
	m_nValues		= 0;
	m_Values		= NULL;
	m_Labels		= NULL;
	m_pParameter	= NULL;
}

//---------------------------------------------------------
CParameters_PG_DoublesValue::CParameters_PG_DoublesValue(class CSG_Parameter *pParameter)
{
	m_nValues		= 0;
	m_Values		= NULL;
	m_Labels		= NULL;
	m_pParameter	= NULL;

	_Create( pParameter );
}

//---------------------------------------------------------
CParameters_PG_DoublesValue::~CParameters_PG_DoublesValue(void)
{
	_Destroy();
}

//---------------------------------------------------------
bool CParameters_PG_DoublesValue::_Create(CSG_Parameter *pParameter)
{
	if( pParameter )
	{
		_Destroy();

		switch( pParameter->Get_Type() )
		{
		default:
			return( false );

		case PARAMETER_TYPE_Range:
			m_nValues	= 2;
			m_Values	= (double *)SG_Malloc(m_nValues * sizeof(double));
			m_Labels	= new wxString[m_nValues];

			m_Labels[0]	= _("Minimum");
			m_Labels[1]	= _("Maximum");
			break;

		case PARAMETER_TYPE_Degree:
			m_nValues	= 3;
			m_Values	= (double *)SG_Malloc(m_nValues * sizeof(double));
			m_Labels	= new wxString[m_nValues];

			m_Labels[0]	= _("\xb0");
			m_Labels[1]	= _("'");
			m_Labels[2]	= _("''");
			break;
		}

		m_pParameter	= pParameter;

		Update_Values();

		return( true );
	}

	return( false );
}

//---------------------------------------------------------
void CParameters_PG_DoublesValue::_Destroy(void)
{
	if( m_nValues > 0 )
	{
		SG_Free(m_Values);
		delete[](m_Labels);

		m_nValues		= 0;
		m_Values		= NULL;
		m_Labels		= NULL;
	}

	m_pParameter	= NULL;
}

//---------------------------------------------------------
bool CParameters_PG_DoublesValue::Assign(const CParameters_PG_DoublesValue &Value)
{
	return( _Create(Value.m_pParameter) );
}

//---------------------------------------------------------
bool CParameters_PG_DoublesValue::Update_Parameter(void)
{
	if( m_pParameter )
	{
		switch( m_pParameter->Get_Type() )
		{
		default:
			break;

		case PARAMETER_TYPE_Range:
			m_pParameter->asRange()->Set_LoVal(m_Values[0]);
			m_pParameter->asRange()->Set_HiVal(m_Values[1]);
			break;

		case PARAMETER_TYPE_Degree:
			m_pParameter->Set_Value(Degree_To_Decimal(m_Values[0], m_Values[1], m_Values[2]));
			break;
		}
	}

	return( true );
}

//---------------------------------------------------------
bool CParameters_PG_DoublesValue::Update_Values(void)
{
	if( m_pParameter )
	{
		switch( m_pParameter->Get_Type() )
		{
		default:
			break;

		case PARAMETER_TYPE_Range:
			m_Values[0]	= m_pParameter->asRange()->Get_LoVal();
			m_Values[1]	= m_pParameter->asRange()->Get_HiVal();
			return( true );

		case PARAMETER_TYPE_Degree:
			Decimal_To_Degree(m_pParameter->asDouble(), m_Values[0], m_Values[1], m_Values[2]);
			return( true );
		}
	}

	return( false );
}


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

//---------------------------------------------------------
WX_PG_IMPLEMENT_VALUE_TYPE_VOIDP(CParameters_PG_DoublesValue, CParameters_PG_Doubles, CParameters_PG_DoublesValue(NULL))

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