private void NewFeatureLayer(DotSpatial.Controls.IMap map, string directory)
{
string filename = Path.Combine(directory, this.Name + ".shp");
if (!File.Exists(filename))
{
CreateFeature(map.Projection, directory);
}
this.Feature = FeatureSet.Open(filename);
if (this.Feature.FeatureType == FeatureType.Polygon)
{
var layer = new MapPolygonLayer(this.Feature);
map.Layers.Add(layer);
this.FeatureLayer = layer;
}
else if (this.Feature.FeatureType == FeatureType.Line)
{
var layer = new MapLineLayer(this.Feature);
map.Layers.Add(layer);
this.FeatureLayer = layer;
}
else if (this.Feature.FeatureType == FeatureType.Point)
{
var layer = new MapPointLayer(this.Feature);
map.Layers.Add(layer);
this.FeatureLayer = layer;
}
}
private MapPointLayer CreateSearchResultLayer(SearchResultItem item, IMapGroup root)
{
Debug.WriteLine("Starting method CreateSearchResultLayer");
var myLayer = new MapPointLayer(item.FeatureSet);
// Get Title of web-server
var webService = _searchSettings.WebServicesSettings.WebServices.FirstOrDefault(
ws => ws.ServiceCode == item.ServiceCode);
var defaulLegendText = webService != null? webService.Title : item.ServiceCode;
// Build legend text
var legendText = defaulLegendText;
int nameIndex = 1;
Debug.WriteLine("Starting while loop.");
while (true)
{
// Check if legend text is already used
var nameUsed = root.Layers.Any(layer => layer.LegendText == legendText);
if (!nameUsed)
{
Debug.WriteLine("Exiting while loop");
break;
}
// Create new legend text
nameIndex++;
legendText = string.Format("{0} ({1})", defaulLegendText, nameIndex);
}
myLayer.LegendText = legendText;
Debug.WriteLine("Returning myLayer");
return(myLayer);
}
public frmMain()
{
InitializeComponent();
uxMap.Projection = KnownCoordinateSystems.Projected.World.WebMercator;
uxMap.BackColor = Color.FromArgb(181, 208, 208);
backgroundLayer = BruTileLayer.CreateOsmLayer();
uxMap.Layers.Add(backgroundLayer);
pseudoAisPort.LogFilePath = Application.StartupPath + "\\AIS.log";
pseudoAisPort.DataReceived += new EventHandler <SerialDataReceivedEventArgs>(pseudoAisPortDataReceived);
refreshTimer.Enabled = false;
refreshTimer.Interval = 1500;
refreshTimer.Tick += new EventHandler(refreshTimerTick);
helper = new AISHelper(uxMap.Projection);
vesselsLayer = helper.VesselsLayer;
uxMap.MapFrame.Add(vesselsLayer);
uxMap.ViewExtents = new Extent(1642982.27031471, 4063251.12000095, 3802748.48786722, 5126261.05520257);
if (DotSpatial.Plugins.AISViewer.Properties.Settings.Default.UsePseudoPort)
{
pseudoAisPort.Open();
}
else
{
aisPort.Open();
}
refreshTimer.Enabled = true;
}
public override void CreateGridFeature()
{
this.GridFeatureFilePath = "GeoSpatial\\Grid.shp";
this.CentroidFeatureFilePath = "GeoSpatial\\Centroid.shp";
var full_gridfea_file = Path.Combine(this.AbsolutePathToProjectFile, GridFeatureFilePath);
var full_centroid_file = Path.Combine(this.AbsolutePathToProjectFile, CentroidFeatureFilePath);
this.Model.Grid.Build(full_gridfea_file);
var fs_grid = FeatureSet.Open(full_gridfea_file);
_GridLayer = new MapPolygonLayer(fs_grid);
this.Model.Grid.FeatureSet = fs_grid;
this.Model.Grid.FeatureLayer = _GridLayer;
this.Map.Layers.Add(_GridLayer);
this.Model.Grid.BuildCentroid(full_centroid_file);
var fs_centroid = FeatureSet.Open(full_centroid_file);
_CentroidLayer = new MapPointLayer(fs_centroid);
this.Model.Grid.CentroidFeature = fs_centroid;
this.Model.Grid.CentroidFeatureLayer = _CentroidLayer;
this.Map.Layers.Add(_CentroidLayer);
this.Map.Invalidate();
}
private MapPointLayer CreateSearchResultLayer(SearchResultItem item, MapGroup root)
{
var myLayer = new MapPointLayer(item.FeatureSet);
// Get Title of web-server
var webService = Settings.SearchSettings.Instance.WebServicesSettings.WebServices.FirstOrDefault(
ws => ws.ServiceCode == item.SeriesDataCart.ServCode);
var defaulLegendText = webService != null? webService.Title : item.SeriesDataCart.ServCode;
// Build legend text
var legendText = defaulLegendText;
int nameIndex = 1;
while (true)
{
// Check if legend text is already used
var nameUsed = root.Layers.Any(layer => layer.LegendText == legendText);
if (!nameUsed)
{
break;
}
// Create new legend text
nameIndex++;
legendText = string.Format("{0} ({1})", defaulLegendText, nameIndex);
}
myLayer.LegendText = legendText;
return(myLayer);
}
internal IMapFeatureLayer CreateLayer(string type, string layerName)
{
IMapFeatureLayer layer = null;
switch (type)
{
case "Polygon":
layer = new MapPolygonLayer();
break;
case "Line":
layer = new MapLineLayer();
break;
case "Point":
layer = new MapPointLayer();
break;
case "MultiPolygon":
layer = new MapPolygonLayer();
break;
default:
throw new Exception("Wrong Layer Class:" + type);
}
layer.DataSet.Name = layerName;
layer.LegendText = layerName;
return(layer);
}
/// <summary>
/// 创建点文件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void createPointShapefileToolStripMenuItem_Click(object sender, EventArgs e)
{
//Change the cursor style
map1.Cursor = Cursors.Cross;
//set the shape type to the classlevel string variable
//we are going to use this variable in select case statement
shapeType = "Point";
//set projection
pointF.Projection = map1.Projection;
//initialize the featureSet attribute table
DataColumn column = new DataColumn("ID");
pointF.DataTable.Columns.Add(column);
//add the featureSet as map layer
MapPointLayer pointLayer = (MapPointLayer)map1.Layers.Add(pointF);
//Create a new symbolizer
PointSymbolizer symbol = new PointSymbolizer(Color.Red, DotSpatial.Symbology.PointShape.Ellipse, 3);
//Set the symbolizer to the point layer
pointLayer.Symbolizer = symbol;
//Set the legentText as point
pointLayer.LegendText = "point";
//Set left mouse click as true
pointmouseClick = true;
}
private void CreateLabelsLayer(MapPointLayer _vesselsLayer)
{
_vesselsLayer.LabelLayer = new MapLabelLayer(VesselsFeatureSet)
{
Projection = _vesselsLayer.Projection
};
_vesselsLayer.ShowLabels = true;
//_vesselsLayer.LabelLayer.UseDynamicVisibility = true;
//_vesselsLayer.LabelLayer.DynamicVisibilityWidth = 0.025F;
_vesselsLayer.LabelLayer.Symbology.Categories.Clear();
_vesselsLayer.LabelLayer.Symbology.Categories.Add(
new LabelCategory()
{
Expression = "[MMSI]",
Symbolizer = new LabelSymbolizer()
{
FontFamily = "Tahoma",
FontColor = Color.Black,
FontSize = 8,
BackColor = Color.White,
BackColorEnabled = true,
BackColorOpacity = 0.5f,
Orientation = ContentAlignment.MiddleRight,
PartsLabelingMethod = PartLabelingMethod.LabelAllParts,
OffsetX = 5
},
Name = "Vessels' Names"
}
);
_vesselsLayer.LabelLayer.CreateLabels();
}
public void createPointShape()
{
//map.Cursor = cursor
//map.Cursor = Cursors.Cross;
//set the shape type to the classlevel string variable
//we are going to use this variable in select case statement
shapeType = "Point";
pointF = new FeatureSet(FeatureType.Point);
//set projection
pointF.Projection = map.Projection;
//initialize the featureSet attribute table
DataColumn column = new DataColumn("ID");
pointF.DataTable.Columns.Add(column);
//add the featureSet as map layer
MapPointLayer pointLayer = (MapPointLayer)map.Layers.Add(pointF);
//Create a new symbolizer
PointSymbolizer symbol = new PointSymbolizer(Color.Red, DotSpatial.Symbology.PointShape.Ellipse, 3);
//Set the symbolizer to the point layer
pointLayer.Symbolizer = symbol;
//Set the legendText as point
pointLayer.LegendText = "My Point";
//Set left mouse click as true
pointmouseClick = true;
}
public override void Activate()
{
App.HeaderControl.Add(new RootItem(AisMenuKey, Resources.MenuAIS));
App.HeaderControl.Add(mnuDeviceStart = new SimpleActionItem(AisMenuKey, Resources.DeviceStart, DeviceStart)
{
LargeImage = Resources.playback_start_32,
SmallImage = Resources.playback_start_16,
ToolTipText = "Start Decoding...",
GroupCaption = AisGroupCaption
});
App.HeaderControl.Add(mnuDeviceStop = new SimpleActionItem(AisMenuKey, Resources.DeviceStop, DeviceStop)
{
LargeImage = Resources.playback_stop_32,
SmallImage = Resources.playback_stop_16,
ToolTipText = "Stop Decoding",
GroupCaption = AisGroupCaption,
Enabled = false
});
pseudoAisPort.LogFilePath = Application.StartupPath + "\\AIS.log";
pseudoAisPort.DataReceived += new EventHandler <SerialDataReceivedEventArgs>(pseudoAisPortDataReceived);
refreshTimer.Enabled = false;
refreshTimer.Interval = 1500;
refreshTimer.Tick += new EventHandler(refreshTimerTick);
helper = new AISHelper(App.Map.Projection);
vesselsLayer = helper.VesselsLayer;
base.Activate();
}
/// <summary>
/// Deserializes the layer.
/// </summary>
/// <param name="layer">The layer.</param>
/// <param name="pointLayer">The point layer.</param>
internal static void DeserializeLayer(dynamic layer, MapPointLayer pointLayer)
{
if (UseAlternateParser(layer))
{
// TODO: write alternate parser for this layer information.
return;
}
LegacyPointType typeOfPoint = (LegacyPointType)Enum.ToObject(typeof(LegacyPointType), Convert.ToInt32(layer.ShapeFileProperties["PointType"]));
PointSymbolizer pointSymbolizer;
if (ConvertLegacyPointTypeToPointShape(typeOfPoint) == PointShape.Undefined)
{
pointSymbolizer = new PointSymbolizer();
}
else
{
var color = LegacyDeserializer.GetColor(layer.ShapeFileProperties["Color"]);
var width = Convert.ToDouble(layer.ShapeFileProperties["LineOrPointSize"]);
pointSymbolizer = new PointSymbolizer(color, ConvertLegacyPointTypeToPointShape(typeOfPoint), width);
}
pointLayer.Symbolizer = pointSymbolizer;
}
public void TestMapFrameIsNotNull()
{
const string filename = @".\TestFiles\test-RandomPts.shp";
const string projectFileName = @".\testmapframeisnotnull.dspx";
//string projPath = Path.Combine(Path.GetTempPath(), projectFileName);
AppManager manager = new AppManager();
Map map = new Map();
manager.Map = map;
IFeatureSet fs = FeatureSet.Open(filename);
MapPointLayer l = new MapPointLayer(fs);
map.Layers.Add(l);
Assert.Greater(map.Layers.Count, 0);
manager.SerializationManager.SaveProject(projectFileName);
Assert.True(System.IO.File.Exists(projectFileName));
//reopen the project
map.Layers.Clear();
Assert.AreEqual(map.Layers.Count, 0);
manager.SerializationManager.OpenProject(projectFileName);
Assert.Greater(map.Layers.Count, 0);
Assert.IsNotNull(map.Layers[0].MapFrame);
//delete file
System.IO.File.Delete(projectFileName);
}
public void TestMapFrameIsNotNull()
{
string filename = Path.Combine("Data", "test-RandomPts.shp");
string projectFileName = FileTools.GetTempFileName(".dspx");
_filesToRemove.Add(projectFileName);
AppManager manager = new AppManager();
Map map = new Map();
manager.Map = map;
IFeatureSet fs = FeatureSet.Open(filename);
MapPointLayer l = new MapPointLayer(fs);
map.Layers.Add(l);
Assert.Greater(map.Layers.Count, 0);
manager.SerializationManager.SaveProject(projectFileName);
Assert.True(File.Exists(projectFileName));
//reopen the project
map.Layers.Clear();
Assert.AreEqual(map.Layers.Count, 0);
manager.SerializationManager.OpenProject(projectFileName);
Assert.Greater(map.Layers.Count, 0);
Assert.IsNotNull(map.Layers[0].MapFrame);
}
public void ConvertLayerProperties_MapPointDataWithStyle_ConvertsStyleToMapPointLayer(
[Values(KnownColor.AliceBlue, KnownColor.Azure)]
KnownColor color,
[Values(1, 5)] int width,
[Values(PointSymbol.Circle, PointSymbol.Square)]
PointSymbol pointStyle)
{
// Setup
var converter = new MapPointDataConverter();
var mapPointLayer = new MapPointLayer();
Color expectedColor = Color.FromKnownColor(color);
var mapPointData = new MapPointData("test", new PointStyle
{
Color = expectedColor,
Size = width,
Symbol = pointStyle,
StrokeColor = expectedColor,
StrokeThickness = 1
});
// Call
converter.ConvertLayerProperties(mapPointData, mapPointLayer);
// Assert
PointShape expectedPointShape = pointStyle == PointSymbol.Circle
? PointShape.Ellipse
: PointShape.Rectangle;
var expectedSymbolizer = new PointSymbolizer(expectedColor, expectedPointShape, width);
expectedSymbolizer.SetOutline(expectedColor, 1);
AssertAreEqual(expectedSymbolizer, mapPointLayer.Symbolizer);
}
private static Layer GetPointLayer(dynamic layer)
{
MapPointLayer pointLayer = new MapPointLayer(FeatureSet.OpenFile(layer["Path"]));
LegacyDeserializer.DeserializeLayer(layer, pointLayer);
return(pointLayer);
}
public void ConvertLayerFeatures_MapPointDataWithMultipleFeatures_ConvertsEachGeometryToMapPointLayerAsSingleFeature()
{
// Setup
var converter = new MapPointDataConverter();
var mapPointLayer = new MapPointLayer();
var mapPointData = new MapPointData("test")
{
Features = new[]
{
new MapFeature(new[]
{
new MapGeometry(new[]
{
new[]
{
new Point2D(1, 2)
}
})
}),
new MapFeature(Enumerable.Empty <MapGeometry>()),
new MapFeature(new[]
{
new MapGeometry(new[]
{
new[]
{
new Point2D(2, 3)
}
})
}),
new MapFeature(Enumerable.Empty <MapGeometry>()),
new MapFeature(new[]
{
new MapGeometry(new[]
{
new[]
{
new Point2D(3, 4)
}
}),
new MapGeometry(new[]
{
new[]
{
new Point2D(5, 6)
}
})
})
}
};
// Call
converter.ConvertLayerFeatures(mapPointData, mapPointLayer);
// Assert
Assert.AreEqual(4, mapPointLayer.DataSet.Features.Count);
}
public ucDrawPoint(HMCon con, TUC_HMDevXManager.TUC_HMDevXManager hmDevMgr, WpfMapDrawBase map, MapPointLayer layer, int layerIndex)
: base(con, hmDevMgr, map)
{
InitializeComponent();
_layer = layer;
_layerIndex = layerIndex;
gcAttr.DataSource = _attrTable;
InDrawingStatus(false);
}
public void ConvertLayerProperties_MapPointDataWithThemeAndMetaDataNameNotInFeatures_OnlyAddsDefaultCategory()
{
// Setup
const string metadataAttribute = "Meta";
var random = new Random(21);
var theme = new MapTheme <PointCategoryTheme>("Other Meta", new[]
{
new PointCategoryTheme(ValueCriterionTestFactory.CreateValueCriterion(),
new PointStyle
{
Color = Color.FromKnownColor(random.NextEnum <KnownColor>()),
Size = random.Next(1, 48),
Symbol = random.NextEnum <PointSymbol>(),
StrokeColor = Color.FromKnownColor(random.NextEnum <KnownColor>()),
StrokeThickness = random.Next(1, 48)
})
});
var pointStyle = new PointStyle
{
Color = Color.FromKnownColor(random.NextEnum <KnownColor>()),
Size = random.Next(1, 48),
Symbol = random.NextEnum <PointSymbol>(),
StrokeColor = Color.FromKnownColor(random.NextEnum <KnownColor>()),
StrokeThickness = random.Next(1, 48)
};
var mapPointData = new MapPointData("test", pointStyle, theme)
{
Features = new[]
{
CreateMapFeatureWithMetaData(metadataAttribute)
}
};
var mapPointLayer = new MapPointLayer();
var converter = new MapPointDataConverter();
// Call
converter.ConvertLayerProperties(mapPointData, mapPointLayer);
// Assert
PointSymbolizer expectedSymbolizer = CreateExpectedSymbolizer(pointStyle);
IPointScheme appliedScheme = mapPointLayer.Symbology;
Assert.AreEqual(1, appliedScheme.Categories.Count);
IPointCategory baseCategory = appliedScheme.Categories[0];
AssertAreEqual(expectedSymbolizer, baseCategory.Symbolizer);
Assert.IsNull(baseCategory.FilterExpression);
}
public static void CreateLayer(IList <Series> series, IProgressHandler ph, IWizardImporterSettings settings)
{
if (series.Count == 0)
{
ph.ReportProgress(100, "Finished.");
return;
}
var progress = settings.MaxProgressPercentWhenImport + 1;
var layerName = settings.LayerName;
var layer = settings.Map.GetAllLayers()
.OfType <IMapPointLayer>()
.FirstOrDefault(l => l.LegendText == layerName);
if (layer != null)
{
ph.ReportProgress(progress++, "Adding series to existing layer...");
foreach (var s in series)
{
AddSeriesToFeatureSet(s, layer.DataSet);
}
}
else
{
ph.ReportProgress(progress++, "Creating map layer...");
var featureSet = InitializeFeatureSet();
featureSet.Projection = KnownCoordinateSystems.Geographic.World.WGS1984;
foreach (var s in series)
{
AddSeriesToFeatureSet(s, featureSet);
}
featureSet.Reproject(settings.Map.Projection);
var fileName = Path.Combine(Settings.Instance.CurrentProjectDirectory,
string.Format("{0}.shp", layerName));
featureSet.Filename = fileName;
featureSet.Save();
featureSet = FeatureSet.Open(fileName); //re-open the featureSet from the file
var myLayer = new MapPointLayer(featureSet)
{
LegendText = layerName
};
var dataSitesGroup = settings.Map.GetDataSitesLayer(true);
dataSitesGroup.Add(myLayer);
}
ph.ReportProgress(progress, "Refreshing series selector...");
settings.SeriesSelector.RefreshSelection();
ph.ReportProgress(100, "Finished.");
}
public override void MapViewTapped(MapView mapView, MapViewInputEventArgs e, bool drawing)
{
if (!drawing)
{
return;
}
DeleteGraphic(DRAFT);
_newPoint = (MapPoint)GeometryEngine.Project(e.Location, SpatialReferences.Wgs84);
AddGraphic(_newPoint, DRAFT, MapPointLayer.GetSymbol(GeoStatus.Hilight));
}
public override void Init(IGeoInfo geo, bool isCur, List <Envelope> shapeList, List <MapPoint> pointList)
{
GraphicsLayer.Graphics.Clear();
MapPoint point = geo.ConvertTo <PointGeoInfo>()?.Point;
if (point != null)
{
AddGraphic(point, CURR_GEO, MapPointLayer.GetSymbol(isCur ? GeoStatus.Hilight : GeoStatus.Reference));
pointList.Add(point);
}
}
private void frmMain_FormClosing(object sender, FormClosingEventArgs e)
{
// aisPort.Close();
if (pseudoAisPort.IsOpen)
{
pseudoAisPort.Close();
}
pseudoAisPort = null;
vesselsLayer = null;
helper = null;
}
public void MapFrameIsNotNull_Group()
{
var map = new Map();
var path = Path.Combine("TestFiles", "test-randomPts.shp");
var fs = FeatureSet.Open(path);
var myLayer = new MapPointLayer(fs);
var grp = new MapGroup(map, "group1");
map.Layers.Add(grp);
grp.Layers.Add(myLayer);
Assert.IsNotNull(myLayer.MapFrame, "mapFrame of layer in group should not be null.");
}
public void MapFrameIsNotNull_Group()
{
var map = new Map();
var path = FileTools.PathToTestFile(@"Shapefiles\Cities\cities.shp");
var fs = FeatureSet.Open(path);
var myLayer = new MapPointLayer(fs);
var grp = new MapGroup(map, "group1");
map.Layers.Add(grp);
grp.Layers.Add(myLayer);
Assert.IsNotNull(myLayer.MapFrame, "mapFrame of layer in group should not be null.");
}
private void addLayer_Click(object sender, EventArgs e)
{
// Add
Coordinate c = new Coordinate(1, 1);
Coordinate c1 = new Coordinate(2, 2);
FeatureSet fs = new FeatureSet(FeatureType.Point);
fs.AddFeature(new DotSpatial.Topology.Point(c));
fs.AddFeature(new DotSpatial.Topology.Point(c1));
env = fs.Extent;
MapPointLayer layer = new MapPointLayer(fs);
map1.MapFrame.DrawingLayers.Add(layer);
map1.Refresh();
}
public void TestMapPointLayer()
{
const string filename = @".\TestFiles\test-RandomPts.shp";
IFeatureSet fs = FeatureSet.Open(filename);
MapPointLayer l = new MapPointLayer(fs);
XmlSerializer s = new XmlSerializer();
string result = s.Serialize(l);
XmlDeserializer d = new XmlDeserializer();
MapPointLayer newPointLayer = d.Deserialize <MapPointLayer>(result);
Assert.IsNotNull(newPointLayer);
Assert.AreEqual(filename, newPointLayer.DataSet.Filename);
}
public void TestMapPointLayer()
{
string filename = Path.Combine("Data", "test-RandomPts.shp");
IFeatureSet fs = FeatureSet.Open(filename);
MapPointLayer l = new MapPointLayer(fs);
XmlSerializer s = new XmlSerializer();
string result = s.Serialize(l);
XmlDeserializer d = new XmlDeserializer();
MapPointLayer newPointLayer = d.Deserialize <MapPointLayer>(result);
Assert.IsNotNull(newPointLayer);
Assert.AreEqual(newPointLayer.DataSet.Filename, Path.GetFullPath(filename));
}
public void MapFrameIsNotNull_Group()
{
DotSpatial.Controls.Map map = new DotSpatial.Controls.Map();
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestFiles", "test-randomPts.shp");
IFeatureSet fs = FeatureSet.Open(path);
MapPointLayer myLayer = new MapPointLayer(fs);
MapGroup grp = new MapGroup(map, "group1");
map.Layers.Add(grp);
grp.Layers.Add(myLayer);
Assert.IsNotNull(myLayer.MapFrame, "mapFrame of layer in group should not be null.");
}
public void MapFrameIsNotNull_Group()
{
var map = new Map();
var path = Path.Combine("TestFiles", "test-randomPts.shp");
var fs = FeatureSet.Open(path);
var myLayer = new MapPointLayer(fs);
var grp = new MapGroup(map, "group1");
map.Layers.Add(grp);
grp.Layers.Add(myLayer);
Assert.IsNotNull(myLayer.MapFrame, "mapFrame of layer in group should not be null.");
}
public override void Deactivate()
{
if (pseudoAisPort.IsOpen)
{
pseudoAisPort.Close();
}
pseudoAisPort = null;
vesselsLayer = null;
helper = null;
App.HeaderControl.RemoveAll();
base.Deactivate();
}
/// <summary>
/// Highlighting shapes with a mouse over is something that also needs to be undone when the
/// mouse leaves. This test handles changing the colors back to normal when the mouse leaves a shape.
/// </summary>
/// <param name="e">The GeoMouseArgs parameter contains information about the mouse location and geographic coordinates.</param>
/// <returns>Boolean, true if mapframe initialize (or visual change) is necessary.</returns>
private bool ShapeRemoveHighlight(GeoMouseArgs e)
{
// If no shapes have ever been highlighted, this is meaningless.
if (_oldCategory == null)
{
return(false);
}
Rectangle mouseRect = new Rectangle(_mousePosition.X - 3, _mousePosition.Y - 3, 6, 6);
Extent ext = Map.PixelToProj(mouseRect);
MapPointLayer mpl = _layer as MapPointLayer;
bool requiresInvalidate = false;
IPolygon env = ext.ToEnvelope().ToPolygon();
if (mpl != null)
{
int w = 3;
int h = 3;
PointCategory pc = mpl.GetCategory(_activeFeature) as PointCategory;
if (pc != null)
{
if (pc.Symbolizer.ScaleMode != ScaleMode.Geographic)
{
w = (int)pc.Symbolizer.GetSize().Width;
h = (int)pc.Symbolizer.GetSize().Height;
}
}
Rectangle rect = new Rectangle(e.Location.X - (w / 2), e.Location.Y - (h / 2), w * 2, h * 2);
if (!rect.Contains(Map.ProjToPixel(_activeFeature.Geometry.Coordinates[0])))
{
mpl.SetCategory(_activeFeature, _oldCategory);
_activeFeature = null;
requiresInvalidate = true;
}
}
else
{
if (!_activeFeature.Geometry.Intersects(env))
{
_layer.SetCategory(_activeFeature, _oldCategory);
_activeFeature = null;
requiresInvalidate = true;
}
}
return(requiresInvalidate);
}
public override bool FinishDraw(object input, ref Geometry output, ref string errMsg)
{
if (_newPoint == null)
{
errMsg = "No point has been set.";
return(false);
}
DeleteGraphic(DRAFT);
DeleteGraphic(CURR_GEO);
AddGraphic(_newPoint, CURR_GEO, MapPointLayer.GetSymbol(GeoStatus.Hilight));
output = _newPoint;
return(true);
}
public void MapFrameIsNotNull_Group()
{
DotSpatial.Controls.Map map = new DotSpatial.Controls.Map();
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestFiles", "test-randomPts.shp");
IFeatureSet fs = FeatureSet.Open(path);
MapPointLayer myLayer = new MapPointLayer(fs);
MapGroup grp = new MapGroup(map, "group1");
map.Layers.Add(grp);
grp.Layers.Add(myLayer);
Assert.IsNotNull(myLayer.MapFrame, "mapFrame of layer in group should not be null.");
}
