wksp_shapes.cpp

这是一个GPS相关的程序

	_Chart_Set_Options();

	m_pTable->DataObject_Changed(NULL);
}

//---------------------------------------------------------
void CWKSP_Shapes::On_Parameters_Changed(void)
{
	m_Def_Color	= Get_Color_asWX(m_Parameters("UNISYMBOL_COLOR")->asColor());

	//-----------------------------------------------------
	if( (m_iColor = m_Parameters("COLORS_ATTRIB")->asInt()) >= m_pShapes->Get_Table().Get_Field_Count() )
	{
		m_iColor	= -1;
	}

	if( m_iColor < 0 && (m_pClassify->Get_Mode() == CLASSIFY_METRIC || m_pClassify->Get_Mode() == CLASSIFY_SHADE) )
	{
		m_pClassify->Set_Mode(CLASSIFY_UNIQUE);
	}

	//-----------------------------------------------------
	if( (m_iLabel = m_Parameters("LABEL_ATTRIB")->asInt()) >= m_pShapes->Get_Table().Get_Field_Count() )
	{
		m_iLabel	= -1;
	}

	//-----------------------------------------------------
#ifdef USE_HTMLINFO
	if( (m_iExtraInfo = m_Parameters("EXTRAINFO_ATTRIB")->asInt()) >= m_pShapes->Get_Table().Get_Field_Count() )
	{
		m_iExtraInfo	= -1;
	}
#endif

	//-----------------------------------------------------
	_Chart_Get_Options();
}


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

//---------------------------------------------------------
int CWKSP_Shapes::On_Parameter_Changed(CSG_Parameters *pParameters, CSG_Parameter *pParameter)
{
	//-----------------------------------------------------
	if(	!SG_STR_CMP(pParameter->Get_Identifier(), wxT("COLORS_TYPE"))
	||	!SG_STR_CMP(pParameter->Get_Identifier(), wxT("COLORS_ATTRIB")) )
	{
		int		zField	= pParameters->Get_Parameter("COLORS_ATTRIB")->asInt();

		pParameters->Get_Parameter("METRIC_ZRANGE")->asRange()->Set_Range(
			m_pShapes->Get_Table().Get_MinValue(zField),
			m_pShapes->Get_Table().Get_MaxValue(zField)
		);
	}

	//-----------------------------------------------------
	return( 1 );
}


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

//---------------------------------------------------------
void CWKSP_Shapes::_LUT_Create(void)
{
	int					iField, iRecord, old_Field, iID;
	double				dValue;
	TSG_Table_Index_Order	old_Order;
	CSG_Colors				Colors;
	CSG_String			sFields, sValue;
	CSG_Table_Record		*pRecord, *pRecord_LUT;
	CSG_Table				*pTable, *pLUT;
	CSG_Parameters			Parameters;

	pTable	= Get_Table()->Get_Table();

	if( pTable->Get_Field_Count() <= 0 || pTable->Get_Record_Count() < 1 )
	{
		DLG_Message_Show(LNG("Function failed because no attributes are available"), LNG("Create Lookup Table"));
	}
	else
	{
		for(iField=0; iField<pTable->Get_Field_Count(); iField++)
		{
			sFields.Append(pTable->Get_Field_Name(iField));
			sFields.Append(wxT("|"));
		}

		Parameters.Create(NULL, LNG("Choose Attribute"), LNG(""));
		Parameters.Add_Choice(NULL, "FIELD"	, LNG("Attribute")	, LNG(""), sFields);

		if( DLG_Parameters(&Parameters) )
		{
			Colors.Random();

			iField		= Parameters("FIELD")	->asInt();

			if( pTable->Get_Field_Type(iField) == TABLE_FIELDTYPE_String )
			{
				pTable->Add_Field(CSG_String::Format(wxT("%s_LUT"), pTable->Get_Field_Name(iField)), TABLE_FIELDTYPE_Int);
				iID		= pTable->Get_Field_Count() - 1;
			}
			else
			{
				iID		= iField;
			}

			pLUT		= m_Parameters("LUT")	->asTable();
			pLUT		->Del_Records();

			old_Order	= pTable->Get_Index_Order();
			old_Field	= pTable->Get_Index_Field();

			pTable->Set_Index(iField, TABLE_INDEX_Up);
			sValue		= pTable->Get_Record_byIndex(0)->asString(iField);
			dValue		= iID != iField ? 1.0 : pTable->Get_Record_byIndex(0)->asDouble(iField);

			for(iRecord=0; iRecord<pTable->Get_Record_Count(); iRecord++)
			{
				pRecord	= pTable->Get_Record_byIndex(iRecord);

				if( iRecord == 0 || sValue.Cmp(pRecord->asString(iField)) )
				{
					if( iRecord > 0 )
					{
						sValue		= pRecord->asString(iField);
						dValue		= iID != iField ? dValue + 1.0 : pRecord->asDouble(iField);
					}

					pRecord_LUT	= pLUT->Add_Record();
					pRecord_LUT	->Set_Value(0, Colors.Get_Color(pLUT->Get_Record_Count() % Colors.Get_Count()));			// Color
					pRecord_LUT	->Set_Value(1, sValue.c_str());	// Name
					pRecord_LUT	->Set_Value(2, sValue.c_str());	// Description
					pRecord_LUT	->Set_Value(3, dValue);			// Minimum
					pRecord_LUT	->Set_Value(4, dValue);			// Maximum
				}

				if( iID != iField )
				{
					pRecord->Set_Value(iID, dValue);
				}
			}

			pTable->Set_Index(old_Field, old_Order);

			DataObject_Changed();

			m_Parameters("COLORS_TYPE")		->Set_Value(1);		// Lookup Table
			m_Parameters("COLORS_ATTRIB")	->Set_Value(iID);

			DataObject_Changed();
		//	Parameters_Changed();
		}
	}
}


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

