/// <summary>
/// Initializes this point size range control
/// </summary>
/// <param name="args"></param>
public void Initialize(SizeRangeEventArgs args)
{
if (_sizeRange == null)
{
return;
}
_sizeRange.Start = args.StartSize;
_sizeRange.End = args.EndSize;
_sizeRange.Symbolizer = args.Template;
_sizeRange.UseSizeRange = args.UseSizeRange;
IPointSymbolizer ps = args.Template as IPointSymbolizer;
if (ps != null)
{
psvStart.Visible = true;
psvEnd.Visible = true;
lsvStart.Visible = false;
lsvEnd.Visible = false;
}
ILineSymbolizer ls = args.Template as ILineSymbolizer;
if (ls != null)
{
lsvStart.Visible = true;
lsvEnd.Visible = true;
psvStart.Visible = false;
psvEnd.Visible = false;
}
}
// This draws the individual point features
private void DrawFeatures(MapArgs e, IEnumerable <IFeature> features, bool selected)
{
IDictionary <IFeature, IDrawnState> states = DrawingFilter.DrawnStates;
if (states == null)
{
return;
}
if (selected && !states.Any(_ => _.Value.IsSelected))
{
return;
}
Graphics g = e.Device ?? Graphics.FromImage(BackBuffer);
Matrix origTransform = g.Transform;
foreach (IFeature feature in features)
{
if (!states.ContainsKey(feature))
{
continue;
}
IDrawnState ds = states[feature];
if (ds == null || !ds.IsVisible || ds.SchemeCategory == null)
{
continue;
}
if (selected && !ds.IsSelected)
{
continue;
}
IPointCategory pc = ds.SchemeCategory as IPointCategory;
if (pc == null)
{
continue;
}
IPointSymbolizer ps = selected ? pc.SelectionSymbolizer : pc.Symbolizer;
if (ps == null)
{
continue;
}
foreach (Coordinate c in feature.Geometry.Coordinates)
{
DrawPoint(c.X, c.Y, e, ps, g, origTransform);
}
}
if (e.Device == null)
{
g.Dispose();
}
else
{
g.Transform = origTransform;
}
}
/// <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 LineDecoration
/// </summary>
public LineDecoration()
{
_symbol = new PointSymbolizer(SymbologyGlobal.RandomColor(), PointShape.Triangle, 10);
_flipAll = false;
_flipFirst = true;
_rotateWithLine = true;
_numSymbols = 2;
}
/// <summary>
/// Initializes a new instance of the <see cref="LineDecoration"/> class.
/// </summary>
public LineDecoration()
{
_symbol = new PointSymbolizer(SymbologyGlobal.RandomColor(), PointShape.Triangle, 10);
_flipAll = false;
_flipFirst = true;
_rotateWithLine = true;
_numSymbols = 2;
}
public static void DrawPoint(IPointSymbolizer symbolizer, Graphics g, IPoint point, MapViewport map)
{
if (point == null)
{
return;
}
symbolizer.Render(map, point, g);
}
public static RectangleF DrawPointEx(IPointSymbolizer symbolizer, Graphics g, IPoint point, MapViewport map)
{
if (point == null)
{
return(RectangleF.Empty);
}
symbolizer.Render(map, point, g);
return(((IPointSymbolizerEx)symbolizer).CanvasArea);
}
/// <summary>
/// Draws a point at the given location.
/// </summary>
/// <param name="ptX">X-Coordinate of the point, that should be drawn.</param>
/// <param name="ptY">Y-Coordinate of the point, that should be drawn.</param>
/// <param name="e">MapArgs for calculating the scaleSize.</param>
/// <param name="ps">PointSymbolizer with which the point gets drawn.</param>
/// <param name="g">Graphics-Object that should be used by the PointSymbolizer.</param>
/// <param name="origTransform">The original transformation that is used to position the point.</param>
private void DrawPoint(double ptX, double ptY, MapArgs e, IPointSymbolizer ps, Graphics g, Matrix origTransform)
{
var x = Convert.ToInt32((ptX - e.MinX) * e.Dx);
var y = Convert.ToInt32((e.MaxY - ptY) * e.Dy);
double scaleSize = ps.GetScale(e);
Matrix shift = origTransform.Clone();
shift.Translate(x, y);
g.Transform = shift;
ps.Draw(g, scaleSize);
}
/// <summary>
/// Creates the category using a random fill color.
/// </summary>
/// <param name="fillColor">The base color to use for creating the category.</param>
/// <param name="size">The double size of the larger dimension of the point.</param>
/// <returns>A new polygon category.</returns>
public override ICategory CreateNewCategory(Color fillColor, double size)
{
IPointSymbolizer ps = EditorSettings.TemplateSymbolizer.Copy() as IPointSymbolizer ?? new PointSymbolizer(fillColor, PointShape.Ellipse, size);
ps.SetFillColor(fillColor);
Size2D oSize = ps.GetSize();
double rat = size / Math.Max(oSize.Width, oSize.Height);
ps.SetSize(new Size2D(rat * oSize.Width, rat * oSize.Height));
return(new PointCategory(ps));
}
/// <summary>
/// Launches a form for editing the line symbolizer
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_original = value as IPointSymbolizer;
if (_original == null) return value;
_copy = _original.Copy();
IWindowsFormsEditorService dialogProvider = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
DetailedPointSymbolDialog dialog = new DetailedPointSymbolDialog(_copy);
dialog.ChangesApplied += new EventHandler(dialog_ChangesApplied);
if (dialogProvider.ShowDialog(dialog) != DialogResult.OK) return value;
_original.CopyProperties(_copy);
return value;
}
private float GetAngleFromExpression(int fid, IPointSymbolizer ps)
{
float angle = 0;
if (_expression == null || fid >= DataSet.DataTable.Rows.Count)
{
return(angle);
}
var row = DataSet.DataTable.Rows[fid];
string value = _expression.CalculateRowValue(row, fid);
bool convertRet = float.TryParse(value, out angle);
return(angle);
}
/// <summary>
/// Resets the existing control with the new symbolizer.
/// </summary>
/// <param name="original">The original symbolizer.</param>
public void Initialize(IPointSymbolizer original)
{
_original = original;
_symbolizer = original.Copy();
ccSymbols.Symbols = _symbolizer.Symbols;
ccSymbols.RefreshList();
if (_symbolizer.Symbols.Count > 0)
{
ccSymbols.SelectedSymbol = _symbolizer.Symbols[0];
}
UpdatePreview();
UpdateSymbolControls();
}
/// <summary>
/// Draws a point at the given location.
/// </summary>
/// <param name="ptX">X-Coordinate of the point, that should be drawn.</param>
/// <param name="ptY">Y-Coordinate of the point, that should be drawn.</param>
/// <param name="e">MapArgs for calculating the scaleSize.</param>
/// <param name="ps">PointSymbolizer with which the point gets drawn.</param>
/// <param name="g">Graphics-Object that should be used by the PointSymbolizer.</param>
/// <param name="origTransform">The original transformation that is used to position the point.</param>
private void DrawPoint(double ptX, double ptY, MapArgs e, IPointSymbolizer ps, Graphics g, Matrix origTransform)
{
var pt = new Point
{
X = Convert.ToInt32((ptX - e.MinX) * e.Dx),
Y = Convert.ToInt32((e.MaxY - ptY) * e.Dy)
};
double scaleSize = ps.ScaleMode == ScaleMode.Geographic ? e.ImageRectangle.Width / e.GeographicExtents.Width : 1;
Matrix shift = origTransform.Clone();
shift.Translate(pt.X, pt.Y);
g.Transform = shift;
ps.Draw(g, scaleSize);
}
/// <summary>
/// Draws a point at the given location.
/// </summary>
/// <param name="ptX">X-Coordinate of the point, that should be drawn.</param>
/// <param name="ptY">Y-Coordinate of the point, that should be drawn.</param>
/// <param name="e">MapArgs for calculating the scaleSize.</param>
/// <param name="ps">PointSymbolizer with which the point gets drawn.</param>
/// <param name="g">Graphics-Object that should be used by the PointSymbolizer.</param>
/// <param name="origTransform">The original transformation that is used to position the point.</param>
/// <param name="clockwiseAngle">clockwiseAngle.</param>
private void DrawPoint(double ptX, double ptY, MapArgs e, IPointSymbolizer ps, Graphics g, Matrix origTransform, float clockwiseAngle)
{
var pt = new PointF
{
X = Convert.ToSingle((ptX - e.MinX) * e.Dx),
Y = Convert.ToSingle((e.MaxY - ptY) * e.Dy)
};
double scaleSize = ps.GetScale(e);
Matrix shift = origTransform.Clone();
shift.Translate(pt.X, pt.Y);
shift.Rotate(clockwiseAngle);
g.Transform = shift;
ps.Draw(g, scaleSize);
}
/// <summary>
/// If possible, use the template to control the colors. Otherwise, just use the default
/// settings for creating "unbounded" colors.
/// </summary>
/// <param name="count">The integer count.</param>
/// <returns>The List of colors.</returns>
protected override List <Color> GetDefaultColors(int count)
{
IPointSymbolizer ps = EditorSettings?.TemplateSymbolizer as IPointSymbolizer;
if (ps != null)
{
List <Color> result = new List <Color>();
Color c = ps.GetFillColor();
for (int i = 0; i < count; i++)
{
result.Add(c);
}
return(result);
}
return(base.GetDefaultColors(count));
}
private static void AssertAreEqual(IPointSymbolizer expectedSymbolizer, IPointSymbolizer actualSymbolizer)
{
IList <ISymbol> firstSymbols = expectedSymbolizer.Symbols;
IList <ISymbol> secondSymbols = actualSymbolizer.Symbols;
Assert.AreEqual(firstSymbols.Count, secondSymbols.Count, "Unequal amount of symbols defined.");
for (var i = 0; i < firstSymbols.Count; i++)
{
var firstSymbol = (SimpleSymbol)firstSymbols[i];
var secondSymbol = (SimpleSymbol)secondSymbols[i];
Assert.AreEqual(firstSymbol.Color, secondSymbol.Color);
Assert.AreEqual(firstSymbol.PointShape, secondSymbol.PointShape);
Assert.AreEqual(firstSymbol.Size, secondSymbol.Size);
Assert.AreEqual(firstSymbol.OutlineColor, secondSymbol.OutlineColor);
Assert.AreEqual(firstSymbol.OutlineWidth, secondSymbol.OutlineWidth);
}
}
/// <summary>
/// Launches a form for editing the line symbolizer
/// </summary>
/// <param name="context"></param>
/// <param name="provider"></param>
/// <param name="value"></param>
/// <returns></returns>
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_original = value as IPointSymbolizer;
if (_original == null)
{
return(value);
}
_copy = _original.Copy();
IWindowsFormsEditorService dialogProvider = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
DetailedPointSymbolDialog dialog = new DetailedPointSymbolDialog(_copy);
dialog.ChangesApplied += DialogChangesApplied;
if (dialogProvider.ShowDialog(dialog) != DialogResult.OK)
{
return(value);
}
_original.CopyProperties(_copy);
return(value);
}
/// <summary>
/// This replaces the constant size calculation with a size
/// calculation that is appropriate for features.
/// </summary>
/// <param name="count">The integer count of the number of sizes to create.</param>
/// <returns>A list of double valued sizes.</returns>
protected override List <double> GetSizeSet(int count)
{
List <double> result = new List <double>();
if (EditorSettings.UseSizeRange)
{
double start = EditorSettings.StartSize;
double dr = EditorSettings.EndSize - start;
double dx = dr / count;
if (!EditorSettings.RampColors)
{
Random rnd = new Random(DateTime.Now.Millisecond);
for (int i = 0; i < count; i++)
{
result.Add(start + (rnd.NextDouble() * dr));
}
}
else
{
for (int i = 0; i < count; i++)
{
result.Add(start + (i * dx));
}
}
}
else
{
Size2D sizes = new Size2D(2, 2);
IPointSymbolizer ps = EditorSettings.TemplateSymbolizer as IPointSymbolizer;
if (ps != null)
{
sizes = ps.GetSize();
}
double size = Math.Max(sizes.Width, sizes.Height);
for (int i = 0; i < count; i++)
{
result.Add(size);
}
}
return(result);
}
private void btnEdit_Click(object sender, EventArgs e)
{
if (_sizeRange == null)
{
return;
}
IPointSymbolizer ps = _sizeRange.Symbolizer as IPointSymbolizer;
if (ps != null)
{
_pointDialog.Symbolizer = _sizeRange.Symbolizer as IPointSymbolizer;
_pointDialog.ShowDialog(this);
}
ILineSymbolizer ls = _sizeRange.Symbolizer as ILineSymbolizer;
if (ls != null)
{
_lineDialog.Symbolizer = _sizeRange.Symbolizer as ILineSymbolizer;
_lineDialog.ShowDialog(this);
}
}
private void BtnImportSymbolClick(object sender, EventArgs e)
{
IPointSymbolizer ps = SerializeHelper.OpenFeatureSymbolizer() as IPointSymbolizer;
if (ps != null)
{
_symbolizer = ps;
ccSymbols.Symbols = _symbolizer.Symbols;
ccSymbols.RefreshList();
if (_symbolizer.Symbols.Count > 0)
{
ccSymbols.SelectedSymbol = _symbolizer.Symbols[0];
}
UpdatePreview();
UpdateSymbolControls();
}
else
{
MessageBox.Show("Failed to open file");
}
}
/// <summary>
/// Draws a point at the given location.
/// </summary>
/// <param name="ptX">X-Coordinate of the point, that should be drawn.</param>
/// <param name="ptY">Y-Coordinate of the point, that should be drawn.</param>
/// <param name="e">MapArgs for calculating the scaleSize.</param>
/// <param name="ps">PointSymbolizer with which the point gets drawn.</param>
/// <param name="g">Graphics-Object that should be used by the PointSymbolizer.</param>
/// <param name="origTransform">The original transformation that is used to position the point.</param>
private void DrawPoint(double ptX, double ptY, MapArgs e, IPointSymbolizer ps, Graphics g, Matrix origTransform)
{
var pt = new Point
{
X = Convert.ToInt32((ptX - e.MinX) * e.Dx),
Y = Convert.ToInt32((e.MaxY - ptY) * e.Dy)
};
double scaleSize = ps.GetScale(e);
// CGX
if (MapFrame != null && (MapFrame as IMapFrame).ReferenceScale > 1.0 && (MapFrame as IMapFrame).CurrentScale > 0.0)
{
double dReferenceScale = (MapFrame as IMapFrame).ReferenceScale;
double dCurrentScale = (MapFrame as IMapFrame).CurrentScale;
scaleSize = dReferenceScale / dCurrentScale;
} // Fin CGX
Matrix shift = origTransform.Clone();
shift.Translate(pt.X, pt.Y);
g.Transform = shift;
ps.Draw(g, scaleSize);
}
/// <summary>
/// Creates a new instance of PointSymbolizerEventArgs
/// </summary>
public PointSymbolizerEventArgs(IPointSymbolizer symbolizer)
: base(symbolizer)
{
}
// This draws the individual point features
private void DrawFeatures(MapArgs e, IEnumerable <int> indices)
{
Graphics g = e.Device ?? Graphics.FromImage(BackBuffer);
Matrix origTransform = g.Transform;
FeatureType featureType = DataSet.FeatureType;
if (!DrawnStatesNeeded)
{
if (Symbology == null || Symbology.Categories.Count == 0)
{
return;
}
FastDrawnState state = new FastDrawnState(false, Symbology.Categories[0]);
IPointCategory pc = state.Category as IPointCategory;
IPointSymbolizer ps = pc?.Symbolizer;
if (ps == null)
{
return;
}
double[] vertices = DataSet.Vertex;
foreach (int index in indices)
{
if (DrawnStates != null && DrawnStates.Length > index && !DrawnStates[index].Visible)
{
continue;
}
if (featureType == FeatureType.Point)
{
DrawPoint(vertices[index * 2], vertices[(index * 2) + 1], e, ps, g, origTransform);
}
else
{
// multi-point
ShapeRange range = DataSet.ShapeIndices[index];
for (int i = range.StartIndex; i <= range.EndIndex(); i++)
{
DrawPoint(vertices[i * 2], vertices[(i * 2) + 1], e, ps, g, origTransform);
}
}
}
}
else
{
FastDrawnState[] states = DrawnStates;
double[] vertices = DataSet.Vertex;
foreach (int index in indices)
{
if (index >= states.Length)
{
break;
}
FastDrawnState state = states[index];
if (!state.Visible || state.Category == null)
{
continue;
}
IPointCategory pc = state.Category as IPointCategory;
if (pc == null)
{
continue;
}
IPointSymbolizer ps = state.Selected ? pc.SelectionSymbolizer : pc.Symbolizer;
if (ps == null)
{
continue;
}
if (featureType == FeatureType.Point)
{
DrawPoint(vertices[index * 2], vertices[(index * 2) + 1], e, ps, g, origTransform);
}
else
{
ShapeRange range = DataSet.ShapeIndices[index];
for (int i = range.StartIndex; i <= range.EndIndex(); i++)
{
DrawPoint(vertices[i * 2], vertices[(i * 2) + 1], e, ps, g, origTransform);
}
}
}
}
if (e.Device == null)
{
g.Dispose();
}
else
{
g.Transform = origTransform;
}
}
/// <inheritdoc />
protected override void OnMouseDown(GeoMouseArgs e)
{
if (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right)
{
_mousePosition = e.Location;
if (_dragging)
{
if (e.Button == MouseButtons.Right)
{
_dragging = false;
Map.Invalidate();
Map.IsBusy = false;
}
}
else
{
if (_selectedFeature != null)
{
Rectangle mouseRect = new Rectangle(_mousePosition.X - 3, _mousePosition.Y - 3, 6, 6);
Envelope env = Map.PixelToProj(mouseRect).ToEnvelope();
if (CheckForVertexDrag(e))
{
return;
}
// No vertex selection has occured.
if (!_selectedFeature.Geometry.Intersects(env.ToPolygon()))
{
// We are clicking down outside of the given polygon, so clear our selected feature
DeselectFeature();
return;
}
}
if (_activeFeature != null)
{
// Don't start dragging a vertices right away for polygons and lines.
// First you select the polygon, which displays the vertices, then they can be moved.
if (_featureSet.FeatureType == FeatureType.Polygon)
{
_selectedFeature = _activeFeature;
_activeFeature = null;
IPolygonCategory sc = _selectedCategory as IPolygonCategory;
if (sc == null)
{
_selectedCategory = new PolygonCategory(Color.FromArgb(55, 0, 255, 255), Color.Blue, 1)
{
LegendItemVisible = false
};
}
_layer.SetCategory(_selectedFeature, _selectedCategory);
}
else if (_featureSet.FeatureType == FeatureType.Line)
{
_selectedFeature = _activeFeature;
_activeFeature = null;
ILineCategory sc = _selectedCategory as ILineCategory;
if (sc == null)
{
_selectedCategory = new LineCategory(Color.Cyan, 1)
{
LegendItemVisible = false
};
}
_layer.SetCategory(_selectedFeature, _selectedCategory);
}
else
{
_dragging = true;
Map.IsBusy = true;
_dragCoord = _activeFeature.Geometry.Coordinates[0];
MapPointLayer mpl = _layer as MapPointLayer;
if (mpl != null)
{
mpl.SetVisible(_activeFeature, false);
}
IPointCategory sc = _selectedCategory as IPointCategory;
if (sc == null)
{
IPointSymbolizer ps =
_layer.GetCategory(_activeFeature).Symbolizer.Copy() as IPointSymbolizer;
if (ps != null)
{
ps.SetFillColor(Color.Cyan);
_selectedCategory = new PointCategory(ps);
}
}
}
}
Map.MapFrame.Initialize();
Map.Invalidate();
}
}
base.OnMouseDown(e);
}
/// <summary>
/// Creates a new category based on a symbolizer, and uses the same symbolizer, but with a fill and border color of light cyan
/// for the selection symbolizer
/// </summary>
/// <param name="pointSymbolizer">The symbolizer to use in order to create a category</param>
public PointCategory(IPointSymbolizer pointSymbolizer)
{
Symbolizer = pointSymbolizer;
SelectionSymbolizer = pointSymbolizer.Copy();
SelectionSymbolizer.SetFillColor(Color.Cyan);
}
/// <summary>
/// Resets the existing control with the new symbolizer
/// </summary>
/// <param name="original"></param>
public void Initialize(IPointSymbolizer original)
{
_original = original;
_symbolizer = original.Copy();
ccSymbols.Symbols = _symbolizer.Symbols;
ccSymbols.RefreshList();
if (_symbolizer.Symbols.Count > 0)
{
ccSymbols.SelectedSymbol = _symbolizer.Symbols[0];
}
UpdatePreview();
UpdateSymbolControls();
}
/// <summary>
/// Handles the inter-connectivity of the various controls and updates
/// them all to match the latest value.
/// </summary>
public void UpdateControls()
{
if (_ignore)
{
return;
}
_ignore = true;
if (_sizeRange == null)
{
_ignore = false;
return;
}
chkSizeRange.Checked = _sizeRange.UseSizeRange;
trkStart.Value = (int)_sizeRange.Start;
trkEnd.Value = (int)_sizeRange.End;
IPointSymbolizer ps = _sizeRange.Symbolizer as IPointSymbolizer;
if (ps != null)
{
Color color = ps.GetFillColor();
if (_scheme != null && _scheme.EditorSettings.UseColorRange)
{
color = _scheme.EditorSettings.StartColor;
}
if (chkSizeRange.Checked)
{
psvStart.Symbolizer = _sizeRange.GetSymbolizer(_sizeRange.Start, color) as IPointSymbolizer;
}
else
{
IPointSymbolizer sm = ps.Copy();
sm.SetFillColor(color);
psvStart.Symbolizer = sm;
}
if (_scheme != null && _scheme.EditorSettings.UseColorRange)
{
color = _scheme.EditorSettings.EndColor;
}
if (chkSizeRange.Checked)
{
psvEnd.Symbolizer = _sizeRange.GetSymbolizer(_sizeRange.End, color) as IPointSymbolizer;
}
else
{
IPointSymbolizer sm = ps.Copy();
sm.SetFillColor(color);
psvEnd.Symbolizer = sm;
}
}
ILineSymbolizer ls = _sizeRange.Symbolizer as ILineSymbolizer;
if (ls != null)
{
Color color = ls.GetFillColor();
if (_scheme != null && _scheme.EditorSettings.UseColorRange)
{
color = _scheme.EditorSettings.StartColor;
}
if (chkSizeRange.Checked)
{
lsvStart.Symbolizer = _sizeRange.GetSymbolizer(_sizeRange.Start, color) as ILineSymbolizer;
}
else
{
ILineSymbolizer sm = ls.Copy();
sm.SetFillColor(color);
lsvStart.Symbolizer = sm;
}
if (_scheme != null && _scheme.EditorSettings.UseColorRange)
{
color = _scheme.EditorSettings.EndColor;
}
if (chkSizeRange.Checked)
{
lsvEnd.Symbolizer = _sizeRange.GetSymbolizer(_sizeRange.End, color) as ILineSymbolizer;
}
else
{
ILineSymbolizer sm = ls.Copy();
sm.SetFillColor(color);
lsvEnd.Symbolizer = sm;
}
}
nudStart.Value = (decimal)_sizeRange.Start;
nudEnd.Value = (decimal)_sizeRange.End;
_ignore = false;
OnSizeRangeChanged();
}
/// <summary>
/// Creates a new category based on a symbolizer, and uses the same symbolizer, but with a fill and border color of light cyan
/// for the selection symbolizer
/// </summary>
/// <param name="pointSymbolizer">The symbolizer to use in order to create a category</param>
public PointCategory(IPointSymbolizer pointSymbolizer)
{
Symbolizer = pointSymbolizer;
SelectionSymbolizer = pointSymbolizer.Copy();
SelectionSymbolizer.SetFillColor(Color.Cyan);
}
/// <summary>
/// Initializes a new instance of the <see cref="PointSymbolizerEventArgs"/> class.
/// </summary>
/// <param name="symbolizer">The symbolizer of the event.</param>
public PointSymbolizerEventArgs(IPointSymbolizer symbolizer)
: base(symbolizer)
{
}
public static void DrawMultiPoint(IPointSymbolizer symbolizer, Graphics g, MultiPoint points, Map map)
{
symbolizer.Render(map, points, g);
}
public static void DrawPoint(IPointSymbolizer symbolizer, Graphics g, Point point, Map map)
{
if (point == null)
return;
symbolizer.Render(map, point, g);
}
public static void DrawMultiPoint(IPointSymbolizer symbolizer, Graphics g, IMultiPoint points, MapViewport map)
{
symbolizer.Render(map, points, g);
}
/// <summary>
/// Creates a new DetailedPointSymbolDialog that will update the specified original symbol
/// by copying the new aspects to it only if the Apply Changes, or Ok buttons are used.
/// </summary>
/// <param name="original">The original IPointSymbolizer to modify.</param>
public DetailedPointSymbolControl(IPointSymbolizer original)
{
Configure();
Initialize(original);
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected override void OnMouseDoubleClick(MouseEventArgs e)
{
_wasDoubleClick = true;
Point loc = new Point(e.X + ControlRectangle.X, e.Location.Y + ControlRectangle.Top);
foreach (LegendBox lb in _legendBoxes)
{
if (!lb.Bounds.Contains(loc) || lb.CheckBox.Contains(loc))
{
continue;
}
ILineCategory lc = lb.Item as ILineCategory;
if (lc != null)
{
DetailedLineSymbolDialog lsDialog = new DetailedLineSymbolDialog(lc.Symbolizer);
lsDialog.ShowDialog();
ILineSymbolizer sel = lc.Symbolizer.Copy();
sel.SetFillColor(Color.Cyan);
lc.SelectionSymbolizer = sel;
}
IPointCategory pc = lb.Item as IPointCategory;
if (pc != null)
{
DetailedPointSymbolDialog dlg = new DetailedPointSymbolDialog(pc.Symbolizer);
dlg.ShowDialog();
IPointSymbolizer ps = pc.Symbolizer.Copy();
ps.SetFillColor(Color.Cyan);
pc.SelectionSymbolizer = ps;
}
IPolygonCategory polyCat = lb.Item as IPolygonCategory;
if (polyCat != null)
{
DetailedPolygonSymbolDialog dlg = new DetailedPolygonSymbolDialog(polyCat.Symbolizer);
dlg.ShowDialog();
IPolygonSymbolizer ps = polyCat.Symbolizer.Copy();
ps.SetFillColor(Color.Cyan);
ps.OutlineSymbolizer.SetFillColor(Color.DarkCyan);
polyCat.SelectionSymbolizer = ps;
}
IFeatureLayer fl = lb.Item as IFeatureLayer;
if (fl != null)
{
LayerDialog layDialog = new LayerDialog(fl, new FeatureCategoryControl());
layDialog.ShowDialog();
}
IRasterLayer rl = lb.Item as IRasterLayer;
if (rl != null)
{
LayerDialog dlg = new LayerDialog(rl, new RasterCategoryControl());
dlg.ShowDialog();
}
IColorCategory cb = lb.Item as IColorCategory;
if (cb != null)
{
_tabColorDialog = new TabColorDialog();
_tabColorDialog.ChangesApplied += TabColorDialogChangesApplied;
_tabColorDialog.StartColor = cb.LowColor;
_tabColorDialog.EndColor = cb.HighColor;
_editCategory = cb;
_tabColorDialog.ShowDialog(this);
}
}
base.OnMouseDoubleClick(e);
}
// This draws the individual point features
private void DrawFeatures(MapArgs e, IEnumerable <int> indices, bool selected)
{
if (selected && (!DrawnStatesNeeded || !DrawnStates.Any(_ => _.Selected)))
{
return; // there are no selected features
}
Graphics g = e.Device ?? Graphics.FromImage(BackBuffer);
Matrix origTransform = g.Transform;
FeatureType featureType = DataSet.FeatureType;
double minX = e.MinX;
double maxY = e.MaxY;
double dx = e.Dx;
double dy = e.Dy;
// CGX
if (dx < 2000000000 && dx > -2000000000 && dy < 2000000000 && dy > -2000000000)
{
if (!DrawnStatesNeeded)
{
if (Symbology == null || Symbology.Categories.Count == 0)
{
return;
}
FastDrawnState state = new FastDrawnState(false, Symbology.Categories[0]);
IPointSymbolizer ps = (state.Category as IPointCategory)?.Symbolizer;
if (ps == null)
{
return;
}
double[] vertices = DataSet.Vertex;
foreach (int index in indices)
{
// CGX
if (Visibility != null)
{
bool visi = Visibility[index].Visible;
if (!visi)
{
continue;
}
}
if (featureType == FeatureType.Point)
{
DrawPoint(vertices[index * 2], vertices[(index * 2) + 1], e, ps, g, origTransform);
}
else
{
// multi-point
ShapeRange range = DataSet.ShapeIndices[index];
for (int i = range.StartIndex; i <= range.EndIndex(); i++)
{
DrawPoint(vertices[i * 2], vertices[(i * 2) + 1], e, ps, g, origTransform);
}
}
}
}
else
{
FastDrawnState[] states = DrawnStates;
var indexList = indices as IList <int> ?? indices.ToList();
if (indexList.Max() >= states.Length)
{
AssignFastDrawnStates();
states = DrawnStates;
}
double[] vertices = DataSet.Vertex;
foreach (int index in indexList)
{
if (index >= states.Length)
{
break;
}
FastDrawnState state = states[index];
if (!state.Visible || state.Category == null)
{
continue;
}
if (selected && !state.Selected)
{
continue;
}
IPointCategory pc = state.Category as IPointCategory;
if (pc == null)
{
continue;
}
IPointSymbolizer ps = selected ? pc.SelectionSymbolizer : pc.Symbolizer;
if (ps == null)
{
continue;
}
if (featureType == FeatureType.Point)
{
DrawPoint(vertices[index * 2], vertices[(index * 2) + 1], e, ps, g, origTransform);
}
else
{
ShapeRange range = DataSet.ShapeIndices[index];
for (int i = range.StartIndex; i <= range.EndIndex(); i++)
{
DrawPoint(vertices[i * 2], vertices[(i * 2) + 1], e, ps, g, origTransform);
}
}
}
}
}
if (e.Device == null)
{
g.Dispose();
}
else
{
g.Transform = origTransform;
}
}
/// <summary>
/// Draws a point at the given location.
/// </summary>
/// <param name="ptX">X-Coordinate of the point, that should be drawn.</param>
/// <param name="ptY">Y-Coordinate of the point, that should be drawn.</param>
/// <param name="e">MapArgs for calculating the scaleSize.</param>
/// <param name="ps">PointSymbolizer with which the point gets drawn.</param>
/// <param name="g">Graphics-Object that should be used by the PointSymbolizer.</param>
/// <param name="origTransform">The original transformation that is used to position the point.</param>
private void DrawPoint(double ptX, double ptY, MapArgs e, IPointSymbolizer ps, Graphics g, Matrix origTransform)
{
var pt = new Point
{
X = Convert.ToInt32((ptX - e.MinX) * e.Dx),
Y = Convert.ToInt32((e.MaxY - ptY) * e.Dy)
};
double scaleSize = ps.ScaleMode == ScaleMode.Geographic ? e.ImageRectangle.Width / e.GeographicExtents.Width : 1;
Matrix shift = origTransform.Clone();
shift.Translate(pt.X, pt.Y);
g.Transform = shift;
ps.Draw(g, scaleSize);
}
private static Bitmap GetSymbolizerBitmap(IPointSymbolizer symbolizer, IProj e)
{
if (symbolizer == null) return null;
var scaleSize = symbolizer.GetScale(e);
var size = symbolizer.GetSize();
if (size.Width * scaleSize < 1 || size.Height * scaleSize < 1) return null;
var bitmap = new Bitmap((int)(size.Width * scaleSize) + 1, (int)(size.Height * scaleSize) + 1);
var bg = Graphics.FromImage(bitmap);
bg.SmoothingMode = symbolizer.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;
var trans = bg.Transform;
// keenedge:
// added ' * scaleSize ' to fix a problme when ploted using ScaleMode=Geographic. however, it still
// appeared to be shifted up and left by 1 pixel so I also added the one pixel shift to the NW.
trans.Translate(((float)(size.Width * scaleSize) / 2 - 1), (float)(size.Height * scaleSize) / 2 - 1);
bg.Transform = trans;
symbolizer.Draw(bg, 1);
return bitmap;
}
/// <summary>
/// Initializes a new instance of the <see cref="DetailedPointSymbolControl"/> class that will update the specified original symbol
/// by copying the new aspects to it only if the Apply Changes, or Ok buttons are used.
/// </summary>
/// <param name="original">The original IPointSymbolizer to modify.</param>
public DetailedPointSymbolControl(IPointSymbolizer original)
{
Configure();
Initialize(original);
}
public GeometrySymbolizer()
{
_pointSymbolizer = new RasterPointSymbolizer();
_lineSymbolizer = new BasicLineSymbolizer();
_polygonSymbolizer = new BasicPolygonSymbolizer();
}
/// <summary>
///
/// </summary>
/// <param name="original"></param>
public DetailedPointSymbolDialog(IPointSymbolizer original)
{
InitializeComponent();
detailedPointSymbolControl1.Initialize(original);
Configure();
}
/// <summary>
/// Initializes a new instance of the <see cref="DetailedPointSymbolDialog"/> class.
/// </summary>
/// <param name="original">The original point symbolizer.</param>
public DetailedPointSymbolDialog(IPointSymbolizer original)
{
InitializeComponent();
detailedPointSymbolControl1.Initialize(original);
Configure();
}
