/// <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> /// 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> /// 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> /// 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> /// 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(); }
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); }