//---------------------------------------------------------
wxString CWKSP_Shapes::Get_Value(CSG_Point ptWorld, double Epsilon)
{
	CSG_Shape		*pShape;

	if( (pShape = m_pShapes->Get_Shape(ptWorld, Epsilon)) != NULL )
	{
		if( m_iColor >= 0 )
		{
			return( pShape->Get_Record()->asString(m_iColor) );
		}
		else
		{
			return( wxString::Format(wxT("%s: %d"), LNG("[CAP] Index"), pShape->Get_Record()->Get_Index() + 1) );
		}
	}

	return( LNG("") );
}

//---------------------------------------------------------
double CWKSP_Shapes::Get_Value_Range(void)
{
	if( m_iColor >= 0 )
	{
		return(
			  m_pShapes->Get_Table().Get_MaxValue(m_iColor)
			- m_pShapes->Get_Table().Get_MinValue(m_iColor)
		);
	}
	else
	{
		return( 0.0 );
	}
}


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

//---------------------------------------------------------
bool CWKSP_Shapes::asImage(CSG_Grid *pImage)
{
	return( false );
}

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

//---------------------------------------------------------
void CWKSP_Shapes::On_Draw(CWKSP_Map_DC &dc_Map, bool bEdit)
{
	int		iShape;
	CSG_Shape	*pShape;

	//-----------------------------------------------------
	if( Get_Extent().Intersects(dc_Map.m_rWorld) != INTERSECTION_None )
	{
		_Draw_Initialize(dc_Map);

		//-------------------------------------------------
		if( bEdit && (m_Edit_pShape || m_pShapes->Get_Selection_Count() > 0) )
		{
			for(iShape=0; iShape<m_pShapes->Get_Count(); iShape++)
			{
				pShape	= m_pShapes->Get_Shape(iShape);

				if( !pShape->Get_Record()->is_Selected() && dc_Map.m_rWorld.Intersects(pShape->Get_Extent()) != INTERSECTION_None )
				{
					_Draw_Shape(dc_Map, pShape, false);
				}
			}

			//---------------------------------------------
			for(iShape=1; iShape<m_pShapes->Get_Selection_Count(); iShape++)
			{
				pShape	= m_pShapes->Get_Selection(iShape);

				if( dc_Map.m_rWorld.Intersects(pShape->Get_Extent()) != INTERSECTION_None )
				{
					_Draw_Shape(dc_Map, pShape, true);
				}
			}

			if( m_Edit_pShape )
			{
				_Edit_Shape_Draw(dc_Map);
			}
			else
			{
				pShape	= m_pShapes->Get_Selection(0);

				if( dc_Map.m_rWorld.Intersects(pShape->Get_Extent()) != INTERSECTION_None )
				{
					_Draw_Shape(dc_Map, pShape, true);
				}
			}
		}

		//-------------------------------------------------
		else
		{
			for(iShape=0; iShape<m_pShapes->Get_Count(); iShape++)
			{
				pShape	= m_pShapes->Get_Shape(iShape);

				if( dc_Map.m_rWorld.Intersects(pShape->Get_Extent()) != INTERSECTION_None )
				{
					_Draw_Shape(dc_Map, pShape, false);
				}
			}

			if( _Chart_is_Valid() )
			{
				for(iShape=0; iShape<m_pShapes->Get_Count(); iShape++)
				{
					pShape	= m_pShapes->Get_Shape(iShape);

					if( dc_Map.m_rWorld.Intersects(pShape->Get_Extent()) != INTERSECTION_None )
					{
						_Draw_Chart(dc_Map, pShape);
					}
				}
			}
		}

		//-------------------------------------------------
		if( m_iLabel >= 0 )
		{
			int		Size;
			double	dSize;

			switch( m_Parameters("LABEL_ATTRIB_SIZE_TYPE")->asInt() )
			{
			case 0:	default:
				dSize	= m_Parameters("LABEL_ATTRIB_FONT")->asFont()->GetPointSize();
				break;

			case 1:
				dSize	= dc_Map.m_World2DC * m_Parameters("LABEL_ATTRIB_SIZE")->asDouble();
				break;
			}

			if( (Size = (int)(0.5 + dSize)) > 0 )
			{
				wxFont	Font	= *m_Parameters("LABEL_ATTRIB_FONT")->asFont();

				Font.SetPointSize(Size);

				dc_Map.dc.SetFont(Font);
				dc_Map.dc.SetTextForeground(m_Parameters("LABEL_ATTRIB_FONT")->asColor());

				for(iShape=0; iShape<m_pShapes->Get_Count(); iShape++)
				{
					pShape	= m_pShapes->Get_Shape(iShape);

					if( dc_Map.m_rWorld.Intersects(pShape->Get_Extent()) != INTERSECTION_None )
					{
						_Draw_Label(dc_Map, pShape);
					}
				}
			}
		}
	}

	//-----------------------------------------------------
	else if( m_Edit_pShape )
	{
		_Edit_Shape_Draw(dc_Map);
	}

	//-----------------------------------------------------
	dc_Map.dc.SetBrush(wxNullBrush);
	dc_Map.dc.SetPen  (wxNullPen);
}


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

//---------------------------------------------------------
CSG_Parameter * CWKSP_Shapes::_AttributeList_Add(CSG_Parameter *pNode, const char *Identifier, const wxChar *Name, const wxChar *Description)
{
	CSG_Parameter *pParameter;

	pParameter	= m_Parameters.Add_Choice(
		pNode, Identifier, Name, Description,