/// <summary>
/// 卸载Group
/// </summary>
public static void UnLoadGroup(MapGroup group)
{
int index = group.index;
//引用置为空
if (index >= 0)
{
groupList[index] = null;
}
//卸载多余场景
if (group.gameObject.scene != SceneManager.GetActiveScene())
{
#if UNITY_EDITOR
if (!UnityEditor.EditorApplication.isPlaying)
{
UnityEditor.SceneManagement.EditorSceneManager.CloseScene(group.gameObject.scene, true);
}
else
#endif
SceneManager.UnloadSceneAsync(group.gameObject.scene);
}
else
{
#if UNITY_EDITOR
if (!UnityEditor.EditorApplication.isPlaying)
{
Object.DestroyImmediate(group.gameObject);
}
else
#endif
GameObject.Destroy(group.gameObject);
}
}
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);
}
/// <summary>
///
/// </summary>
public static void AddBaseLayers(Map pMap)
{
var mBasemap = new MapGroup();
mBasemap.LegendText = "Base Map";
var mLandFilename = Application.StartupPath + "\\GisData\\land.shp";
PolygonLayer mLandLayer = (PolygonLayer)mBasemap.Layers.Add(mLandFilename);
mLandLayer.Symbolizer = new PolygonSymbolizer(GoogleMapsColors.Land);
mLandLayer.LegendText = "Abu Dhabi Emirate";
mLandLayer.Projection = KnownCoordinateSystems.Projected.UtmWgs1984.WGS1984UTMZone40N;
mLandLayer.Reproject(pMap.Projection);
var mRoadsFilename = Application.StartupPath + "\\GisData\\roadssub.shp";
LineLayer mRoadsLayer = (LineLayer)mBasemap.Layers.Add(mRoadsFilename);
mRoadsLayer.Symbolizer = new LineSymbolizer(GoogleMapsColors.MajorRoad, 2);
mRoadsLayer.LegendText = "Approved Roads";
mRoadsLayer.Projection = KnownCoordinateSystems.Projected.UtmWgs1984.WGS1984UTMZone40N;
mRoadsLayer.Reproject(pMap.Projection);
var ms = new ShapefileDataProvider();
var ms2 = ms.Open(Application.StartupPath + "\\GisData\\roadssub.shp");
pMap.Layers.Add(mBasemap);
pMap.Legend.RefreshNodes();
mLandLayer.SelectionEnabled = false;
mRoadsLayer.SelectionEnabled = false;
ExtFunctions.AddLabelsForFeatureLayer(mRoadsLayer, "Road IDs", "[ADRROADID]", Color.LightBlue, "Arial", 10, true);
pMap.ViewExtents = mRoadsLayer.Extent;
pMap.Refresh();
}
/// <summary>
/// 尝试卸载Group，并决定卸载前是否，若取消卸载返回false
/// </summary>
public static bool UnLoadGroup(MapGroup group)
{
if (group == null)
{
return(true);
}
if (group.dirty)
{
switch (EditorUtility.DisplayDialogComplex("温馨小提示", "当前场景组未保存，是否保存该组？", "保存", "取消", "不保存"))
{
case 0:
SaveGroup(group);
MapSystem.UnLoadGroup(group);
return(true);
case 2:
MapSystem.UnLoadGroup(group);
return(true);
default:
return(false);
}
}
else
{
MapSystem.UnLoadGroup(group);
return(true);
}
}
void ReadMapping(IDataRecord record, Node rootNode)
{
MapGroup[] groups =
(from i in Enumerable.Range(0, record.FieldCount)
let columnName = record.GetName(i)
let path = columnName.Split('$')
let property = (path.Length == 1) ? columnName : path[path.Length - 1]
let assoc = (path.Length == 1) ? "" : path[path.Length - 2]
let parent = (path.Length <= 2) ? "" : path[path.Length - 3]
let propertyInfo = new { ColumnOrdinal = i, PropertyName = property }
group propertyInfo by new { depth = path.Length - 1, parent, assoc } into t
orderby t.Key.depth, t.Key.parent, t.Key.assoc
select new MapGroup {
Depth = t.Key.depth,
Name = t.Key.assoc,
Parent = t.Key.parent,
Properties = t.ToDictionary(p => p.ColumnOrdinal, p => p.PropertyName)
}
).ToArray();
MapGroup topGroup = groups.Where(m => m.Depth == 0).SingleOrDefault()
?? new MapGroup {
Name = "", Parent = "", Properties = new Dictionary <int, string>()
};
ReadMapping(record, groups, topGroup, rootNode);
}
public virtual GClass853 GetBehavior()
{
if (this.C.Map.IsGG)
{
return(this.C.gclass863_0);
}
if (this.C.Map.MapName.StartsWith("4-"))
{
return(this.C.gclass861_0);
}
if (this.C.Map.MapId == 92)
{
return(this.C.gclass858_0);
}
MapGroup mapGroup = MapUtils.smethod_2(this.C.Map.MapId);
if (mapGroup == MapGroup.FrozenLabyrinth)
{
return(this.C.gclass855_0);
}
if (mapGroup == MapGroup.PayloadEscort)
{
return(this.C.gclass856_0);
}
return(this.C.gclass853_0);
}
public static void Init()
{
//clean map pointer
CurrentMapGroup = null;
//clean player
Players = new Player[MAX_TEAM_SLOTS];
for (int i = 0; i < MAX_TEAM_SLOTS; i++)
{
Players[i] = new Player();
}
Inventory = new int[MAX_INV_SLOTS];
for (int i = 0; i < MAX_INV_SLOTS; i++)
{
Inventory[i] = -1;
}
PrevInput = new Input();
CurrentInput = new Input();
InputTime = RenderTime.Zero;
replayInputs = new List <Command>();
Rand = new Random();
isLogging = true;
currentCharIndex = -MAX_TEAM_SLOTS;
CurrentMapID = "";
}
private static void LoadMapGroup(MapGroup group, GameObject parent = null)
{
if (group.groupName.Contains("fnc0000"))
{
return;
}
GameObject groupRootObject = new GameObject(group.groupName);
if (parent == null)
{
groupRootObject.GetComponent <Transform>().position = Vector3.Reflect(group.groupTransform.translation, Vector3.left);
groupRootObject.GetComponent <Transform>().rotation = Quaternion.Euler(Vector3.Reflect(group.groupTransform.rotation.ToVector3(), Vector3.left));
groupRootObject.GetComponent <Transform>().localScale = Vector3.Reflect(group.groupTransform.scale, Vector3.left);
}
else
{
groupRootObject.GetComponent <Transform>().SetParent(parent.GetComponent <Transform>());
groupRootObject.GetComponent <Transform>().localPosition = group.groupTransform.translation;
groupRootObject.GetComponent <Transform>().localRotation = group.groupTransform.rotation;
groupRootObject.GetComponent <Transform>().localScale = group.groupTransform.scale;
}
groupRootObject.SetActive(true);
if (group.entries != null && group.entries.Count > 0)
{
foreach (MapModelEntry entry in group.entries)
{
if (DebugCustomLoad)
{
if (!debugCustomLoadList.Contains(entry.modelId))
{
continue;
}
}
Mesh[] meshes = _modelMeshes[entry.modelId];
GameObject obj = AddMeshToNewGameObject(meshes, true);
obj.GetComponent <Transform>().SetParent(groupRootObject.GetComponent <Transform>());
obj.GetComponent <Transform>().localPosition = entry.transform.translation;
obj.GetComponent <Transform>().localRotation = entry.transform.rotation;
obj.GetComponent <Transform>().localScale = entry.transform.scale;
obj.SetActive(true);
}
}
if (group.groups != null && group.groups.Count > 0)
{
foreach (MapGroup subGroup in group.groups)
{
if (subGroup != null)
{
LoadMapGroup(subGroup, groupRootObject);
}
}
}
}
protected PixelMapObject(Camera camera, Vector2 pixelPosition, Vector2 size, MapGroup parent = null, string id = null)
: base(camera, pixelPosition * PixelOptions.PixelSize, size, parent)
{
Id = id ?? Guid.NewGuid().ToString();
IsDraggingAllowed = true;
OnParentRemoved += PixelMapObject_OnParentRemoved;
OnParentChanged += PixelMapObject_OnParentChanged;
}
private static void LoadGroupDirect(MapGroupAsset asset, int index)
{
Scene newScene = EditorSceneManager.OpenScene(GetScenePath(asset, index), OpenSceneMode.Additive);
MapGroup newGroup = newScene.GetRootGameObjects()[0].GetComponent <MapGroup>();
newGroup.index = index;
MapSystem.groupList[index] = newGroup;
}
public int GetMapGroupId(int mapId)
{
MapGroup group = this.MapGroups.Find(g => g.Maps.ContainsKey(mapId));
if (group == null)
{
return(-1);
}
return(group.GetId());
}
/// <summary>
/// 判定鼠标所处区域
/// </summary>
private void SetMouseArea()
{
Vector2 mousePos = Event.current.mousePosition;
//判断顺序=遮挡关系
//判定选中物体
MapGroup group = GroupList[MapSystem.currentGroupIndex];
if (group != null)
{
for (int i = 0; i < group.transform.childCount; i++)
{
Vector2 guiPos = GetElementGUIPos(group.transform.GetChild(i).position);
if (Vector2.Distance(mousePos, guiPos) < Prefs.elementRadius)
{
areaIndex = i;
mouseArea = MouseArea.ObjectArea;
return;
}
}
}
for (int i = 0; i < invalidObjectList.Count; i++)
{
Vector2 guiPos = GetElementGUIPos(invalidObjectList[i].transform.position);
if (Vector2.Distance(mousePos, guiPos) < Prefs.elementRadius)
{
areaIndex = -i - 1;
mouseArea = MouseArea.ObjectArea;
return;
}
}
//判定在中心
if (Vector2.Distance(mousePos, center) < Prefs.centerDiscRadius)
{
mouseArea = MouseArea.Center;
return;
}
//判定在缩放区域
if (mousePos.x < Prefs.sideWidth)
{
mouseArea = MouseArea.ScollArea;
return;
}
//判定选中组
if (Vector2.Distance(mousePos, center) < radius)
{
areaIndex = (int)(MapSystem.GetAngle(GetElementWorldPos(Event.current.mousePosition, 0)) / MapSystem.AnglePerGroup);
mouseArea = MouseArea.GroupArea;
return;
}
mouseArea = MouseArea.DragArea;
}
private void OnGroupGUI()
{
MapGroup group = target as MapGroup;
DrawPreview(true);
if (group == null)
{
GUILayout.Label("当前组为空", Prefs.informationStyle);
if (GUILayout.Button("", Prefs.mapAssetBackgroundStyle, GUILayout.ExpandHeight(true)))
{
GUI.FocusControl("");
}
GUILayout.BeginHorizontal(Prefs.mapAssetBackgroundStyle, GUILayout.Height(28));
{
GUILayout.FlexibleSpace();
if (GUILayout.Button("新建组", GUILayout.Width(60)))
{
MapGroupAssetEditor.NewEmptyGroup(MapSystem.currentGroupIndex); FocusOn(MapSystem.groupList[MapSystem.currentGroupIndex], SelectionType.Group);
}
if (MapAssetManager.CurrentAsset != null && GUILayout.Button("加载组", GUILayout.Width(60)))
{
MapGroupAssetEditor.LoadGroup(MapAssetManager.CurrentAsset, MapSystem.currentGroupIndex); FocusOn(MapSystem.groupList[MapSystem.currentGroupIndex], SelectionType.Group);
}
}
GUILayout.EndHorizontal();
}
else
{
EditableNameField(group);
if (GUILayout.Button("组序号：" + group.index, Prefs.mapAssetBackgroundStyle, GUILayout.ExpandHeight(true)))
{
GUI.FocusControl("");
}
GUILayout.BeginHorizontal(Prefs.mapAssetBackgroundStyle, GUILayout.Height(28));
{
GUILayout.FlexibleSpace();
if (GUILayout.Button("保存组", GUILayout.Width(60)))
{
MapGroupAssetEditor.SaveGroup(group); FocusOn(MapSystem.groupList[MapSystem.currentGroupIndex], SelectionType.Group);
}
if (GUILayout.Button("卸载组", GUILayout.Width(60)))
{
FocusOn(null, SelectionType.Group); MapGroupAssetEditor.UnLoadGroup(group);
}
if (MapAssetManager.CurrentAsset != null && GUILayout.Button("加载组", GUILayout.Width(60)))
{
MapGroupAssetEditor.LoadGroup(MapAssetManager.CurrentAsset, MapSystem.currentGroupIndex); FocusOn(MapSystem.groupList[MapSystem.currentGroupIndex], SelectionType.Group);
}
}
GUILayout.EndHorizontal();
}
}
/// <summary>
/// Parses an SgbFile for model entries or further gimmicks, and adds groups
/// to the given MapGroup.
/// </summary>
/// <param name="file"></param>
/// <param name="parent"></param>
/// <param name="models"></param>
private static void AddSgbModelsToMap(ref Map map, ref MapGroup mg, SgbFile file)
{
foreach (var sgbGroup in file.Data.OfType <SgbGroup>())
{
foreach (var mdl in sgbGroup.Entries.OfType <SgbModelEntry>())
{
int modelId = map.TryAddUniqueModel(mdl.Model.Model.ToMapModel());
mg.AddEntry(mdl.Model.ToMapModelEntry(modelId));
}
}
}
private static void DeserializeLayers(MapGroup g, dynamic layers)
{
foreach (var layer in layers)
{
try
{
LegacyLayerType typeOfLayer = (LegacyLayerType)Enum.ToObject(typeof(LegacyLayerType), Convert.ToInt32(layer["Type"]));
Layer mapLayer;
switch (typeOfLayer)
{
case LegacyLayerType.Grid:
mapLayer = GetGridLayer(layer);
break;
case LegacyLayerType.Image:
mapLayer = GetImageLayer(layer);
break;
case LegacyLayerType.Invalid:
throw new ArgumentException("The LayerType is an invalid layer type and cannot be loaded.");
case LegacyLayerType.LineShapefile:
mapLayer = GetLineLayer(layer);
break;
case LegacyLayerType.PointShapefile:
mapLayer = GetPointLayer(layer);
break;
case LegacyLayerType.PolygonShapefile:
mapLayer = GetPolygonLayer(layer);
break;
default:
throw new NotImplementedException("That LayerType is not supported.");
}
if (mapLayer != null)
{
LegacyDeserializer.DeserializeLayerProperties(layer, mapLayer);
g.Add(mapLayer);
}
}
catch (Exception exOpen)
{
// TODO: provide a warning of some sort, possibly ask abort/retry/continue
// HACK: we should be catching a more specific exception.
Trace.WriteLine(exOpen.Message);
}
}
}
private void LoadMap(XElement node)
{
var map = new MapGroup(this);
foreach (var nextNode in node.Elements())
{
var target = LoadTarget(nextNode);
map.AddTarget(target);
}
Maps.Add(map);
}
public static void StartMap(string mapName, int seed)
{
BeginSeed(seed);
MapGroup map_group = new BasicMapGroup();
map_group.Initialize();
CurrentMapGroup = map_group;
CurrentMapID = mapName;
ResetGameState();
Display.Screen.AddResult(new Results.Fade(Display.Screen.FadeType.FadeIn));
}
private void SetupResultsMapGroup(Core.Result.IResultSet set)
{
if (this.resultsGroup == null)
{
this.resultsGroup = new DotSpatial.Controls.MapGroup();
this.resultsGroup.LegendText = "Results";
this.resultsGroup.SelectionEnabled = true;
this.resultsGroup.IsVisible = false;
this.map.Layers.Add(this.resultsGroup);
}
if (set == null)
{
if (this.resultsLayer != null)
{
this.resultsGroup.Layers.Remove(this.resultsLayer);
this.resultsLayer = null;
}
this.curResultsSet = null;
this.resultsGroup.IsVisible = false;
return;
}
this.resultsGroup.IsVisible = true;
if (this.resultsGroup.Layers.Count > 0)
{
this.resultsGroup.Layers.Clear();
}
this.curResultsSet = set;
FeatureSet featureSet = new FeatureSet(FeatureType.Line);
featureSet.Projection = this.map.Projection;
featureSet.DataTable.Columns.Add(new DataColumn("LayerName", typeof(string)));
foreach (var layer in this.curResultsSet.LayerNames)
{
var points = this.curResultsSet.GetDataset(layer);
List <Coordinate> coords = new List <Coordinate>();
for (int i = 0; i <= points.GetUpperBound(0); i++)
{
coords.Add(new Coordinate(points[i, 0], points[i, 1]));
}
var feature = featureSet.AddFeature(new LineString(coords));
feature.DataRow["LayerName"] = layer;
}
this.resultsLayer = new MapLineLayer(featureSet);
this.resultsLayer.Symbology.EditorSettings.ExcludeExpression = "[LayerName] <> ''";
this.resultsGroup.Layers.Add(this.resultsLayer);
}
private static void DeleteUnit(MapUnit unit)
{
MapGroup group = unit.group;
group.unitList.RemoveAt(unit.index);
unit.group = null;
for (int j = unit.index; j < group.unitList.Count; j++)
{
group.unitList[j].index = j;
}
group.dirty = true;
}
/// <summary>
/// Get Data Sites Layer for given map
/// </summary>
/// <param name="map">Map</param>
/// <param name="createIfNotExists">Create data sites layer, if it not exists.</param>
/// <returns>Data Sites Layer.</returns>
public static IMapGroup GetDataSitesLayer(this IMap map, bool createIfNotExists = false)
{
if (map == null) throw new ArgumentNullException("map");
Contract.EndContractBlock();
var layerName = Resources.SearchGroupName;
var layer = FindGroupLayerByName(map, layerName);
if (layer == null && createIfNotExists)
{
layer = new MapGroup(map, layerName);
}
return layer;
}
/// <summary>
/// 保存到Asset中
/// </summary>
public static void SaveToAsset(MapGroup group, MapGroupAsset asset)
{
int index = group.index;
group.index = -1;
Quaternion rot = group.transform.rotation;
group.transform.rotation = Quaternion.identity;
PrefabUtility.ReplacePrefab(group.gameObject, asset.groupPrefab, ReplacePrefabOptions.ConnectToPrefab);
asset.baked = false;
group.transform.rotation = rot;
group.index = index;
}
private void DrawGroup(MapGroup group)
{
if (group.maps.Count == 0)
{
return;
}
var(head, tail) = group.maps.Perform((m) => Rooms.FindNodeByValue(m.Id)).Step();
(Vector2 start, Vector2 end)boundary = (head.pos, head.pos + head.size);
tail.Perform((n) => boundary = (Vector2.Min(n.pos, boundary.start), Vector2.Max(n.pos + n.size, boundary.end)));
var(p0, p1) = (ScreenPos(boundary.start), ScreenPos(boundary.end));
Vector2 s = p1 - p0;
DrawOutline(p0, s, 4, Color.white, CGUI.Constants.LineStyle.Dashed, true);
}
private void DeserializeGroups(dynamic groups)
{
// consider grouping these elements by Position attribute
// the groups are serialized in the correct order in the files we have examined.
foreach (var group in groups)
{
MapGroup g = new MapGroup();
g.LegendText = group["Name"];
g.IsExpanded = Convert.ToBoolean(group["Expanded"]);
DeserializeLayers(g, group.Layers.Elements());
_map.MapFrame.Layers.Add(g);
}
}
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.");
}
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.");
}
/// <summary>
/// 存储Group
/// </summary>
public static void SaveGroup(MapGroup group)
{
if (ContainsAsset(group.groupName))
{
if (EditorUtility.DisplayDialog("温馨小提示", "场景组已存在，是否覆盖？", "覆盖", "取消"))
{
MapGroupAssetEditor.SaveToAsset(group, GetGroupAssetByName(group.groupName));
group.dirty = false;
}
}
else
{
CreateGroupAsset(group);
}
}
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.");
}
private MapGroup GetSearchResultLayerGroup()
{
MapGroup layer = null;
foreach (var lay in _map.Layers)
{
if (lay is MapGroup &&
lay.LegendText.ToLower() == _searchGroupName.ToLower())
{
layer = lay as MapGroup;
break;
}
}
return(layer);
}
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.");
}
private void IterateThroughAnyGroupsToFindLayers(ILayer layer)
{
MapGroup g = (layer as MapGroup);
if (g == null)
{
LegacyLayerDeserializer.TryDeserialization(layer, App.Map);
}
else
{
foreach (var l in g.Layers)
{
IterateThroughAnyGroupsToFindLayers(l);
}
}
}
private static void DeserializeLayers(MapGroup g, dynamic layers)
{
foreach (var layer in layers)
{
try
{
LegacyLayerType typeOfLayer = (LegacyLayerType)Enum.ToObject(typeof(LegacyLayerType), Convert.ToInt32(layer["Type"]));
Layer mapLayer = null;
switch (typeOfLayer)
{
case LegacyLayerType.Grid:
mapLayer = GetGridLayer(layer);
break;
case LegacyLayerType.Image:
mapLayer = GetImageLayer(layer);
break;
case LegacyLayerType.Invalid:
throw new ArgumentException("The LayerType is an invalid layer type and cannot be loaded.");
case LegacyLayerType.LineShapefile:
mapLayer = GetLineLayer(layer);
break;
case LegacyLayerType.PointShapefile:
mapLayer = GetPointLayer(layer);
break;
case LegacyLayerType.PolygonShapefile:
mapLayer = GetPolygonLayer(layer);
break;
default:
throw new NotImplementedException("That LayerType is not supported.");
}
if (mapLayer != null)
{
LegacyDeserializer.DeserializeLayerProperties(layer, mapLayer);
g.Add(mapLayer);
}
}
catch (Exception exOpen)
{
//TODO: provide a warning of some sort, possibly ask abort/retry/continue
//HACK: we should be catching a more specific exception.
Trace.WriteLine(exOpen.Message);
}
}
}
public PixelRectangle(Camera camera, Vector2 position, Vector2 pixelSize, MapGroup parent = null, string id = null)
: base(camera, position, pixelSize * PixelOptions.PixelSize, parent, id)
{
#region Corners
_dragableLeftTop = CreateCornerDragable(() => GetDragableLeftTopPosition(BasicSize), DragableLeftTopOnDragging);
_dragableLeftBot = CreateCornerDragable(() => GetDragableLeftBotPosition(BasicSize), DragableLeftBotOnDragging);
_dragableRightTop = CreateCornerDragable(() => GetDragableRightTopPosition(BasicSize), DragableRightTopOnDragging);
_dragableRightBot = CreateCornerDragable(() => GetDragableRightBotPosition(BasicSize), DragableRightBotOnDragging);
#endregion
#region Sides
_dragableTop = CreateDragable(() => GetDragableTopPosition(BasicSize), () => HorizontalSideSize(BasicSize), DragableTop_OnDragging, DRAGABLE_SIDE_OPACITY);
_dragableLeft = CreateDragable(() => GetDragableLeftPosition(BasicSize), () => VerticalSideSize(BasicSize), DragableLeft_OnDragging, DRAGABLE_SIDE_OPACITY);
_dragableBot = CreateDragable(() => GetDragableBotPosition(BasicSize), () => HorizontalSideSize(BasicSize), DragableBot_OnDragging, DRAGABLE_SIDE_OPACITY);
_dragableRight = CreateDragable(() => GetDragableRightPosition(BasicSize), () => VerticalSideSize(BasicSize), DragableRight_OnDragging, DRAGABLE_SIDE_OPACITY);
#endregion
}
/// <summary>
/// 画指定地图组上的元素
/// </summary>
private void DrawElement(MapGroup group, float alpha)
{
if (group == null)
{
return;
}
float angle = group.index * MapSystem.AnglePerGroup + MapSystem.AnglePerGroup / 2;
for (int i = 0; i < group.transform.childCount; i++)
{
Transform child = group.transform.GetChild(i);
Handles.color = Color.Lerp(Prefs.backColor, Color.Lerp(GetElementColor(child.gameObject), Prefs.circleGradient.Evaluate(angle / MapSystem.MaxAngle), Prefs.elementColorMixRate), alpha);
Handles.DrawSolidDisc(GetElementGUIPos(child.position), Vector3.back, Prefs.elementRadius);
Handles.Label(GetElementGUIPos(child.position), child.name, Prefs.elementNameStyle);
}
Handles.color = Color.white;
}
/// <summary>
/// Get Data Sites Layer for given map
/// </summary>
/// <param name="map">Map</param>
/// <param name="createIfNotExists">Create data sites layer, if it not exists.</param>
/// <returns>Data Sites Layer.</returns>
public static IMapGroup GetDataSitesLayer(this IMap map, bool createIfNotExists = false)
{
if (map == null)
{
throw new ArgumentNullException("map");
}
Contract.EndContractBlock();
var layerName = LayerConstants.SearchGroupName;
var layer = FindGroupLayerByName(map, layerName);
if (layer == null && createIfNotExists)
{
layer = new MapGroup(map, layerName);
}
return(layer);
}
public void GetAllGroupsTest()
{
var map = new MapFrame();
var group = new MapGroup();
map.Layers.Add(group);
group.Layers.Add(new MapPolygonLayer());
group.Layers.Add(new MapLineLayer());
group.Layers.Add(new MapPointLayer());
//add a nested group
var group2 = new MapGroup();
group.Layers.Add(group2);
group2.Layers.Add(new MapPointLayer());
group2.Layers.Add(new MapLineLayer());
group2.Layers.Add(new MapPolygonLayer());
List<IMapGroup> groupList = map.GetAllGroups();
Assert.AreEqual(groupList.Count, 2);
}
public void GetAllLayersTest()
{
var map = new Map();
var group = new MapGroup();
map.Layers.Add(group);
group.Layers.Add(new MapPolygonLayer());
group.Layers.Add(new MapLineLayer());
group.Layers.Add(new MapPointLayer());
//add a nested group
var group2 = new MapGroup();
group.Layers.Add(group2);
group2.Layers.Add(new MapPointLayer());
group2.Layers.Add(new MapLineLayer());
group2.Layers.Add(new MapPolygonLayer());
List<ILayer> layerList = map.GetAllLayers();
Assert.AreEqual(layerList.Count, 6);
}
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 TestMapFrameIsNotNull_Group()
{
const string filename = @".\TestFiles\test-RandomPts.shp";
const string projectFileName = @".\testmapframeisnotnull.dspx";
AppManager manager = new AppManager();
Map map = new Map();
manager.Map = map;
//new map group added to map
MapGroup grp = new MapGroup(map, "group1");
//new map layer added to group
IFeatureSet fs = FeatureSet.Open(filename);
MapPointLayer l = new MapPointLayer(fs);
//add layer to group
grp.Layers.Add(l);
Assert.Greater(map.Layers.Count, 0);
Assert.IsNotNull(l.MapFrame);
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);
List<ILayer> layers = map.GetAllLayers();
Assert.IsNotNull(layers[0].MapFrame);
//delete file
System.IO.File.Delete(projectFileName);
}
[Ignore] // todo: fix reprojections
public void TestMapFrameIsNotNull_Group()
{
var filename = FileTools.PathToTestFile(@"Shapefiles\Cities\cities.shp");
var projectFileName = FileTools.GetTempFileName(".dspx");
_filesToRemove.Add(projectFileName);
var manager = new AppManager();
var map = new Map();
manager.Map = map;
//new map group added to map
var grp = new MapGroup(map, "group1");
//new map layer added to group
var fs = FeatureSet.Open(filename);
var l = new MapPointLayer(fs);
//add layer to group
grp.Layers.Add(l);
Assert.Greater(map.Layers.Count, 0);
Assert.IsNotNull(l.MapFrame);
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);
var layers = map.GetAllLayers();
Assert.IsNotNull(layers[0].MapFrame);
}
public void Deserialize(dynamic xmlRoot)
{
var mapwin4Section = xmlRoot.MapWindow4;
var mapwingisSection = xmlRoot.MapWinGIS;
_map.MapFrame.ProjectionString = mapwin4Section["ProjectProjection"];
if (!Convert.ToBoolean(mapwin4Section["ViewBackColor_UseDefault"]))
{
var mapControl = _map as Control;
if (mapControl != null)
mapControl.BackColor = LegacyDeserializer.GetColor(mapwin4Section["ViewBackColor"]);
_map.Invalidate();
}
// Deserialize layers
var layersDescs = mapwingisSection.Layers.Elements();
var allLayers = new Dictionary<int, List<ILayer>>(); // key: Group Name. Value: layers
foreach (var layer in mapwin4Section.Layers.Elements())
{
var name = (string)layer["Name"];
var groupInd = Convert.ToInt32(layer["GroupIndex"]);
if (!allLayers.ContainsKey(groupInd)) allLayers[groupInd] = new List<ILayer>();
var listLayers = allLayers[groupInd];
IMapLayer layerToAdd = null;
foreach (var layersDesc in layersDescs)
{
if (layersDesc["LayerName"] == name)
{
var lt = (string) layersDesc["LayerType"];
switch (lt)
{
case "Image":
layerToAdd = new MapImageLayer(ImageData.Open(layersDesc["Filename"]));
break;
case "Shapefile":
var fs = FeatureSet.OpenFile(layersDesc["Filename"]);
if (fs is PointShapefile)
{
layerToAdd = new MapPointLayer(fs);
}
else if (fs is PolygonShapefile)
{
layerToAdd = new MapPolygonLayer(fs);
}
else if (fs is LineShapefile)
{
layerToAdd = new MapLineLayer(fs);
}
else
{
Trace.WriteLine("Unsupported FeatureSet Type: " + fs.GetType());
}
break;
default:
Trace.WriteLine("Unsupported LayerType: " + lt);
break;
}
break;
}
}
if (layerToAdd != null)
{
layerToAdd.IsExpanded = Convert.ToBoolean(layer["Expanded"]);
listLayers.Add(layerToAdd);
}
}
// Deserialize groups
foreach (var group in mapwin4Section.Groups.Elements())
{
var gInd = Convert.ToInt32(group["Position"]);
var g = new MapGroup
{
LegendText = group["Name"],
IsExpanded = Convert.ToBoolean(group["Expanded"])
};
List<ILayer> gl;
if (allLayers.TryGetValue(gInd, out gl))
{
foreach (var layer in gl)
{
g.Add(layer);
}
}
_map.MapFrame.Layers.Add(g);
}
}
public void TestSetViewExtents()
{
Map mainMap = new Map();
mainMap.Projection = KnownCoordinateSystems.Projected.World.WebMercator;
Extent defaultMapExtent = new Extent(-130, 5, -70, 60);
string baseMapFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestFiles");
//SetDefaultMapExtents(mainMap);
MapPolygonLayer layStates;
MapGroup baseGroup = new MapGroup(mainMap.Layers, mainMap.MapFrame, mainMap.ProgressHandler);
baseGroup.LegendText = "Base Map Data";
baseGroup.ParentMapFrame = mainMap.MapFrame;
baseGroup.MapFrame = mainMap.MapFrame;
baseGroup.IsVisible = true;
//load the 'Countries of the world' layer
try
{
string fileName = Path.Combine(baseMapFolder, "50m_admin_0_countries.shp");
IFeatureSet fsCountries = FeatureSet.OpenFile(fileName);
fsCountries.Reproject(mainMap.Projection);
MapPolygonLayer layCountries = new MapPolygonLayer(fsCountries);
layCountries.LegendText = "Countries";
PolygonScheme schmCountries = new PolygonScheme();
schmCountries.EditorSettings.StartColor = Color.Orange;
schmCountries.EditorSettings.EndColor = Color.Silver;
schmCountries.EditorSettings.ClassificationType =
ClassificationType.UniqueValues;
schmCountries.EditorSettings.FieldName = "NAME";
schmCountries.EditorSettings.UseGradient = true;
schmCountries.CreateCategories(layCountries.DataSet.DataTable);
layCountries.Symbology = schmCountries;
baseGroup.Layers.Add(layCountries);
layCountries.MapFrame = mainMap.MapFrame;
}
catch { }
//load U.S. states layer
try
{
string fileName = Path.Combine(baseMapFolder, "50mil_us_states.shp");
IFeatureSet fsStates = FeatureSet.OpenFile(fileName);
fsStates.Reproject(mainMap.Projection);
layStates = new MapPolygonLayer(fsStates);
PolygonScheme schmStates = new PolygonScheme();
layStates.IsVisible = true;
layStates.LegendText = "U.S. States";
schmStates.EditorSettings.StartColor = Color.LemonChiffon;
schmStates.EditorSettings.EndColor = Color.LightPink;
schmStates.EditorSettings.ClassificationType =
ClassificationType.UniqueValues;
schmStates.EditorSettings.FieldName = "NAME";
schmStates.EditorSettings.UseGradient = true;
schmStates.CreateCategories(layStates.DataSet.DataTable);
layStates.Symbology = schmStates;
baseGroup.Layers.Add(layStates);
layStates.MapFrame = mainMap.MapFrame;
}
catch { }
//load Canada Provinces layer
try
{
string fileName = Path.Combine(baseMapFolder, "50mil_canada_provinces.shp");
IFeatureSet fsProvince = FeatureSet.OpenFile(fileName);
fsProvince.Reproject(mainMap.Projection);
MapPolygonLayer layProvince = new MapPolygonLayer(fsProvince);
PolygonScheme schmProvince = new PolygonScheme();
layProvince.IsVisible = true;
layProvince.LegendText = "Canada Provinces";
schmProvince.EditorSettings.StartColor = Color.Green;
schmProvince.EditorSettings.EndColor = Color.Yellow;
schmProvince.EditorSettings.ClassificationType =
ClassificationType.UniqueValues;
schmProvince.EditorSettings.FieldName = "NAME";
schmProvince.EditorSettings.UseGradient = true;
schmProvince.CreateCategories(layProvince.DataSet.DataTable);
layProvince.Symbology = schmProvince;
baseGroup.Layers.Add(layProvince);
layProvince.MapFrame = mainMap.MapFrame;
}
catch { }
//theme data group
//create a new empty 'themes' data group
try
{
MapGroup themeGroup = new MapGroup(mainMap.Layers,
mainMap.MapFrame, mainMap.ProgressHandler);
themeGroup.ParentMapFrame = mainMap.MapFrame;
themeGroup.MapFrame = mainMap.MapFrame;
themeGroup.LegendText = "Themes";
}
catch { }
double[] xy = new double[4];
xy[0] = defaultMapExtent.MinX;
xy[1] = defaultMapExtent.MinY;
xy[2] = defaultMapExtent.MaxX;
xy[3] = defaultMapExtent.MaxY;
double[] z = new double[] { 0, 0 };
string esri = "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137,298.257223562997]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.0174532925199433]]";
ProjectionInfo wgs84 = ProjectionInfo.FromEsriString(esri);
Reproject.ReprojectPoints(xy, z, wgs84, mainMap.Projection, 0, 2);
xy[0] = 1000000000000000;
xy[1] = 2000000000000000;
xy[2] = 3000000000000000;
xy[3] = 4000000000000000;
Extent ext = new Extent(xy);
mainMap.ViewExtents = ext;
}
public void TestMapFrameIsNotNull_Group()
{
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;
//new map group added to map
MapGroup grp = new MapGroup(map, "group1");
//new map layer added to group
IFeatureSet fs = FeatureSet.Open(filename);
MapPointLayer l = new MapPointLayer(fs);
//add layer to group
grp.Layers.Add(l);
Assert.Greater(map.Layers.Count, 0);
Assert.IsNotNull(l.MapFrame);
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);
List<ILayer> layers = map.GetAllLayers();
Assert.IsNotNull(layers[0].MapFrame);
}
private void DeserializeGroups(dynamic groups)
{
// consider grouping these elements by Position attribute
// the groups are serialized in the correct order in the files we have examined.
foreach (var group in groups)
{
MapGroup g = new MapGroup();
g.LegendText = group["Name"];
g.IsExpanded = Convert.ToBoolean(group["Expanded"]);
DeserializeLayers(g, group.Layers.Elements());
_map.MapFrame.Layers.Add(g);
}
}
