protected virtual void OnPointFetched(MapObjects2.Point e)
{
if (PointFetchedEvent != null && e != null)
{
PointFetchedEvent(null, e);
}
}
public MapObjects2.ClassBreaksRenderer GetClassBreaksRender(MapObjects2.MapLayer layer, string renderFieldName, int breaksCount, Color startColor, Color endColor)
{
MapObjects2.ClassBreaksRenderer oClassBreakRender = new MapObjects2.ClassBreaksRendererClass();
if (layer.shapeType == ShapeTypeConstants.moShapeTypePoint)
oClassBreakRender.SymbolType = SymbolTypeConstants.moPointSymbol;
else if (layer.shapeType == ShapeTypeConstants.moShapeTypeLine)
oClassBreakRender.SymbolType = SymbolTypeConstants.moLineSymbol;
else if (layer.shapeType == ShapeTypeConstants.moShapeTypePolygon)
oClassBreakRender.SymbolType = SymbolTypeConstants.moFillSymbol;
oClassBreakRender.Field = renderFieldName;
oClassBreakRender.BreakCount = (short)breaksCount;
MapObjects2.Statistics oStatistic = layer.Records.CalculateStatistics(renderFieldName);
double dInterval = (oStatistic.Max - oStatistic.Min) / breaksCount;
for (short i = 0; i < breaksCount; i++)
{
oClassBreakRender.set_Break(i, oStatistic.Min + dInterval * i);
}
oClassBreakRender.RampColors((uint)Utilities.Converter.ConvertSystemtoIntegerColor(startColor), (uint)Utilities.Converter.ConvertSystemtoIntegerColor(endColor));
return oClassBreakRender;
}
public void ConvertTextSymbol(TextSymbolStruct fromSymbol, MapObjects2.TextSymbol toSymbol)
{
toSymbol.Color = (uint)fromSymbol.TextColor.ToArgb();
toSymbol.Fitted = fromSymbol.Fitted;
toSymbol.Font = fromSymbol.TextFont;
toSymbol.Height = fromSymbol.Height;
toSymbol.HorizontalAlignment = (MapObjects2.AlignmentConstants)fromSymbol.HorizontalAlignment;
toSymbol.VerticalAlignment = (MapObjects2.AlignmentConstants)fromSymbol.VerticalAlignment;
toSymbol.Rotation = fromSymbol.Rotation;
}
public void ConvertSymbol(SymbolStruct fromSymbol,MapObjects2.Symbol toSymbol)
{
toSymbol.CenterOnAscent = fromSymbol.CenterOnAscent;
toSymbol.CharacterIndex = fromSymbol.CharacterIndex;
toSymbol.Color = Convert.ToUInt32(fromSymbol.FillColor.ToArgb());
toSymbol.Custom = fromSymbol.CustomSymbol;
toSymbol.Font.Name = fromSymbol.FontName;
toSymbol.Outline = fromSymbol.OutLine;
toSymbol.OutlineColor = Convert.ToUInt32(fromSymbol.OutLineColor.ToArgb());
toSymbol.Rotation = fromSymbol.Rotation;
toSymbol.Size = fromSymbol.Size;
toSymbol.Style = fromSymbol.Style;
toSymbol.SymbolType = (MapObjects2.SymbolTypeConstants)fromSymbol.SymbolType;
}
private void LoadDataToGridView(MapObjects2.MapLayer layer)
{
Utilities.LayerProperty oLayerProperty = new MapConfigure.Utilities.LayerProperty();
try
{
this.lblLayerDescription.Text = string.Format("ͼ������ �� {0}", layer.Name);
System.Data.DataTable dtlayerAttributes = oLayerProperty.GetAttributesByLayer(layer);
this.dgvViewAttributes.DataSource = dtlayerAttributes;
}
finally
{
oLayerProperty = null;
}
}
public FeatureInformations GetIdentifyFeatureInfos(MapObjects2.Point mousePosition, AxMapObjects2.AxMap mapControl,MapProject.MapStruct mapInfosCollection)
{
FeatureInformations oFeatureInfos = null;
foreach (ILayerStruct oLayerInfos in mapInfosCollection.Layers)
{
if (oLayerInfos.LayerType != (short)LayerTypeConstants.moMapLayer)
continue;
MapUtil.MapOperation oMapOper = new MapOperation();
MapObjects2.MapLayer oMapLayer = oMapOper.GetLayerByName(mapControl, oLayerInfos.AliasName) as MapObjects2.MapLayer;
if (oMapLayer.Visible == false)
continue;
Recordset oSelectedRecords = oMapLayer.SearchShape(mousePosition, SearchMethodConstants.moAreaIntersect, "");
if (oSelectedRecords.EOF)
continue;
oSelectedRecords.MoveFirst();
oFeatureInfos = new FeatureInformations();
oFeatureInfos.CurrentLayerInfos = oLayerInfos;
oFeatureInfos.Geometry = oSelectedRecords.Fields.Item("shape").Value;
TableDesc oTableDesc = oSelectedRecords.TableDesc;
oFeatureInfos.FieldsAndValuesCollection = new Dictionary<string, string>();
int iFieldsCount = oTableDesc.FieldCount;
string sFieldName = "";
string sValue = "";
for (short i = 0; i < iFieldsCount; i++)
{
sFieldName = oTableDesc.get_FieldName(i);
sValue = oSelectedRecords.Fields.Item(sFieldName).ValueAsString;
oFeatureInfos.FieldsAndValuesCollection.Add(sFieldName, sValue);
}
break;
}
return oFeatureInfos;
}
public MapObjects2.LabelRenderer GetLabelRender(string labelFieldName,bool allowDuplicates, bool flip,
double minLevel, double maxLevel, System.Drawing.Color labelColor, string labelFontName,double labelSize, double rotation,
MapObjects2.AlignmentConstants horizontalAlignment, MapObjects2.AlignmentConstants verticalAlignment)
{
MapObjects2.LabelRenderer oLabelRender = new MapObjects2.LabelRendererClass();
oLabelRender.Field = labelFieldName;
oLabelRender.AllowDuplicates = allowDuplicates;
oLabelRender.Flip = flip;
oLabelRender.MaxLevel = (short)maxLevel;
oLabelRender.MinLevel = (short)minLevel;
oLabelRender.SymbolCount = 1;
oLabelRender.get_Symbol(0).Color = (uint)Utilities.Converter.ConvertSystemtoIntegerColor(labelColor);
oLabelRender.get_Symbol(0).Font.Name = labelFontName;
oLabelRender.get_Symbol(0).Font.Size = (decimal)labelSize;
oLabelRender.get_Symbol(0).HorizontalAlignment = horizontalAlignment;
oLabelRender.get_Symbol(0).VerticalAlignment = verticalAlignment;
oLabelRender.get_Symbol(0).Rotation = rotation;
return oLabelRender;
}
public System.Data.DataTable GetAttributesByLayer(MapObjects2.MapLayer layer)
{
if (layer == null)
return null;
short iColumnsCount = 0;
string sFieldName = null;
DataTable dtLayerAttribute = new DataTable();
MapObjects2.Recordset oAttributeRecordes = layer.Records;
MapObjects2.TableDesc oAtributeColumns = oAttributeRecordes.TableDesc;
iColumnsCount = oAtributeColumns.FieldCount;
for (short i = 0; i < iColumnsCount; i++)
{
DataColumn oColumn = new DataColumn(oAtributeColumns.get_FieldName(i));
dtLayerAttribute.Columns.Add(oColumn);
}
oAttributeRecordes.MoveFirst();
while (!oAttributeRecordes.EOF)
{
DataRow oNewRow = dtLayerAttribute.NewRow();
for (short i = 0; i < iColumnsCount; i++)
{
sFieldName = oAttributeRecordes.TableDesc.get_FieldName(i).ToString();
oNewRow[sFieldName] = oAttributeRecordes.Fields.Item(sFieldName).ValueAsString;
}
dtLayerAttribute.Rows.Add(oNewRow);
oAttributeRecordes.MoveNext();
}
return dtLayerAttribute;
}
public void DrawMainMapViewExtent(MapObjects2.Rectangle viewExtent)
{
this.mapControl.TrackingLayer.ClearEvents();
this.mapControl.TrackingLayer.AddEvent(viewExtent, 0);
}
public void AddTrackingPath(MapObjects2.Line trackingPath)
{
this._trackingLineEvent = this._trackingLayer.AddEvent(trackingPath, this._trackingLineSymbolIndex);
}
private void InitGroupRenderLab(MapObjects2.GroupRenderer render)
{
if ((render).Count > 0)
{
object oClassBreaksRender = this.GetRenderFromGroup(render, RenderType.ClassBreakRender);
if (oClassBreaksRender != null)
{
this.ckbIsAddClassBreakRender.Checked = true;
InitClassBreaksRenderLab(oClassBreaksRender as MapObjects2.ClassBreaksRenderer);
}
object oLabelRender = this.GetRenderFromGroup(render, RenderType.LabelRender);
if (oLabelRender != null)
{
this.ckbIsAddLabelRender.Checked = true;
InitLabelRenderLab(oLabelRender as MapObjects2.LabelRenderer);
}
object oValueRender = this.GetRenderFromGroup(render, RenderType.ValueRender);
if (oValueRender != null)
{
this.ckbIsAddUniqueValueRender.Checked = true;
InitUniqueValueRenderLab(oValueRender as MapObjects2.ValueMapRenderer);
}
}
}
private void SetLayerRender(MapObjects2.MapLayer layer, IRenderStruct render)
{
if (render.LayerRenderType == RenderType.ValueRender) layer.Renderer = this.GetValueRender(render as ValueRenderStruct);
else if (render.LayerRenderType == RenderType.ClassBreakRender) layer.Renderer = this.GetClassBreakRender(render as ClassBreakRenderStruct);
else if (render.LayerRenderType == RenderType.LabelRender) layer.Renderer = this.GetLabelRender(render as LabelRenderStruct);
else if (render.LayerRenderType == RenderType.GroupRender) layer.Renderer = this.GetGroupRender(render as GroupRenderStruct);
}
private ValueRenderStruct ExportValueRender(MapObjects2.ValueMapRenderer render)
{
ValueRenderStruct oValueRender = new ValueRenderStruct();
this.DeconvertSymbol(render.DefaultSymbol, oValueRender.DefaultSymbol);
oValueRender.Field = render.Field;
oValueRender.RotationField = render.RotationField;
oValueRender.ScaleField = render.ScalingField;
oValueRender.SymbolType = (short)render.SymbolType;
oValueRender.Tag = render.Tag;
oValueRender.UseDefault = render.UseDefault;
oValueRender.ValueCount = render.ValueCount;
short iIndex = 0;
MapObjects2.Symbol oMapSymbol = render.get_Symbol(iIndex);
while (oMapSymbol != null)
{
SymbolStruct oSymbol = new SymbolStruct();
this.DeconvertSymbol(oMapSymbol, oSymbol);
oValueRender.SymbolList.Add(oSymbol);
iIndex++;
oMapSymbol = render.get_Symbol(iIndex);
}
return oValueRender;
}
public MapLayerInfoStruct LoadLayerInfos(MapObjects2.MapLayer layer,string fileName,double minScale,double maxScale)
{
MapLayerInfoStruct oMapLayerStruct = new MapLayerInfoStruct();
oMapLayerStruct.Name = layer.Name;
oMapLayerStruct.FileName = fileName;
oMapLayerStruct.ShapeType = (short)layer.shapeType;
oMapLayerStruct.MinLevel = minScale;
oMapLayerStruct.MaxLevel = maxScale;
this.DeconvertSymbol(layer.Symbol, oMapLayerStruct.Symbol);
oMapLayerStruct.Render = this.ExportLayerRender(layer);
return oMapLayerStruct;
}
private void CopySymbolToAnother(MapObjects2.Symbol fromSymbol, MapObjects2.Symbol toSymbol)
{
toSymbol.SymbolType = fromSymbol.SymbolType;
toSymbol.CenterOnAscent = fromSymbol.CenterOnAscent;
toSymbol.CharacterIndex = fromSymbol.CharacterIndex;
toSymbol.Color = fromSymbol.Color;
toSymbol.Custom = fromSymbol.Custom;
toSymbol.Font = toSymbol.Font;
toSymbol.Outline = fromSymbol.Outline;
toSymbol.OutlineColor = fromSymbol.OutlineColor;
toSymbol.Rotation = fromSymbol.Rotation;
toSymbol.Size = fromSymbol.Size;
toSymbol.Style = fromSymbol.Style;
toSymbol.SymbolType = fromSymbol.SymbolType;
}
private void DeconvertTextSymbol(MapObjects2.TextSymbol fromSymbol, TextSymbolStruct toSymbol)
{
toSymbol.TextColor = System.Drawing.ColorTranslator.FromWin32((int)fromSymbol.Color);
toSymbol.Fitted = fromSymbol.Fitted;
toSymbol.TextFont = fromSymbol.Font;
toSymbol.Height = fromSymbol.Height;
toSymbol.HorizontalAlignment = (short)fromSymbol.HorizontalAlignment;
toSymbol.VerticalAlignment = (short)fromSymbol.VerticalAlignment;
toSymbol.Rotation = fromSymbol.Rotation;
}
/// <summary>
/// ��ͼ������Ψһֵ��Ⱦ
/// </summary>
/// <param name="layer"></param>
/// <param name="renderFieldName"></param>
public MapObjects2.ValueMapRenderer GetUniqueValueRender(MapObjects2.MapLayer layer, string renderFieldName)
{
MapObjects2.ValueMapRenderer oValueMapRender = new MapObjects2.ValueMapRendererClass();
MapObjects2.Recordset oRecords = layer.Records;
MapObjects2.Strings oStrings = new StringsClass();
if (layer.shapeType == ShapeTypeConstants.moShapeTypePoint)
oValueMapRender.SymbolType = SymbolTypeConstants.moPointSymbol;
else if (layer.shapeType == ShapeTypeConstants.moShapeTypeLine)
oValueMapRender.SymbolType = SymbolTypeConstants.moLineSymbol;
else if (layer.shapeType == ShapeTypeConstants.moShapeTypePolygon)
oValueMapRender.SymbolType = SymbolTypeConstants.moFillSymbol;
oValueMapRender.Field = renderFieldName;
oStrings.Unique = true;
oRecords.MoveFirst();
while (!oRecords.EOF)
{
oStrings.Add(oRecords.Fields.Item(renderFieldName).ValueAsString);
oRecords.MoveNext();
}
oValueMapRender.ValueCount = oStrings.Count;
for (short i = 0; i < oStrings.Count; i++) oValueMapRender.set_Value(i, oStrings.Item(i));
return oValueMapRender;
}
private void DeconvertSymbol(MapObjects2.Symbol fromSymbol, SymbolStruct toSymbol)
{
toSymbol.CenterOnAscent = fromSymbol.CenterOnAscent;
toSymbol.CharacterIndex = fromSymbol.CharacterIndex;
toSymbol.FillColor = System.Drawing.ColorTranslator.FromWin32((int)fromSymbol.Color);
toSymbol.CustomSymbol = fromSymbol.Custom;
toSymbol.FontName = fromSymbol.Font.Name;
toSymbol.OutLine = fromSymbol.Outline;
toSymbol.OutLineColor = System.Drawing.ColorTranslator.FromWin32((int)fromSymbol.OutlineColor);
toSymbol.Rotation = fromSymbol.Rotation;
toSymbol.Size = fromSymbol.Size;
toSymbol.Style = fromSymbol.Style;
toSymbol.SymbolType = (short)fromSymbol.SymbolType;
}
private void InitUniqueValueRenderLab(MapObjects2.ValueMapRenderer render)
{
this.cbbFields_UniqueValue.Text = (render as MapObjects2.ValueMapRenderer).Field;
}
public ImageLayerInfoStruct LoadLayerInfos(MapObjects2.ImageLayer layer,string fileName,double minScale,double maxScale)
{
ImageLayerInfoStruct oImageLayerStruct = new ImageLayerInfoStruct();
oImageLayerStruct.FileName = fileName;
oImageLayerStruct.MinLevel = minScale;
oImageLayerStruct.MaxLevel = maxScale;
oImageLayerStruct.Name = layer.Name;
return oImageLayerStruct;
}
void Instance_PointFetchedEvent(object sender, MapObjects2.Point e)
{
this.txtCoordX.Text = e.X.ToString();
this.txtCoordY.Text = e.Y.ToString();
}
private void InitLabelRenderLab(MapObjects2.LabelRenderer render)
{
this.cbbLabelField.Text = render.Field;
this.txtFont.Text = render.get_Symbol(0).Font.Name;
this.pnlLabelColor.BackColor = Utilities.Converter.ConvertIntegerToSystemColor((int)render.get_Symbol(0).Color);
this.cbbLabelHorizonalAligment.Text = (render.get_Symbol(0).HorizontalAlignment).ToString();
this.cbbLabelVerticalAligment.Text = (render.get_Symbol(0).VerticalAlignment).ToString();
this.numLabelSize.Value = render.get_Symbol(0).Font.Size;
this.numLabelRotation.Value = (decimal)render.get_Symbol(0).Rotation;
this.ckbAllowOverwrite.Checked = render.AllowDuplicates;
this.ckbLabelScale.Checked = render.Flip;
}
private ClassBreakRenderStruct ExportClassBreakRender(MapObjects2.ClassBreaksRenderer render)
{
ClassBreakRenderStruct oClassBreakRender = new ClassBreakRenderStruct();
short iIndex = 0;
oClassBreakRender.BreakCount = render.BreakCount;
oClassBreakRender.DrawBackground = render.DrawBackground;
oClassBreakRender.Field = render.Field;
oClassBreakRender.SymbolType = (short)render.SymbolType;
oClassBreakRender.Tag = render.Tag;
double dBreak = render.get_Break(iIndex);
while (dBreak != double.NaN)
{
oClassBreakRender.BreakList.Add(dBreak);
iIndex++;
dBreak = render.get_Break(iIndex);
}
oClassBreakRender.StartColor = System.Drawing.ColorTranslator.FromWin32((int)render.get_Symbol((short)0).Color);
oClassBreakRender.EndColor = System.Drawing.ColorTranslator.FromWin32((int)render.get_Symbol((short)(render.BreakCount - 1)).Color);
return oClassBreakRender;
}
static object toObject(MapObjects2.Point poi)
{
return (object)poi;
}
/// <summary>
/// �������úõ���ʽ��ӵ�Ψһֵ��Ⱦ��ȥ
/// </summary>
/// <param name="layer"></param>
/// <param name="symbols"></param>
public void SetSymbolsToValueRenderedLayer(MapObjects2.MapLayer layer, Dictionary<string, MapObjects2.Symbol> symbols)
{
if (layer.Renderer == null)
throw new Exception("the layer has not set a render.");
if (layer.Renderer is MapObjects2.ValueMapRenderer)
throw new Exception("the layer has a render,but not a valuerender.");
Dictionary<string, MapObjects2.Symbol>.KeyCollection oKeys = symbols.Keys;
MapObjects2.ValueMapRenderer oValueRender = layer.Renderer as MapObjects2.ValueMapRenderer;
int iValueIndex = -1;
MapObjects2.Symbol oSymbol = null;
foreach (string sKey in oKeys)
{
iValueIndex = this.GetValueIndexByRenderValue(oValueRender, sKey);
if (iValueIndex != -1 && symbols.TryGetValue(sKey, out oSymbol))
this.CopySymbolToAnother(oSymbol, oValueRender.get_Symbol((short)iValueIndex));
}
}
private GroupRenderStruct ExportGroupRender(MapObjects2.GroupRenderer render)
{
GroupRenderStruct oGroupRender = new GroupRenderStruct();
short iIndex = 0;
oGroupRender.DrawBackground = render.DrawBackground;
oGroupRender.Tag = render.Tag;
object oMapSubRender = render.get_Renderer(iIndex);
while (oMapSubRender != null)
{
if (oMapSubRender is MapObjects2.ValueMapRenderer)
{
ValueRenderStruct oValueRender = this.ExportValueRender(oMapSubRender as MapObjects2.ValueMapRenderer);
oGroupRender.RenderList.Add(oValueRender);
}
else if (oMapSubRender is MapObjects2.ClassBreaksRenderer)
{
ClassBreakRenderStruct oClassBreakRender = this.ExportClassBreakRender(oMapSubRender as MapObjects2.ClassBreaksRenderer);
oGroupRender.RenderList.Add(oClassBreakRender);
}
else if (oMapSubRender is MapObjects2.LabelRenderer)
{
LabelRenderStruct oLabelRender = this.ExportLabelRender(oMapSubRender as MapObjects2.LabelRenderer);
oGroupRender.RenderList.Add(oLabelRender);
}
iIndex++;
oMapSubRender = render.get_Renderer(iIndex);
}
return oGroupRender;
}
private int GetValueIndexByRenderValue(MapObjects2.ValueMapRenderer render, string renderValue)
{
int iValueCount = render.ValueCount;
for (short i = 0; i < iValueCount; i++)
{
if (renderValue.Equals(render.get_Value(i)))
return (int)i;
}
return -1;
}
private LabelRenderStruct ExportLabelRender(MapObjects2.LabelRenderer render)
{
LabelRenderStruct oLabelRender = new LabelRenderStruct();
oLabelRender.AllowDuplicates = render.AllowDuplicates;
oLabelRender.DrawBackground = render.DrawBackground;
oLabelRender.Field = render.Field;
oLabelRender.FittedField = render.FittedField;
oLabelRender.Flip = render.Flip;
oLabelRender.HeightField = render.HeightField;
oLabelRender.LevelField = render.LevelField;
oLabelRender.MaxLevel = render.MaxLevel;
oLabelRender.MinLevel = render.MinLevel;
oLabelRender.RotationField = render.RotationField;
oLabelRender.SplinedText = render.SplinedText;
oLabelRender.SymbolCount = render.SymbolCount;
oLabelRender.SymbolField = render.SymbolField;
oLabelRender.Tag = render.Tag;
oLabelRender.XOffsetField = render.XOffsetField;
oLabelRender.YOffsetField = render.YOffsetField;
short iIndex = 0;
MapObjects2.TextSymbol oMapTextSymbol = render.get_Symbol(iIndex);
while (oMapTextSymbol != null)
{
TextSymbolStruct oTextSymbol = new TextSymbolStruct();
this.DeconvertTextSymbol(oMapTextSymbol, oTextSymbol);
oLabelRender.SymbolList.Add(oTextSymbol);
iIndex++;
oMapTextSymbol = render.get_Symbol(iIndex);
}
return oLabelRender;
}
public short GetSymbolStyleByName(MapObjects2.ShapeTypeConstants shapeType, string symbolStyleName)
{
if (shapeType == ShapeTypeConstants.moShapeTypePoint)
{
if (symbolStyleName == MarkerStyleConstants.moCircleMarker.ToString())
return (short)MarkerStyleConstants.moCircleMarker;
else if (symbolStyleName == MarkerStyleConstants.moCrossMarker.ToString())
return (short)MarkerStyleConstants.moCrossMarker;
else if (symbolStyleName == MarkerStyleConstants.moSquareMarker.ToString())
return (short)MarkerStyleConstants.moSquareMarker;
else if (symbolStyleName == MarkerStyleConstants.moTriangleMarker.ToString())
return (short)MarkerStyleConstants.moTriangleMarker;
else if (symbolStyleName == MarkerStyleConstants.moTrueTypeMarker.ToString())
return (short)MarkerStyleConstants.moTrueTypeMarker;
}
else if (shapeType == ShapeTypeConstants.moShapeTypeLine)
{
if (symbolStyleName == LineStyleConstants.moDashDotDotLine.ToString())
return (short)LineStyleConstants.moDashDotDotLine;
else if (symbolStyleName == LineStyleConstants.moDashDotLine.ToString())
return (short)LineStyleConstants.moDashDotLine;
else if (symbolStyleName == LineStyleConstants.moDashLine.ToString())
return (short)LineStyleConstants.moDashLine;
else if (symbolStyleName == LineStyleConstants.moDotLine.ToString())
return (short)LineStyleConstants.moDotLine;
else if (symbolStyleName == LineStyleConstants.moSolidLine.ToString())
return (short)LineStyleConstants.moSolidLine;
}
else if (shapeType == ShapeTypeConstants.moShapeTypePolygon)
{
if (symbolStyleName == FillStyleConstants.moCrossFill.ToString())
return (short)FillStyleConstants.moCrossFill;
else if (symbolStyleName == FillStyleConstants.moDarkGrayFill.ToString())
return (short)FillStyleConstants.moDarkGrayFill;
else if (symbolStyleName == FillStyleConstants.moDiagonalCrossFill.ToString())
return (short)FillStyleConstants.moDiagonalCrossFill;
else if (symbolStyleName == FillStyleConstants.moDownwardDiagonalFill.ToString())
return (short)FillStyleConstants.moDownwardDiagonalFill;
else if (symbolStyleName == FillStyleConstants.moGrayFill.ToString())
return (short)FillStyleConstants.moGrayFill;
else if (symbolStyleName == FillStyleConstants.moHorizontalFill.ToString())
return (short)FillStyleConstants.moHorizontalFill;
else if (symbolStyleName == FillStyleConstants.moLightGrayFill.ToString())
return (short)FillStyleConstants.moLightGrayFill;
else if (symbolStyleName == FillStyleConstants.moSolidFill.ToString())
return (short)FillStyleConstants.moSolidFill;
else if (symbolStyleName == FillStyleConstants.moTransparentFill.ToString())
return (short)FillStyleConstants.moTransparentFill;
else if (symbolStyleName == FillStyleConstants.moUpwardDiagonalFill.ToString())
return (short)FillStyleConstants.moUpwardDiagonalFill;
else if (symbolStyleName == FillStyleConstants.moVerticalFill.ToString())
return (short)FillStyleConstants.moVerticalFill;
}
return (short)-1;
}
private IRenderStruct ExportLayerRender(MapObjects2.MapLayer layer)
{
object oLayerRender = layer.Renderer;
if (oLayerRender == null) return null;
if (oLayerRender is MapObjects2.ValueMapRenderer) return this.ExportValueRender(layer.Renderer as MapObjects2.ValueMapRenderer);
else if (oLayerRender is MapObjects2.ClassBreaksRenderer) return this.ExportClassBreakRender(layer.Renderer as MapObjects2.ClassBreaksRenderer);
else if (oLayerRender is MapObjects2.LabelRenderer) return this.ExportLabelRender(layer.Renderer as MapObjects2.LabelRenderer);
else if (oLayerRender is MapObjects2.GroupRenderer) return this.ExportGroupRender(layer.Renderer as MapObjects2.GroupRenderer);
else return null;
}
