/// <summary>
/// Creates a new instance of a DrawnState class for subdividing features.
/// </summary>
/// <param name="category">A category that the feature belongs to</param>
/// <param name="selected">Boolean, true if the feature is currently selected</param>
/// <param name="chunk">An integer chunk that this feature should belong to</param>
/// <param name="visible">A boolean indicating whether this feature is visible or not</param>
public DrawnState(IFeatureCategory category, bool selected, int chunk, bool visible)
{
SchemeCategory = category;
IsSelected = selected;
IsVisible = visible;
Chunk = chunk;
}
/// <inheritdoc />
protected override void OnDeactivate()
{
DeselectFeature();
RemoveHighlightFromFeature();
_oldCategory = null;
base.OnDeactivate();
}
/// <summary>
/// Adding a feature state sets the drawing state of the item to be
/// </summary>
/// <param name="item">The item to add to this category</param>
/// <exception cref="Serialization.ReadOnlyException">Occurs if this list is set to read-only in the constructor</exception>
public void Add(IFeature item)
{
if (_isReadOnly)
{
throw new ReadOnlyException();
}
IDrawnState previousState = _filter[item];
IFeatureCategory cat = previousState.SchemeCategory;
if (_useCategory)
{
cat = _category;
}
bool sel = previousState.IsSelected;
if (_useSelection)
{
sel = _selected;
}
int chunk = previousState.Chunk;
if (_useChunks)
{
chunk = _chunk;
}
bool vis = previousState.IsVisible;
if (_useVisibility)
{
vis = _visible;
}
_filter[item] = new DrawnState(cat, sel, chunk, vis);
OnChanged();
}
/// <summary>
/// Creates a new instance of a DrawnState class for subdividing features.
/// </summary>
/// <param name="category">A category that the feature belongs to</param>
/// <param name="selected">Boolean, true if the feature is currently selected</param>
/// <param name="chunk">An integer chunk that this feature should belong to</param>
/// <param name="visible">A boolean indicating whether this feature is visible or not</param>
public DrawnState(IFeatureCategory category, bool selected, int chunk, bool visible)
{
_category = category;
_isSelected = selected;
_isVisible = visible;
_chunk = chunk;
}
/// <summary>
/// Creates a new instance of a DrawnState class for subdividing features.
/// </summary>
/// <param name="category">A category that the feature belongs to</param>
/// <param name="selected">Boolean, true if the feature is currently selected</param>
/// <param name="chunk">An integer chunk that this feature should belong to</param>
/// <param name="visible">A boolean indicating whether this feature is visible or not</param>
public DrawnState(IFeatureCategory category, bool selected, int chunk, bool visible)
{
_category = category;
_isSelected = selected;
_isVisible = visible;
_chunk = chunk;
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawnState"/> class for subdividing features.
/// </summary>
/// <param name="category">A category that the feature belongs to.</param>
/// <param name="selected">Boolean, true if the feature is currently selected.</param>
/// <param name="chunk">An integer chunk that this feature should belong to.</param>
/// <param name="visible">A boolean indicating whether this feature is visible or not.</param>
public DrawnState(IFeatureCategory category, bool selected, int chunk, bool visible)
{
SchemeCategory = category;
IsSelected = selected;
IsVisible = visible;
Chunk = chunk;
}
private void CreateUniqueCategories(string fieldName, IAttributeSource source, ICancelProgressHandler progressHandler)
{
Breaks = GetUniqueValues(fieldName, source, progressHandler);
string fieldExpression = "[" + fieldName.ToUpper() + "]";
ClearCategories();
bool isStringField = CheckFieldType(fieldName, source);
ProgressMeter pm = new ProgressMeter(progressHandler, "Building Feature Categories", Breaks.Count);
List <double> sizeRamp = GetSizeSet(Breaks.Count);
List <Color> colorRamp = GetColorSet(Breaks.Count);
for (int colorIndex = 0; colorIndex < Breaks.Count; colorIndex++)
{
Break brk = Breaks[colorIndex];
// get the color for the category
Color randomColor = colorRamp[colorIndex];
double size = sizeRamp[colorIndex];
IFeatureCategory cat = CreateNewCategory(randomColor, size) as IFeatureCategory;
if (cat != null)
{
cat.LegendText = brk.Name;
if (isStringField)
{
cat.FilterExpression = fieldExpression + "= '" + brk.Name.Replace("'", "''") + "'";
}
else
{
cat.FilterExpression = fieldExpression + "=" + brk.Name;
}
if (cat.FilterExpression != null)
{
if (cat.FilterExpression.Contains("=[NULL]"))
{
cat.FilterExpression = cat.FilterExpression.Replace("=[NULL]", " is NULL");
}
else if (cat.FilterExpression.Contains("= '[NULL]'"))
{
cat.FilterExpression = cat.FilterExpression.Replace("= '[NULL]'", " is NULL");
}
}
AddCategory(cat);
}
colorIndex++;
pm.CurrentValue = colorIndex;
}
pm.Reset();
}
private void Configure()
{
// Cache the active state of the filter.
_selected = _filter.Selected;
_selectionState = _filter.Selected;
_visible = _filter.Visible;
_chunk = _filter.Chunk;
_category = _filter.Category;
_useSelection = _filter.UseSelection;
_useChunks = _filter.UseChunks;
_useVisibility = _filter.UseVisibility;
_useCategory = _filter.UseCategory;
}
private void CreateUniqueCategories(string fieldName, DataTable table)
{
Breaks = GetUniqueValues(fieldName, table);
List <double> sizeRamp = GetSizeSet(Breaks.Count);
List <Color> colorRamp = GetColorSet(Breaks.Count);
string fieldExpression = "[" + fieldName.ToUpper() + "]";
ClearCategories();
bool isStringField = CheckFieldType(fieldName, table);
int colorIndex = 0;
foreach (Break brk in Breaks)
{
//get the color for the category
Color randomColor = colorRamp[colorIndex];
double size = sizeRamp[colorIndex];
IFeatureCategory cat = CreateNewCategory(randomColor, size) as IFeatureCategory;
if (cat != null)
{
//cat.SelectionSymbolizer = _selectionSymbolizer.Copy();
cat.LegendText = brk.Name;
if (isStringField)
{
cat.FilterExpression = fieldExpression + "= '" + brk.Name.Replace("'", "''") + "'";
}
else
{
cat.FilterExpression = fieldExpression + "=" + brk.Name;
}
if (cat.FilterExpression != null)
{
if (cat.FilterExpression.Contains("=[NULL]"))
{
cat.FilterExpression = cat.FilterExpression.Replace("=[NULL]", " is NULL");
}
else if (cat.FilterExpression.Contains("= '[NULL]'"))
{
cat.FilterExpression = cat.FilterExpression.Replace("= '[NULL]'", " is NULL");
}
}
AddCategory(cat);
}
colorIndex++;
}
}
public int IndexOf(IFeatureCategory item)
{
var category = item.GetInternal();
for (int i = 0; i < _categories.Count; i++)
{
if (_categories.Item[i] == category)
{
return(i);
}
}
return(-1);
}
private void BuildPaths(MapArgs e, IEnumerable <IFeature> features, out Dictionary <FastDrawnState, GraphicsPath> borderPaths, bool selected)
{
borderPaths = new Dictionary <FastDrawnState, GraphicsPath>();
if (selected && !DrawingFilter.DrawnStates.Any(_ => _.Value.IsSelected))
{
return;
}
Rectangle clipRect = ComputeClippingRectangle(e);
Extent drawExtents = e.PixelToProj(clipRect);
SoutherlandHodgman shClip = new SoutherlandHodgman(clipRect);
var featureList = features as IList <IFeature> ?? features.ToList();
foreach (var category in Symbology.Categories)
{
// Determine the subset of the specified features that are visible and match the category
IFeatureCategory polygonCategory = category;
Func <IDrawnState, bool> isMember;
if (selected)
{
// get only selected features
isMember = state => state.SchemeCategory == polygonCategory && state.IsVisible && state.IsSelected;
}
else
{
// get all features
isMember = state => state.SchemeCategory == polygonCategory && state.IsVisible;
}
var drawnFeatures = (from feature in featureList where isMember(DrawingFilter[feature]) select feature).ToList();
if (drawnFeatures.Count > 0)
{
GraphicsPath borderPath = new GraphicsPath();
foreach (IFeature f in drawnFeatures)
{
BuildPolygon(DataSet.Vertex, f.ShapeIndex, borderPath, e, drawExtents.Contains(f.Geometry.EnvelopeInternal) ? null : shClip);
}
borderPaths.Add(new FastDrawnState(selected, category), borderPath);
}
}
}
/// <summary>
/// Removes the specified item from the subset of this classification if that category is used.
/// Selected -> !Selected
/// Category[>0] -> Category[0]
/// Category[0] -> Null
/// Visible -> !Visible
/// Chunk -> -1 or basically a chunk index that is never drawn.
/// </summary>
/// <param name="item">The item to change the drawing state of.</param>
/// <returns>Boolean, false if the item does not match the current grouping.</returns>
/// <exception cref="ReadOnlyException">Occurs if this list is set to read-only in the constructor.</exception>
public bool Remove(IFeature item)
{
if (IsReadOnly)
{
throw new ReadOnlyException();
}
if (Contains(item) == false)
{
return(false);
}
IDrawnState previousState = Filter[item];
IFeatureCategory cat = previousState.SchemeCategory;
int chunk = previousState.Chunk;
bool sel = previousState.IsSelected;
bool vis = previousState.IsVisible;
if (ActiveType == FilterType.Category)
{
cat = Category != Filter.DefaultCategory ? Filter.DefaultCategory : null;
}
if (ActiveType == FilterType.Chunk)
{
// removing from a chunk effectively means setting to -1 so that it will not get drawn
// until it is added to a chunk again.
chunk = -1;
}
if (ActiveType == FilterType.Selection)
{
sel = !Selected;
}
if (ActiveType == FilterType.Visible)
{
vis = !Visible;
}
Filter[item] = new DrawnState(cat, sel, chunk, vis);
_envelope = null; //reset the envelope so it will be calculated from the selected features the next time the property is accessed
OnChanged();
return(true);
}
/// <summary>
/// This describes how to launch the form etc.
/// </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)
{
_context = context;
IWindowsFormsEditorService dialogProvider = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
SQLExpressionDialog dlgExpression = new SQLExpressionDialog();
string original = (string)value;
dlgExpression.Expression = (string)value;
// Try to find the Table
IFeatureCategory category = context.Instance as IFeatureCategory;
if (category != null)
{
IFeatureScheme scheme = category.GetParentItem() as IFeatureScheme;
if (scheme != null)
{
IFeatureLayer layer = scheme.GetParentItem() as IFeatureLayer;
if (layer != null)
{
dlgExpression.Table = layer.DataSet.DataTable;
}
}
else
{
IFeatureLayer layer = category.GetParentItem() as IFeatureLayer;
if (layer != null)
{
dlgExpression.Table = layer.DataSet.DataTable;
}
}
}
dlgExpression.ChangesApplied += DlgExpressionChangesApplied;
var result = dialogProvider.ShowDialog(dlgExpression);
dlgExpression.ChangesApplied -= DlgExpressionChangesApplied;
return(result != DialogResult.OK ? original : dlgExpression.Expression);
}
/// <summary>
/// Removes the specified item from the subset of this classification if that category is used.
/// Selected -> !Selected
/// Category[>0] -> Category[0]
/// Category[0] -> Null
/// Visible -> !Visible
/// Chunk -> -1 or basically a chunk index that is never drawn.
/// </summary>
/// <param name="item">The item to change the drawing state of</param>
/// <returns>Boolean, false if the item does not match the current grouping</returns>
/// <exception cref="ReadOnlyException">Occurs if this list is set to read-only in the constructor</exception>
public bool Remove(IFeature item)
{
if (_isReadOnly)
{
throw new ReadOnlyException();
}
if (Contains(item) == false)
{
return(false);
}
IDrawnState previousState = _filter[item];
IFeatureCategory cat = previousState.SchemeCategory;
int chunk = previousState.Chunk;
bool sel = previousState.IsSelected;
bool vis = previousState.IsVisible;
if (_activeType == FilterType.Category)
{
cat = _category != _filter.DefaultCategory ? _filter.DefaultCategory : null;
}
if (_activeType == FilterType.Chunk)
{
// removing from a chunk effectively means setting to -1 so that it will not get drawn
// until it is added to a chunk again.
chunk = -1;
}
if (_activeType == FilterType.Selection)
{
sel = !_selected;
}
if (_activeType == FilterType.Visible)
{
vis = !_visible;
}
_filter[item] = new DrawnState(cat, sel, chunk, vis);
OnChanged();
return(true);
}
/// <summary>
/// Adding a feature state sets the drawing state of the item to be.
/// </summary>
/// <param name="item">The item to add to this category.</param>
/// <exception cref="Serialization.ReadOnlyException">Occurs if this list is set to read-only in the constructor.</exception>
public void Add(IFeature item)
{
if (IsReadOnly)
{
throw new ReadOnlyException();
}
IDrawnState previousState = Filter[item];
IFeatureCategory cat = previousState.SchemeCategory;
if (UseCategory)
{
cat = Category;
}
bool sel = previousState.IsSelected;
if (UseSelection)
{
sel = Selected;
}
int chunk = previousState.Chunk;
if (UseChunks)
{
chunk = Chunk;
}
bool vis = previousState.IsVisible;
if (UseVisibility)
{
vis = Visible;
}
Filter[item] = new DrawnState(cat, sel, chunk, vis);
_envelope = null; //reset the envelope so it will be calculated from the selected features the next time the property is accessed
OnChanged();
}
private IFeatureScheme CreateCategoryScheme(TFeatureBasedMapData mapData)
{
IFeatureScheme scheme = CreateScheme();
scheme.ClearCategories();
scheme.AddCategory(CreateDefaultCategory(mapData));
MapTheme <TCategoryTheme> mapTheme = mapData.Theme;
Dictionary <string, int> attributeMapping = GetAttributeMapping(mapData);
if (attributeMapping.ContainsKey(mapTheme.AttributeName))
{
int attributeIndex = attributeMapping[mapTheme.AttributeName];
foreach (TCategoryTheme categoryTheme in mapTheme.CategoryThemes)
{
IFeatureCategory category = CreateFeatureCategory(categoryTheme);
category.FilterExpression = CreateFilterExpression(attributeIndex, categoryTheme.Criterion);
scheme.AddCategory(category);
}
}
return(scheme);
}
private IFeatureLayer addLayer(string path, string name, bool isForObserved, bool isWorkingLayer)
{
Debug.WriteLine(DateTime.Now);
Debug.WriteLine("Adding Layer..., " + name);
if (!System.IO.File.Exists(path))
{
Debug.WriteLine(path + " doesn't exist!");
return(null);
}
IFeatureLayer layer = this.Layers.Add(path) as IFeatureLayer;
layer.SelectionEnabled = isWorkingLayer;
layer.LegendText = name;
foreach (DataColumn col in layer.DataSet.DataTable.Columns)
{
col.ColumnName = col.ColumnName.ToLower();
}
//working layer and result display
if (isWorkingLayer && !isForObserved)
{
//add result column
DataTable dt = layer.DataSet.DataTable;
dt.Columns.Add(RESULT_COLUMN, typeof(double));
//create schema for result display
layer.Symbology.EditorSettings.ClassificationType = ClassificationType.Quantities;
layer.Symbology.EditorSettings.FieldName = RESULT_COLUMN;
layer.Symbology.EditorSettings.IntervalMethod = IntervalMethod.Quantile;
layer.Symbology.EditorSettings.IntervalSnapMethod = IntervalSnapMethod.SignificantFigures;
layer.Symbology.EditorSettings.IntervalRoundingDigits = 3; //3 significant number
layer.Symbology.EditorSettings.StartSize = 5;
layer.Symbology.EditorSettings.EndSize = 25;
layer.Symbology.EditorSettings.NumBreaks = 5;
layer.Symbology.EditorSettings.UseSizeRange = true;
//start and end color
layer.Symbology.EditorSettings.StartColor = Color.Green;
layer.Symbology.EditorSettings.EndColor = Color.Red;
}
//set normal symbol
//for result display, this is just the initial symbol. The symbol would be updated based on result
//after the result is retrieved.
if (layer.DataSet.FeatureType == DotSpatial.Topology.FeatureType.Polygon) //subbasin
{
layer.Symbolizer = new PolygonSymbolizer(System.Drawing.Color.LightGray, System.Drawing.Color.Black, 0.5);
//show label for subbasin
MapLabelLayer label = new MapLabelLayer();
label.Symbology.Categories[0].Expression = "[" + ID_COLUMN_NAME + "]";
layer.LabelLayer = label;
layer.ShowLabels = true;
}
else if (layer.DataSet.FeatureType == DotSpatial.Topology.FeatureType.Line) //reach
{
layer.Symbolizer = new LineSymbolizer(System.Drawing.Color.Blue, 3.0);
//set selection sysmbol for reach as wider red to make it more obvious
layer.SelectionSymbolizer = new LineSymbolizer(System.Drawing.Color.Red, 3.0);
}
else if (layer.DataSet.FeatureType == DotSpatial.Topology.FeatureType.Point) //reservoir
{
//set the symbol color,shape and size
layer.Symbolizer = new PointSymbolizer(Color.Green, DotSpatial.Symbology.PointShape.Hexagon, 20.0);
layer.SelectionSymbolizer = new PointSymbolizer(Color.Cyan, DotSpatial.Symbology.PointShape.Hexagon, 20.0);
//also set to just show reservoir
//first to see if there are some reservoir there Type = R
if (layer.DataSet.DataTable.Rows.Count == 0)
{
Layers.Remove(layer as IMapLayer); return(null);
}
int reservoirNum = int.Parse(layer.DataSet.DataTable.Compute("count(" + ID_COLUMN_NAME + ")", "type = 'R' or type = 'r'").ToString());
if (reservoirNum <= 0)
{
Layers.Remove(layer as IMapLayer); return(null);
}
//only show reservoir
List <int> hiddenMoniterPoints = new List <int>();
for (int i = 0; i < layer.DataSet.DataTable.Rows.Count; i++)
{
ArcSWAT.RowItem item = new ArcSWAT.RowItem(layer.DataSet.DataTable.Rows[i]);
string type = item.getColumnValue_String("type");
if (!type.Equals("R") && !type.Equals("r"))
{
hiddenMoniterPoints.Add(i);
}
}
layer.RemoveFeaturesAt(hiddenMoniterPoints);
}
//add a column to show if the feature has observed data
if (isForObserved)
{
//add observed column
DataTable dt = layer.DataSet.DataTable;
dt.Columns.Add(OBSERVED_COLUMN, typeof(int));
//create schema observed column to make feature with observed data more obvious
if (layer.DataSet.FeatureType != DotSpatial.Topology.FeatureType.Polygon)
{
layer.Symbology.ClearCategories();
//get the observed data status
ArcSWAT.SWATUnitType unitType = ArcSWAT.SWATUnitType.RCH;
if (layer.DataSet.FeatureType == DotSpatial.Topology.FeatureType.Point)
{
unitType = ArcSWAT.SWATUnitType.RES;
}
foreach (DataRow r in layer.DataSet.DataTable.Rows)
{
int id = getIDFromFeatureRow(r);
if (_project.Observation(Interval).getObservedData(unitType, id).Count > 0)
{
r[OBSERVED_COLUMN] = 1;
}
else
{
r[OBSERVED_COLUMN] = 0;
}
}
//set the category
IFeatureCategory cat_observed = layer.Symbology.CreateNewCategory(Color.Blue, 3.0) as IFeatureCategory;
cat_observed.FilterExpression = string.Format("[{0}]=0", OBSERVED_COLUMN.ToUpper());
IFeatureCategory cat_no_observed = layer.Symbology.CreateNewCategory(Color.Red, 3.0) as IFeatureCategory;
cat_no_observed.FilterExpression = string.Format("[{0}]=1", OBSERVED_COLUMN.ToUpper());
//for reservoir, change default size and shape
if (layer.DataSet.FeatureType == DotSpatial.Topology.FeatureType.Point)
{
cat_observed.SelectionSymbolizer = new PointSymbolizer(Color.Cyan, DotSpatial.Symbology.PointShape.Hexagon, 20.0);
cat_no_observed.SelectionSymbolizer = new PointSymbolizer(Color.Cyan, DotSpatial.Symbology.PointShape.Hexagon, 20.0);
((cat_observed.Symbolizer as PointSymbolizer).Symbols[0] as SimpleSymbol).Size = new Size2D(20.0, 20.0);
((cat_no_observed.Symbolizer as PointSymbolizer).Symbols[0] as SimpleSymbol).Size = new Size2D(20.0, 20.0);
((cat_observed.Symbolizer as PointSymbolizer).Symbols[0] as SimpleSymbol).PointShape = DotSpatial.Symbology.PointShape.Hexagon;
((cat_no_observed.Symbolizer as PointSymbolizer).Symbols[0] as SimpleSymbol).PointShape = DotSpatial.Symbology.PointShape.Hexagon;
}
layer.Symbology.AddCategory(cat_observed);
layer.Symbology.AddCategory(cat_no_observed);
layer.ApplyScheme(layer.Symbology);
}
}
if (isWorkingLayer)
{
layer.SelectionEnabled = true;
//for selection changed event
layer.SelectionChanged += (ss, _e) =>
{
if (onLayerSelectionChanged == null)
{
return;
}
ArcSWAT.SWATUnitType unitType = ArcSWAT.SWATUnitType.SUB;
if (layer.DataSet.FeatureType == DotSpatial.Topology.FeatureType.Point)
{
unitType = ArcSWAT.SWATUnitType.RES;
}
else if (layer.DataSet.FeatureType == DotSpatial.Topology.FeatureType.Line)
{
unitType = ArcSWAT.SWATUnitType.RCH;
}
int id = -1;
if (layer.Selection.NumRows() > 0)
{
IFeature fea = layer.Selection.ToFeatureList()[0];
id = getIDFromFeatureRow(fea.DataRow);
}
onLayerSelectionChanged(unitType, id);
_id = id;
};
}
return(layer);
}
/// <summary>
/// Creates a new FastDrawnState with the specified parameters
/// </summary>
/// <param name="sel"></param>
/// <param name="cat"></param>
public FastDrawnState(bool sel, IFeatureCategory cat)
{
Selected = sel;
Category = cat;
Visible = true;
}
/// <summary>
/// Given a scheme, this will build the break list to match approximately. This does not
/// force the interval method to build a new scheme.
/// </summary>
public void UpdateBreaks()
{
if (_isRaster)
{
UpdateRasterBreaks();
return;
}
if (_scheme == null)
{
return;
}
IFeatureCategory selectedCat = null;
if (_selectedSlider != null)
{
selectedCat = _selectedSlider.Category as IFeatureCategory;
}
_breaks.Clear();
Statistics stats = _scheme.Statistics;
Rectangle gb = _graph.GetGraphBounds();
_graph.ColorRanges.Clear();
foreach (IFeatureCategory category in _scheme.GetCategories())
{
ColorRange cr = new ColorRange(category.GetColor(), category.Range);
_graph.ColorRanges.Add(cr);
BreakSlider bs = new BreakSlider(gb, _graph.Minimum, _graph.Maximum, cr);
bs.Color = _breakColor;
bs.SelectColor = _selectedBreakColor;
if (selectedCat != null && category == selectedCat)
{
bs.Selected = true;
_selectedSlider = bs;
_graph.SelectedRange = cr;
}
if (category.Maximum != null)
{
bs.Value = double.Parse(category.Maximum.ToString());
}
else
{
bs.Value = stats.Maximum;
}
bs.Category = category;
_breaks.Add(bs);
}
_breaks.Sort();
// Moving a break generally affects both a maximum and a minimum.
// Point to the next category to actuate that.
for (int i = 0; i < _breaks.Count - 1; i++)
{
_breaks[i].NextCategory = _breaks[i + 1].Category;
// We use the maximums to set up breaks. Minimums should simply
// be set to work with the maximums of the previous category.
_breaks[i + 1].Category.Minimum = _breaks[i].Value;
}
if (_breaks.Count == 0)
{
return;
}
int breakIndex = 0;
BreakSlider nextSlider = _breaks[breakIndex];
int count = 0;
if (_graph == null || _graph.Bins == null)
{
return;
}
foreach (double value in _values)
{
if (value < nextSlider.Value)
{
count++;
continue;
}
nextSlider.Count = count;
while (value > nextSlider.Value)
{
breakIndex++;
if (breakIndex >= _breaks.Count)
{
break;
}
nextSlider = _breaks[breakIndex];
}
count = 0;
}
}
public bool Remove(IFeatureCategory item)
{
return(_categories.Remove(IndexOf(item)));
}
/// <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);
}
/// <inheritdoc />
protected override void OnDeactivate()
{
DeselectFeature();
RemoveHighlightFromFeature();
_oldCategory = null;
base.OnDeactivate();
}
/// <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;
}
// Á¤Á¡ ¼±ÅÃÀÌ ¹ß»ýÇÏÁö ¾Ê¾Ò½À´Ï´Ù.
if (!_selectedFeature.Geometry.Intersects(env.ToPolygon()))
{
// ¼±ÅÃÀ» Ãë¼ÒÇÕ´Ï´Ù.
DeselectFeature();
return;
}
}
if (_activeFeature != null)
{
// ´Ù°¢Çü°ú ¼±ÀÇ Á¤Á¡À» ¹Ù·Î µå·¡±×ÇÏÁö ¸¶½Ê½Ã¿À. ¸ÕÀú Á¤Á¡À» Ç¥½ÃÇÏ´Â ´Ù°¢ÇüÀ» ¼±ÅÃÇÑ ´ÙÀ½ À̵¿ÇÒ ¼ö ÀÖ½À´Ï´Ù.
if (_featureSet.FeatureType == FeatureType.Polygon) // ¸é
{
_selectedFeature = _activeFeature;
_activeFeature = null;
if (!(_selectedCategory is IPolygonCategory sc))
{
_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;
if (!(_selectedCategory is ILineCategory sc))
{
_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;
mpl?.SetVisible(_activeFeature, false);
if (!(_selectedCategory is IPointCategory sc))
{
if (_layer.GetCategory(_activeFeature).Symbolizer.Copy() is IPointSymbolizer ps)
{
ps.SetFillColor(Color.Cyan);
_selectedCategory = new PointCategory(ps);
}
}
}
}
Map.MapFrame.Initialize();
Map.Invalidate();
}
}
base.OnMouseDown(e);
}
/// <inheritdoc />
public void SetCategory(IFeature feature, IFeatureCategory category)
{
if (_editMode)
{
DrawingFilter.DrawnStates[feature].SchemeCategory = category;
}
else
{
int index = DataSet.Features.IndexOf(feature);
DrawnStates[index].Category = category;
}
if (!_scheme.GetCategories().Contains(category))
{
_scheme.InsertCategory(0, category);
}
}
public void Insert(int index, IFeatureCategory item)
{
_categories.Insert2(index, item.GetInternal());
}
public void Add(IFeatureCategory item)
{
_categories.Add2(item.GetInternal());
}
internal static ShapefileCategory GetInternal(this IFeatureCategory category)
{
return(category.InternalObject as ShapefileCategory);
}
/// <inheritdoc />
protected override void OnMouseDown(GeoMouseArgs e)
{
_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);
IEnvelope env = Map.PixelToProj(mouseRect).ToEnvelope();
if (CheckForVertexDrag(e)) { return; }
// No vertex selection has occured.
if (!_selectedFeature.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.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();
}
}
/// <summary>
/// Deselects the selected feature and removes the highlight from any highlighted feature.
/// </summary>
public void ClearSelection()
{
DeselectFeature();
RemoveHighlightFromFeature();
_oldCategory = null;
}
/// <summary>
/// Before a shape is selected, moving the mouse over a shape will highlight that shape by changing
/// its appearance. This tests features to determine the first feature to qualify as the highlight.
/// </summary>
/// <param name="e">The GeoMouseArgs parameter contains information about the mouse location
/// and geographic coordinates.</param>
/// <returns>A value indicating whether the shape was successfully highlighted.</returns>
private bool ShapeHighlight(GeoMouseArgs e)
{
if (e == null)
throw new ArgumentNullException("e", "e is null.");
Rectangle mouseRect = new Rectangle(_mousePosition.X - 3, _mousePosition.Y - 3, 6, 6);
Extent ext = Map.PixelToProj(mouseRect);
IPolygon env = ext.ToEnvelope().ToPolygon();
bool requiresInvalidate = false;
foreach (IFeature feature in _featureSet.Features)
{
if (_featureSet.FeatureType == FeatureType.Point || _featureSet.FeatureType == FeatureType.MultiPoint)
{
MapPointLayer mpl = _layer as MapPointLayer;
if (mpl != null)
{
int w = 3;
int h = 3;
PointCategory pc = mpl.GetCategory(feature) as PointCategory;
if (pc != null)
{
if (pc.Symbolizer.ScaleMode != ScaleMode.Geographic)
{
Size2D size = pc.Symbolizer.GetSize();
w = (int)size.Width;
h = (int)size.Height;
}
}
_imageRect = new Rectangle(e.Location.X - (w / 2), e.Location.Y - (h / 2), w, h);
if (_imageRect.Contains(Map.ProjToPixel(feature.Coordinates[0])))
{
_activeFeature = feature;
_oldCategory = mpl.GetCategory(feature);
if (_selectedCategory == null)
{
_selectedCategory = _oldCategory.Copy();
_selectedCategory.SetColor(Color.Red);
_selectedCategory.LegendItemVisible = false;
}
mpl.SetCategory(_activeFeature, _selectedCategory);
}
}
requiresInvalidate = true;
}
else
{
if (feature.Intersects(env))
{
_activeFeature = feature;
_oldCategory = _layer.GetCategory(_activeFeature);
if (_featureSet.FeatureType == FeatureType.Polygon)
{
IPolygonCategory pc = _activeCategory as IPolygonCategory;
if (pc == null)
{
_activeCategory = new PolygonCategory(Color.FromArgb(55, 255, 0, 0), Color.Red, 1) { LegendItemVisible = false };
}
}
if (_featureSet.FeatureType == FeatureType.Line)
{
ILineCategory pc = _activeCategory as ILineCategory;
if (pc == null)
{
_activeCategory = new LineCategory(Color.Red, 3) { LegendItemVisible = false };
}
}
_layer.SetCategory(_activeFeature, _activeCategory);
requiresInvalidate = true;
}
}
}
return requiresInvalidate;
}
/// <summary>
/// Before a shape is selected, moving the mouse over a shape will highlight that shape by changing
/// its appearance. This tests features to determine the first feature to qualify as the highlight.
/// </summary>
/// <param name="e">The GeoMouseArgs parameter contains information about the mouse location
/// and geographic coordinates.</param>
/// <returns>A value indicating whether the shape was successfully highlighted.</returns>
private bool ShapeHighlight(GeoMouseArgs e)
{
if (e == null)
{
throw new ArgumentNullException("e", "e is null.");
}
Rectangle mouseRect = new Rectangle(_mousePosition.X - 3, _mousePosition.Y - 3, 6, 6);
Extent ext = Map.PixelToProj(mouseRect);
IPolygon env = ext.ToEnvelope().ToPolygon();
bool requiresInvalidate = false;
foreach (IFeature feature in _featureSet.Features)
{
if (_featureSet.FeatureType == FeatureType.Point || _featureSet.FeatureType == FeatureType.MultiPoint)
{
MapPointLayer mpl = _layer as MapPointLayer;
if (mpl != null)
{
int w = 3;
int h = 3;
PointCategory pc = mpl.GetCategory(feature) as PointCategory;
if (pc != null)
{
if (pc.Symbolizer.ScaleMode != ScaleMode.Geographic)
{
Size2D size = pc.Symbolizer.GetSize();
w = (int)size.Width;
h = (int)size.Height;
}
}
_imageRect = new Rectangle(e.Location.X - (w / 2), e.Location.Y - (h / 2), w, h);
if (_imageRect.Contains(Map.ProjToPixel(feature.Geometry.Coordinates[0])))
{
_activeFeature = feature;
_oldCategory = mpl.GetCategory(feature);
if (_selectedCategory == null)
{
_selectedCategory = _oldCategory.Copy();
_selectedCategory.SetColor(Color.Red);
_selectedCategory.LegendItemVisible = false;
}
mpl.SetCategory(_activeFeature, _selectedCategory);
}
}
requiresInvalidate = true;
}
else
{
if (feature.Geometry.Intersects(env))
{
_activeFeature = feature;
_oldCategory = _layer.GetCategory(_activeFeature);
if (_featureSet.FeatureType == FeatureType.Polygon)
{
IPolygonCategory pc = _activeCategory as IPolygonCategory;
if (pc == null)
{
_activeCategory = new PolygonCategory(Color.FromArgb(55, 255, 0, 0), Color.Red, 1)
{
LegendItemVisible = false
};
}
}
if (_featureSet.FeatureType == FeatureType.Line)
{
ILineCategory pc = _activeCategory as ILineCategory;
if (pc == null)
{
_activeCategory = new LineCategory(Color.Red, 3)
{
LegendItemVisible = false
};
}
}
_layer.SetCategory(_activeFeature, _activeCategory);
requiresInvalidate = true;
}
}
}
return(requiresInvalidate);
}
public bool Contains(IFeatureCategory item)
{
return(IndexOf(item) != -1);
}
/// <summary>
/// This calculates the extent for the category and caches it in the extents collection
/// </summary>
/// <param name="category">
/// </param>
protected virtual Extent CalculateCategoryExtent(IFeatureCategory category)
{
Extent ext = new Extent(new[] { double.MaxValue, double.MaxValue, double.MinValue, double.MinValue });
if (_editMode)
{
IDictionary<IFeature, IDrawnState> features = _drawingFilter.DrawnStates;
foreach (IFeature f in DataSet.Features)
{
if (category == features[f].SchemeCategory)
{
ext.ExpandToInclude(new Extent(f.Envelope));
}
}
if (_categoryExtents.Keys.Contains(category))
{
_categoryExtents[category] = ext.Copy();
}
else
{
_categoryExtents.Add(category, ext.Copy());
}
}
else
{
FastDrawnState[] states = DrawnStates;
List<ShapeRange> ranges = DataSet.ShapeIndices;
for (int shp = 0; shp < DrawnStates.Length; shp++)
{
if (states[shp].Category != null)
{
if (!_categoryExtents.ContainsKey(states[shp].Category))
{
_categoryExtents.Add(states[shp].Category, ranges[shp].Extent.Copy());
}
else
{
_categoryExtents[states[shp].Category].ExpandToInclude(ranges[shp].Extent);
}
}
}
}
return ext;
}
/// <summary>
/// Creates a new FastDrawnState with the specified parameters
/// </summary>
/// <param name="sel"></param>
/// <param name="cat"></param>
public FastDrawnState(bool sel, IFeatureCategory cat)
{
Selected = sel;
Category = cat;
Visible = true;
}
private void Configure()
{
// Cache the active state of the filter.
_selected = _filter.Selected;
_selectionState = _filter.Selected;
_visible = _filter.Visible;
_chunk = _filter.Chunk;
_category = _filter.Category;
_useSelection = _filter.UseSelection;
_useChunks = _filter.UseChunks;
_useVisibility = _filter.UseVisibility;
_useCategory = _filter.UseCategory;
}
protected override void OnDeactivate()
{
UnSelectFeature();
UnHighlightFeature();
_oldCategory = null;
base.OnDeactivate();
}
