/// <summary>
/// Creates a new instance of the PointSizeRangeEventArgs derived from a PointSizeRange
/// </summary>
/// <param name="range"></param>
public SizeRangeEventArgs(FeatureSizeRange range)
{
_startSize = range.Start;
_endSize = range.End;
_template = range.Symbolizer;
_useSizeRange = range.UseSizeRange;
}
/// <summary>
/// Creates a new instance of PointSizeRangeEventArgs
/// </summary>
public SizeRangeEventArgs(double startSize, double endSize, IFeatureSymbolizer template, bool useSizeRange)
{
_startSize = startSize;
_endSize = endSize;
_template = template;
_useSizeRange = useSizeRange;
}
/// <summary>
/// Given a size, this will return the native symbolizer that has been adjusted to the specified size.
/// </summary>
/// <param name="size">The size of the symbol</param>
/// <param name="color">The color of the symbol</param>
/// <returns>The adjusted symbolizer.</returns>
public IFeatureSymbolizer GetSymbolizer(double size, Color color)
{
IFeatureSymbolizer copy = Symbolizer.Copy();
// preserve aspect ratio, larger dimension specified
IPointSymbolizer ps = copy as IPointSymbolizer;
if (ps != null)
{
Size2D s = ps.GetSize();
double ratio = size / Math.Max(s.Width, s.Height);
s.Width *= ratio;
s.Height *= ratio;
ps.SetSize(s);
ps.SetFillColor(color);
}
ILineSymbolizer ls = copy as ILineSymbolizer;
if (ls != null)
{
ls.SetWidth(size);
ls.SetFillColor(color);
}
return(copy);
}
/// <summary>
/// Creates a new instance of the PointSizeRangeEventArgs derived from a PointSizeRange
/// </summary>
/// <param name="range"></param>
public SizeRangeEventArgs(FeatureSizeRange range)
{
_startSize = range.Start;
_endSize = range.End;
_template = range.Symbolizer;
_useSizeRange = range.UseSizeRange;
}
/// <summary>
/// Updates the preview display using the specified symbolizer
/// </summary>
/// <param name="symbolizer">The symbolizer displayed in the preview</param>
public void UpdatePreview(IFeatureSymbolizer symbolizer)
{
if (symbolizer == null)
{
return;
}
_symbolizer = symbolizer;
Graphics g = CreateGraphics();
Rectangle rect = new Rectangle(0, 0, this.Width, this.Height);
if (symbolizer is PointSymbolizer)
{
DrawPointSymbolizer(symbolizer as PointSymbolizer, g, rect);
}
else if (symbolizer is LineSymbolizer)
{
DrawLineSymbolizer(symbolizer as LineSymbolizer, g, rect);
}
else if (symbolizer is PolygonSymbolizer)
{
DrawPolygonSymbolizer(symbolizer as PolygonSymbolizer, g, rect);
}
else
{
symbolizer.Draw(g, rect);
}
g.Dispose();
}
/// <summary>
/// Updates the preview display using the specified symbolizer.
/// </summary>
/// <param name="symbolizer">The symbolizer displayed in the preview.</param>
public void UpdatePreview(IFeatureSymbolizer symbolizer)
{
if (symbolizer == null)
{
return;
}
_symbolizer = symbolizer;
using Graphics g = CreateGraphics();
Rectangle rect = new(0, 0, Width, Height);
if (symbolizer is PointSymbolizer pointSymbolizer)
{
DrawPointSymbolizer(pointSymbolizer, g, rect);
return;
}
if (symbolizer is LineSymbolizer lineSymbolizer)
{
DrawLineSymbolizer(lineSymbolizer, g, rect);
return;
}
if (symbolizer is PolygonSymbolizer polygonSymbolizer)
{
DrawPolygonSymbolizer(polygonSymbolizer, g, rect);
}
else
{
symbolizer.Draw(g, rect);
}
}
/// <summary>
/// Creates a new instance of PointSizeRangeEventArgs
/// </summary>
public SizeRangeEventArgs(double startSize, double endSize, IFeatureSymbolizer template, bool useSizeRange)
{
_startSize = startSize;
_endSize = endSize;
_template = template;
_useSizeRange = useSizeRange;
}
/// <summary>
/// Updates the preview display using the specified symbolizer
/// </summary>
/// <param name="symbolizer">The symbolizer displayed in the preview</param>
public void UpdatePreview(IFeatureSymbolizer symbolizer)
{
if (symbolizer == null) return;
_symbolizer = symbolizer;
Graphics g = CreateGraphics();
Rectangle rect = new Rectangle(0, 0, this.Width, this.Height);
if (symbolizer is PointSymbolizer)
{
DrawPointSymbolizer(symbolizer as PointSymbolizer, g, rect);
}
else if (symbolizer is LineSymbolizer)
{
DrawLineSymbolizer(symbolizer as LineSymbolizer, g, rect);
}
else if (symbolizer is PolygonSymbolizer)
{
DrawPolygonSymbolizer(symbolizer as PolygonSymbolizer, g, rect);
}
else
{
symbolizer.Draw(g, rect);
}
g.Dispose();
}
/// <summary>
/// Creates a new instance of CustomSymbolizer
/// </summary>
public CustomSymbolizer(IFeatureSymbolizer symbolizer, string uniqueName, string name, string categoryName)
{
_symbolizer = symbolizer;
_uniqueName = uniqueName;
_name = name;
_categoryName = categoryName;
_type = GetSymbolType(_symbolizer);
}
/// <summary>
/// Constructs a new instance of a custom symbolizer
/// </summary>
public CustomSymbolizer()
{
_symbolizer = new PointSymbolizer();
_uniqueName = "symbol 001";
_name = "symbol 001";
_categoryName = "default";
_type = GetSymbolType(_symbolizer);
}
/// <summary>
/// This looks like a function created by Mr. Jiri and not commented on.
/// </summary>
/// <param name="symbolCategories"></param>
/// <param name="symbolizer"></param>
public AddCustomSymbolDialog(List <string> symbolCategories, IFeatureSymbolizer symbolizer)
{
InitializeComponent();
_symbolizer = symbolizer;
_categories = symbolCategories;
UpdateCategories();
}
/// <summary>
/// Constructs a new instance of a custom symbolizer
/// </summary>
public CustomSymbolizer()
{
_symbolizer = new PointSymbolizer();
_uniqueName = "symbol 001";
_name = "symbol 001";
_categoryName = "default";
_type = GetSymbolType(_symbolizer);
}
/// <summary>
/// Creates a new instance of CustomSymbolizer
/// </summary>
public CustomSymbolizer(IFeatureSymbolizer symbolizer, string uniqueName, string name, string categoryName)
{
_symbolizer = symbolizer;
_uniqueName = uniqueName;
_name = name;
_categoryName = categoryName;
_type = GetSymbolType(_symbolizer);
}
/// <summary>
/// Calculates the scale based on the IFeatureSymbolizers ScaleMode.
/// </summary>
/// <param name="self">The IFeatureSymbolizer.</param>
/// <param name="args">The MapArgs needed for calculation.</param>
/// <returns>Returns args.ImageRectangle.Width / args.GeographicExtents.Width if ScaleMode is Geographic, otherwise this returns 1.</returns>
public static double GetScale(this IFeatureSymbolizer self, MapArgs args)
{
if (self.ScaleMode == ScaleMode.Geographic)
{
return((args.ImageRectangle.Width / args.GeographicExtents.Width) * args.Factor);
}
return(1 * args.Factor);
}
private void BtnUpClick(object sender, EventArgs e)
{
IFeatureSymbolizer sym = lbxItems.SelectedItem as IFeatureSymbolizer;
if (sym == null)
{
return;
}
_symbolizers.IncreaseIndex(sym);
RefreshList();
lbxItems.SelectedItem = sym;
OnOrderChanged();
}
private static SymbolizerType GetSymbolType(IFeatureSymbolizer symbolizer)
{
if (symbolizer is PointSymbolizer)
{
return(SymbolizerType.Point);
}
if (symbolizer is LineSymbolizer)
{
return(SymbolizerType.Line);
}
if (symbolizer is PolygonSymbolizer)
{
return(SymbolizerType.Polygon);
}
return(SymbolizerType.Unknown);
}
private SymbolizerTypes GetSymbolType(IFeatureSymbolizer symbolizer)
{
if (symbolizer is PointSymbolizer)
{
return SymbolizerTypes.Point;
}
if (symbolizer is LineSymbolizer)
{
return SymbolizerTypes.Line;
}
if (symbolizer is PolygonSymbolizer)
{
return SymbolizerTypes.Polygon;
}
return SymbolizerTypes.Unknown;
}
private void btnRemove_Click(object sender, EventArgs e)
{
if (lbxItems.SelectedItem == null)
{
return;
}
IFeatureSymbolizer sym = lbxItems.SelectedItem as IFeatureSymbolizer;
int index = _symbolizers.IndexOf(sym);
_symbolizers.Remove(sym);
RefreshList();
if (_symbolizers.Count == 0)
{
return;
}
if (index >= _symbolizers.Count)
{
index -= 1;
}
lbxItems.SelectedIndex = index;
OnRemoveClick();
}
/// <summary>
/// This forces the creation of a category for the specified symbolizer, if it doesn't exist.
/// This will add the specified feature to the category. Be sure that the symbolizer type
/// matches the feature type.
/// </summary>
/// <param name="index">
/// The integer index of the shape to control.
/// </param>
/// <param name="symbolizer">
/// The symbolizer to assign.
/// </param>
public void SetShapeSymbolizer(int index, IFeatureSymbolizer symbolizer)
{
foreach (IFeatureCategory category in Symbology.GetCategories())
{
if (category.Symbolizer != symbolizer)
{
continue;
}
if (DataSet.IndexMode)
{
_drawnStates[index].Category = category;
_drawnStates[index].Visible = true;
}
else
{
IFeature f = DataSet.Features[index];
DrawingFilter.DrawnStates[f].SchemeCategory = category;
}
Invalidate();
return;
}
IFeatureCategory cat = Symbology.CreateNewCategory(Color.Blue, 1) as IFeatureCategory;
if (cat != null)
{
cat.Symbolizer = symbolizer;
Symbology.AddCategory(cat);
if (DataSet.IndexMode)
{
_drawnStates[index].Category = cat;
_drawnStates[index].Visible = true;
}
else
{
IFeature f = DataSet.Features[index];
DrawingFilter.DrawnStates[f].SchemeCategory = cat;
}
Invalidate();
}
}
private void UpdatePreview(IFeatureSymbolizer symbolizer)
{
symbolPreview1.UpdatePreview(symbolizer);
}
/// <summary>
/// Disposes memory objects
/// </summary>
/// <param name="disposeManagedResources">
/// </param>
protected override void Dispose(bool disposeManagedResources)
{
if (disposeManagedResources)
{
ViewAttributes = null;
LabelSetup = null;
SnapShotTaken = null;
SchemeApplied = null;
_name = null;
_scheme = null;
_selection = null;
_drawingFilter = null;
_featureSymbolizer = null;
_selectionFeatureSymbolizer = null;
_categoryExtents = null;
_drawnStates = null;
}
if (_labelLayer != null)
{
_labelLayer.Dispose();
}
base.Dispose(disposeManagedResources);
}
public FeatureSymbolCollection(IFeatureSymbolizer parent) : base(parent)
{
}
/// <summary>
/// Creates a new instance of FeatureSymbolizerEventArgs
/// </summary>
public FeatureSymbolizerEventArgs(IFeatureSymbolizer symbolizer)
{
Symbolizer = symbolizer;
}
/// <summary>
/// Creates a new instance of SymbolPreview control
/// </summary>
public SymbolPreview()
{
_symbolizer = new PointSymbolizer();
}
/// <summary>
/// Creates a new instance of FeatureSymbolizerEventArgs
/// </summary>
public FeatureSymbolizerEventArgs(IFeatureSymbolizer symbolizer)
{
Symbolizer = symbolizer;
}
/// <summary>
/// Gets or sets the Point Size Range
/// </summary>
/// <param name="symbolizer"></param>
/// <param name="start"></param>
/// <param name="end"></param>
public FeatureSizeRange(IFeatureSymbolizer symbolizer, double start, double end)
{
_symbolizer = symbolizer;
_start = start;
_end = end;
}
/// <summary>
/// Gets or sets the Point Size Range
/// </summary>
/// <param name="symbolizer"></param>
/// <param name="start"></param>
/// <param name="end"></param>
public FeatureSizeRange(IFeatureSymbolizer symbolizer, double start, double end)
{
_symbolizer = symbolizer;
_start = start;
_end = end;
}
/// <summary>
/// Initializes a new instance of the <see cref="FeatureSizeRange"/> class.
/// </summary>
/// <param name="symbolizer">The symbolizer.</param>
/// <param name="start">The minimum size.</param>
/// <param name="end">The maximum size.</param>
public FeatureSizeRange(IFeatureSymbolizer symbolizer, double start, double end)
{
Symbolizer = symbolizer;
Start = start;
End = end;
}
/// <summary>
/// Initializes a new instance of the <see cref="SymbolPreview"/> class.
/// </summary>
public SymbolPreview()
{
_symbolizer = new PointSymbolizer();
}
/// <summary>
/// This looks like a function created by Mr. Jiri and not commented on.
/// </summary>
/// <param name="symbolCategories"></param>
/// <param name="symbolizer"></param>
public AddCustomSymbolDialog(List<string> symbolCategories, IFeatureSymbolizer symbolizer)
{
InitializeComponent();
_symbolizer = symbolizer;
_categories = symbolCategories;
UpdateCategories();
}
private void UpdatePreview(IFeatureSymbolizer symbolizer)
{
symbolPreview1.UpdatePreview(symbolizer);
}
public static IFeatureSymbolizer OpenFeatureSymbolizer()
{
IFeatureSymbolizer featureSymbolizer = Open <IFeatureSymbolizer>("*.dsst|*.dsst");
return(featureSymbolizer);
}
public static void SaveFeatureSymbolizer(IFeatureSymbolizer symbolizer)
{
Save(symbolizer, "*.dsst|*.dsst");
}
/// <summary>
/// Gets the smoothing mode based on the IFeatureSymbolizer.
/// </summary>
/// <param name="self">The IFeatureSymbolizer.</param>
/// <returns>Returns AntiAlias if smothing is true, otherwise none.</returns>
public static SmoothingMode GetSmoothingMode(this IFeatureSymbolizer self)
{
return(self.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None);
}
