public static ShieldSymbol ReadFrom(ArcXmlReader reader)
{
try
{
ShieldSymbol shieldSymbol = new ShieldSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "antialiasing": shieldSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "bottomcolor": shieldSymbol.BottomColor = ColorConverter.ToColor(value); break;
case "font": shieldSymbol.Font = value; break;
case "fontcolor": shieldSymbol.FontColor = ColorConverter.ToColor(value); break;
case "fontsize": shieldSymbol.FontSize = Convert.ToInt32(value); break;
case "fontstyle": shieldSymbol.FontStyle = (FontStyle)ArcXmlEnumConverter.ToEnum(typeof(FontStyle), value); break;
case "labelmode": shieldSymbol.LabelMode = (ShieldLabelMode)ArcXmlEnumConverter.ToEnum(typeof(ShieldLabelMode), value); break;
case "middlecolor": shieldSymbol.MiddleColor = ColorConverter.ToColor(value); break;
case "minsize": shieldSymbol.MinSize = Convert.ToInt32(value); break;
case "shadow": shieldSymbol.Shadow = ColorConverter.ToColor(value); break;
case "topcolor": shieldSymbol.TopColor = ColorConverter.ToColor(value); break;
case "transparency": shieldSymbol.Transparency = Convert.ToDouble(value); break;
}
}
}
reader.MoveToElement();
}
return(shieldSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static ChartSymbol ReadFrom(ArcXmlReader reader)
{
try
{
ChartSymbol chartSymbol = new ChartSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "antialiasing": chartSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "maxsize": chartSymbol.MaxSize = Convert.ToInt32(value); break;
case "maxvalue": chartSymbol.MaxValue = Convert.ToInt32(value); break;
case "minsize": chartSymbol.MinSize = Convert.ToInt32(value); break;
case "minvalue": chartSymbol.MinValue = Convert.ToInt32(value); break;
case "mode": chartSymbol.Mode = (ChartSymbolMode)ArcXmlEnumConverter.ToEnum(typeof(ChartSymbolMode), value); break;
case "outline": chartSymbol.Outline = ColorConverter.ToColor(value); break;
case "shadow": chartSymbol.Shadow = ColorConverter.ToColor(value); break;
case "size": chartSymbol.Size = Convert.ToInt32(value); break;
case "sizefield": chartSymbol.SizeField = value; break;
case "transparency": chartSymbol.Transparency = Convert.ToDouble(value); break;
case "width": chartSymbol.Width = Convert.ToInt32(value); break;
}
}
}
reader.MoveToElement();
}
return(chartSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static CallOutMarkerSymbol ReadFrom(ArcXmlReader reader)
{
try
{
CallOutMarkerSymbol callOutMarkerSymbol = new CallOutMarkerSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "antialiasing": callOutMarkerSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "backcolor": callOutMarkerSymbol.BackColor = ColorConverter.ToColor(value); break;
case "boundarycolor": callOutMarkerSymbol.BoundaryColor = ColorConverter.ToColor(value); break;
case "font": callOutMarkerSymbol.Font = value; break;
case "fontcolor": callOutMarkerSymbol.FontColor = ColorConverter.ToColor(value); break;
case "fontsize": callOutMarkerSymbol.FontSize = Convert.ToInt32(value); break;
case "fontstyle": callOutMarkerSymbol.FontStyle = (FontStyle)ArcXmlEnumConverter.ToEnum(typeof(FontStyle), value); break;
case "glowing": callOutMarkerSymbol.Glowing = ColorConverter.ToColor(value); break;
case "interval": callOutMarkerSymbol.Interval = Convert.ToInt32(value); break;
case "outline": callOutMarkerSymbol.Outline = ColorConverter.ToColor(value); break;
case "shadow": callOutMarkerSymbol.Shadow = ColorConverter.ToColor(value); break;
case "transparency": callOutMarkerSymbol.Transparency = Convert.ToDouble(value); break;
}
}
}
reader.MoveToElement();
}
return(callOutMarkerSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static SimpleMarkerSymbol ReadFrom(ArcXmlReader reader)
{
try
{
SimpleMarkerSymbol simpleMarkerSymbol = new SimpleMarkerSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "antialiasing": simpleMarkerSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "color": simpleMarkerSymbol.Color = ColorConverter.ToColor(value); break;
case "outline": simpleMarkerSymbol.Outline = ColorConverter.ToColor(value); break;
case "overlap": simpleMarkerSymbol.Overlap = Convert.ToBoolean(value); break;
case "shadow": simpleMarkerSymbol.Shadow = ColorConverter.ToColor(value); break;
case "transparency": simpleMarkerSymbol.Transparency = Convert.ToDouble(value); break;
case "type": simpleMarkerSymbol.Type = (MarkerType)ArcXmlEnumConverter.ToEnum(typeof(MarkerType), value); break;
case "usecentroid": simpleMarkerSymbol.UseCentroid = Convert.ToBoolean(value); break;
case "width": simpleMarkerSymbol.Width = Convert.ToInt32(value); break;
}
}
}
reader.MoveToElement();
}
return(simpleMarkerSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static HashLineSymbol ReadFrom(ArcXmlReader reader)
{
try
{
HashLineSymbol hashLineSymbol = new HashLineSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "antialiasing": hashLineSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "color": hashLineSymbol.Color = ColorConverter.ToColor(value); break;
case "interval": hashLineSymbol.Interval = Convert.ToInt32(value); break;
case "linethickness": hashLineSymbol.LineThickness = Convert.ToInt32(value); break;
case "tickthickness": hashLineSymbol.TickThickness = Convert.ToInt32(value); break;
case "overlap": hashLineSymbol.Overlap = Convert.ToBoolean(value); break;
case "transparency": hashLineSymbol.Transparency = Convert.ToDouble(value); break;
case "type": hashLineSymbol.Type = (HashLineType)ArcXmlEnumConverter.ToEnum(typeof(HashLineType), value); break;
case "width": hashLineSymbol.Width = Convert.ToInt32(value); break;
}
}
}
reader.MoveToElement();
}
return(hashLineSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static GradientFillSymbol ReadFrom(ArcXmlReader reader)
{
try
{
GradientFillSymbol gradientFillSymbol = new GradientFillSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "antialiasing": gradientFillSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "finishcolor": gradientFillSymbol.FinishColor = ColorConverter.ToColor(value); break;
case "overlap": gradientFillSymbol.Overlap = Convert.ToBoolean(value); break;
case "startcolor": gradientFillSymbol.StartColor = ColorConverter.ToColor(value); break;
case "transparency": gradientFillSymbol.Transparency = Convert.ToDouble(value); break;
case "type": gradientFillSymbol.Type = (GradientFillType)ArcXmlEnumConverter.ToEnum(typeof(GradientFillType), value); break;
}
}
}
reader.MoveToElement();
}
return(gradientFillSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static RasterRange ReadFrom(ArcXmlReader reader)
{
try
{
RasterRange rasterRange = new RasterRange();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "color": rasterRange.Color = ColorConverter.ToColor(value); break;
case "equality": rasterRange.Equality = (RangeEquality)ArcXmlEnumConverter.ToEnum(typeof(RangeEquality), value); break;
case "label": rasterRange.Label = value; break;
case "lower": rasterRange.Lower = Convert.ToDouble(value); break;
case "transparency": rasterRange.Transparency = Convert.ToDouble(value); break;
case "upper": rasterRange.Upper = Convert.ToDouble(value); break;
}
}
}
reader.MoveToElement();
}
return(rasterRange);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static ChartValue ReadFrom(ArcXmlReader reader)
{
try
{
ChartValue chartValue = new ChartValue();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "color": chartValue.Color = ColorConverter.ToColor(value); break;
case "lookupfield": chartValue.LookUpField = value; break;
case "lower": chartValue.Lower = Convert.ToInt32(value); break;
case "upper": chartValue.Upper = Convert.ToInt32(value); break;
case "value": chartValue.Value = Convert.ToInt32(value); break;
}
}
}
reader.MoveToElement();
}
return(chartValue);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static RasterExact ReadFrom(ArcXmlReader reader)
{
try
{
RasterExact rasterExact = new RasterExact();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "color": rasterExact.Color = ColorConverter.ToColor(value); break;
case "label": rasterExact.Label = value; break;
case "transparency": rasterExact.Transparency = Convert.ToDouble(value); break;
case "value": rasterExact.Value = value; break;
}
}
}
reader.MoveToElement();
}
return(rasterExact);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static Background ReadFrom(ArcXmlReader reader)
{
try
{
Background background = new Background();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "color": background.Color = ColorConverter.ToColor(value); break;
case "transcolor": background.TransparentColor = ColorConverter.ToColor(value); break;
}
}
}
reader.MoveToElement();
}
return(background);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static RasterShieldSymbol ReadFrom(ArcXmlReader reader)
{
try
{
RasterShieldSymbol rasterShieldSymbol = new RasterShieldSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "antialiasing": rasterShieldSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "boundary": rasterShieldSymbol.Boundary = Convert.ToBoolean(value); break;
case "font": rasterShieldSymbol.Font = value; break;
case "fontcolor": rasterShieldSymbol.FontColor = ColorConverter.ToColor(value); break;
case "fontsize": rasterShieldSymbol.FontSize = Convert.ToInt32(value); break;
case "fontstyle": rasterShieldSymbol.FontStyle = (FontStyle)ArcXmlEnumConverter.ToEnum(typeof(FontStyle), value); break;
case "image": rasterShieldSymbol.Image = value; break;
case "labelmode": rasterShieldSymbol.LabelMode = (ShieldLabelMode)ArcXmlEnumConverter.ToEnum(typeof(ShieldLabelMode), value); break;
case "printmode": rasterShieldSymbol.PrintMode = (PrintMode)ArcXmlEnumConverter.ToEnum(typeof(PrintMode), value); break;
case "shadow": rasterShieldSymbol.Shadow = ColorConverter.ToColor(value); break;
case "transparency": rasterShieldSymbol.Transparency = Convert.ToDouble(value); break;
case "url": rasterShieldSymbol.Url = value; break;
case "textposition":
string[] p = value.Split(new char[] { ',' });
rasterShieldSymbol.TextPosition = new NetTopologySuite.Geometries.Point(Convert.ToDouble(p[0]), Convert.ToDouble(p[1]));
break;
}
}
}
reader.MoveToElement();
}
return(rasterShieldSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public new static TextMarkerSymbol ReadFrom(ArcXmlReader reader)
{
try
{
TextMarkerSymbol textMarkerSymbol = new TextMarkerSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "angle": textMarkerSymbol.Angle = Convert.ToDouble(value); break;
case "antialiasing": textMarkerSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "blockout": textMarkerSymbol.BlockOut = ColorConverter.ToColor(value); break;
case "font": textMarkerSymbol.Font = value; break;
case "fontcolor": textMarkerSymbol.FontColor = ColorConverter.ToColor(value); break;
case "fontsize": textMarkerSymbol.FontSize = reader.ReadContentAsInt(); break;
case "fontstyle": textMarkerSymbol.FontStyle = (FontStyle)ArcXmlEnumConverter.ToEnum(typeof(FontStyle), value); break;
case "glowing": textMarkerSymbol.Glowing = ColorConverter.ToColor(value); break;
case "halignment": textMarkerSymbol.HAlignment = (HorizontalAlignment)ArcXmlEnumConverter.ToEnum(typeof(HorizontalAlignment), value); break;
case "interval": textMarkerSymbol.Interval = Convert.ToInt32(value); break;
case "outline": textMarkerSymbol.Outline = ColorConverter.ToColor(value); break;
case "overlap": textMarkerSymbol.Overlap = Convert.ToBoolean(value); break;
case "printmode": textMarkerSymbol.PrintMode = (PrintMode)ArcXmlEnumConverter.ToEnum(typeof(PrintMode), value); break;
case "shadow": textMarkerSymbol.Shadow = ColorConverter.ToColor(value); break;
case "transparency": textMarkerSymbol.Transparency = Convert.ToDouble(value); break;
case "valignment": textMarkerSymbol.VAlignment = (VerticalAlignment)ArcXmlEnumConverter.ToEnum(typeof(VerticalAlignment), value); break;
}
}
}
reader.MoveToElement();
}
return(textMarkerSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static SimplePolygonSymbol ReadFrom(ArcXmlReader reader)
{
try
{
SimplePolygonSymbol simplePolygonSymbol = new SimplePolygonSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "antialiasing": simplePolygonSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "boundary": simplePolygonSymbol.Boundary = Convert.ToBoolean(value); break;
case "boundarycaptype": simplePolygonSymbol.BoundaryCapType = (CapType)ArcXmlEnumConverter.ToEnum(typeof(CapType), value); break;
case "boundarycolor": simplePolygonSymbol.BoundaryColor = Color.FromArgb(simplePolygonSymbol.BoundaryColor.A, ColorConverter.ToColor(value)); break;
case "boundaryjointype": simplePolygonSymbol.BoundaryJoinType = (JoinType)ArcXmlEnumConverter.ToEnum(typeof(JoinType), value); break;
case "boundarytype": simplePolygonSymbol.BoundaryType = (LineType)ArcXmlEnumConverter.ToEnum(typeof(LineType), value); break;
case "boundarywidth": simplePolygonSymbol.BoundaryWidth = Convert.ToInt32(value); break;
case "fillcolor": simplePolygonSymbol.FillColor = Color.FromArgb(simplePolygonSymbol.FillColor.A, ColorConverter.ToColor(value)); break;
case "fillinterval": simplePolygonSymbol.FillInterval = Convert.ToInt32(value); break;
case "filltype": simplePolygonSymbol.FillType = (FillType)ArcXmlEnumConverter.ToEnum(typeof(FillType), value); break;
case "overlap": simplePolygonSymbol.Overlap = Convert.ToBoolean(value); break;
case "transparency": simplePolygonSymbol.Transparency = Convert.ToDouble(value); break;
}
}
}
reader.MoveToElement();
}
return(simplePolygonSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static RasterMarkerSymbol ReadFrom(ArcXmlReader reader)
{
try
{
RasterMarkerSymbol rasterMarkerSymbol = new RasterMarkerSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "antialiasing": rasterMarkerSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "image": rasterMarkerSymbol.Image = value; break;
case "overlap": rasterMarkerSymbol.Overlap = Convert.ToBoolean(value); break;
case "shadow": rasterMarkerSymbol.Shadow = ColorConverter.ToColor(value); break;
case "transparency": rasterMarkerSymbol.Transparency = Convert.ToDouble(value); break;
case "url": rasterMarkerSymbol.Url = value; break;
case "usecentroid": rasterMarkerSymbol.UseCentroid = Convert.ToBoolean(value); break;
case "hotspot":
string[] p = value.Split(new char[] { ',' });
rasterMarkerSymbol.Hotspot = new NetTopologySuite.Geometries.Point(Convert.ToDouble(p[0]), Convert.ToDouble(p[1]));
break;
case "size":
string[] d = value.Split(new char[] { ',' });
rasterMarkerSymbol.Width = Convert.ToInt32(d[0]);
rasterMarkerSymbol.Height = Convert.ToInt32(d[1]);
break;
}
}
}
reader.MoveToElement();
}
return(rasterMarkerSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}
public static TrueTypeMarkerSymbol ReadFrom(ArcXmlReader reader)
{
try
{
TrueTypeMarkerSymbol trueTypeMarkerSymbol = new TrueTypeMarkerSymbol();
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string value = reader.ReadContentAsString();
if (value.Length > 0)
{
switch (reader.Name)
{
case "angle": trueTypeMarkerSymbol.Angle = Convert.ToDouble(value); break;
case "anglefield": trueTypeMarkerSymbol.AngleField = value; break;
case "antialiasing": trueTypeMarkerSymbol.Antialiasing = Convert.ToBoolean(value); break;
case "character": trueTypeMarkerSymbol.Character = Convert.ToUInt16(value); break;
case "font": trueTypeMarkerSymbol.Font = value; break;
case "fontcolor": trueTypeMarkerSymbol.FontColor = ColorConverter.ToColor(value); break;
case "fontsize": trueTypeMarkerSymbol.FontSize = Convert.ToInt32(value); break;
case "fontstyle": trueTypeMarkerSymbol.FontStyle = (FontStyle)ArcXmlEnumConverter.ToEnum(typeof(FontStyle), value); break;
case "glowing": trueTypeMarkerSymbol.Glowing = ColorConverter.ToColor(value); break;
case "outline": trueTypeMarkerSymbol.Outline = ColorConverter.ToColor(value); break;
case "overlap": trueTypeMarkerSymbol.Overlap = Convert.ToBoolean(value); break;
case "rotatemethod": trueTypeMarkerSymbol.RotateMethod = (RotateMethod)ArcXmlEnumConverter.ToEnum(typeof(RotateMethod), value); break;
case "shadow": trueTypeMarkerSymbol.Shadow = ColorConverter.ToColor(value); break;
case "transparency": trueTypeMarkerSymbol.Transparency = Convert.ToDouble(value); break;
case "usecentroid": trueTypeMarkerSymbol.UseCentroid = Convert.ToBoolean(value); break;
}
}
}
reader.MoveToElement();
}
return(trueTypeMarkerSymbol);
}
catch (Exception ex)
{
if (ex is ArcXmlException)
{
throw ex;
}
else
{
throw new ArcXmlException(String.Format("Could not read {0} element.", XmlName), ex);
}
}
}