/// <summary> /// Adds the specified layer /// </summary> /// <param name="layer"></param> public void Add(RuntimeMapLayer layer) { if (!Contains(layer)) { var sel = new LayerSelection(layer); Add(sel); } }
/// <summary> /// Internal helper to construct a LayerSelection /// </summary> /// <param name="layer">The layer that the selection belongs to</param> /// <param name="ids">A list of xml <ID> nodes</param> internal LayerSelection(RuntimeMapLayer layer, XmlNodeList ids) : this(layer) { foreach (XmlNode n in ids) { Add(ParseIDString(n.InnerXml)); } }
/// <summary> /// Gets the parent group /// </summary> /// <param name="layer"></param> /// <returns></returns> public static RuntimeMapGroup GetParentGroup(this RuntimeMapLayer layer) { Check.ArgumentNotNull(layer, nameof(layer)); if (string.IsNullOrEmpty(layer.Group)) { return(null); } return(layer.Parent.Groups[layer.Group]); }
/// <summary> /// Returns the index of the given layer /// </summary> /// <param name="layer">The layer.</param> /// <returns> /// The index of the layer, or -1 if the layer is not in the collection /// </returns> public int IndexOf(RuntimeMapLayer layer) { for (int i = 0; i < _layers.Count; i++) { if (_layers[i].Layer.ObjectId == layer.ObjectId) { return(i); } } return(-1); }
/// <summary> /// Constructs a new LayerSelection with a number of selected featured /// </summary> /// <param name="layer">The layer to represent</param> public LayerSelection(RuntimeMapLayer layer) { if (layer == null) { throw new ArgumentNullException(nameof(layer)); //NOXLATE } if (layer.IdentityProperties.Length == 0 && layer.Parent.StrictSelection) { throw new Exception(Strings.ErrorLayerHasNoPk); } m_layer = layer; }
public int IndexOfLayer(RuntimeMapLayer layer) { return this.Layers.IndexOf(layer); }
public RuntimeMapLayer CreateLayer(string layerDefinitionId, RuntimeMapGroup group) { ILayerDefinition ldf = GetLayerDefinition(layerDefinitionId); var layer = new RuntimeMapLayer(this, ldf, true); if (group != null) layer.Group = group.Name; return layer; }
private void OnLayerSelected(RuntimeMapLayer layer) { var h = this.LayerSelected; if (h != null) h(this, layer); }
private void drawOrderCtrl_LayerDeleted(object sender, RuntimeMapLayer layer) { if (layer == propGrid.SelectedObject) propGrid.SelectedObject = null; }
internal bool GetVisibilityFlag(RuntimeMapLayer layer) { return layer.IsVisibleAtScale(_map.ViewScale); }
public void RemoveLayer(RuntimeMapLayer layer) { Check.NotNull(layer, "layer"); //NOXLATE this.Layers.Remove(layer); }
/// <summary> /// Inserts a selection layer into the collection /// </summary> /// <param name="index">The index to place the item at</param> /// <param name="layer">The layer.</param> public void Insert(int index, RuntimeMapLayer layer) => _layers.Insert(index, new LayerSelection(layer));
internal void OnLayerDefinitionChanged(RuntimeMapLayer layer) { TrackChange(layer.ObjectId, true, Change.ChangeType.definitionChanged, string.Empty); }
internal void OnLayerDisplayInLegendChanged(RuntimeMapLayer layer, string displayInLegendState) { TrackChange(layer.ObjectId, true, Change.ChangeType.displayInLegendChanged, displayInLegendState); }
internal void OnLayerAdded(RuntimeMapLayer layer) { var h = this.LayerAdded; if (h != null) h(this, layer); //Fix the draw order of this layer that was added //??? TrackChange(layer.ObjectId, true, Change.ChangeType.added, string.Empty); }
internal void AddLayer(RuntimeMapLayer layer) { this.Layers.Add(layer); }
public void SetLayerIndex(int index, RuntimeMapLayer layer) { this.Layers[index] = layer; }
private TreeNode CreateLayerNode(RuntimeMapLayer layer) { var node = new TreeNode(); node.Name = layer.ObjectId; node.Text = layer.LegendLabel; node.Checked = layer.Visible; //node.ContextMenuStrip = _legend.LayerContextMenu; var lt = layer.Type; var fsId = layer.FeatureSourceID; LayerNodeMetadata layerMeta = null; if (fsId.EndsWith("DrawingSource")) { node.SelectedImageKey = node.ImageKey = IMG_DWF; bool bInitiallySelectable = layer.Selectable; if (_layers.ContainsKey(layer.ObjectId)) { layerMeta = _layers[layer.ObjectId]; bInitiallySelectable = layerMeta.WasInitiallySelectable; } else //If not in the dictionary, assume it is a dynamically added layer { RuntimeMapGroup group = null; if (!string.IsNullOrEmpty(layer.Group)) group = _map.Groups[layer.Group]; layerMeta = new LayerNodeMetadata(layer, bInitiallySelectable); _layers[layer.ObjectId] = layerMeta; } node.Tag = layerMeta; node.ToolTipText = string.Format(Properties.Resources.DrawingLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID); } else //Vector or Grid layer { var ldfId = layer.LayerDefinitionID; if (_layers.ContainsKey(layer.ObjectId)) { layerMeta = _layers[layer.ObjectId]; } else { RuntimeMapGroup group = null; if (!string.IsNullOrEmpty(layer.Group)) group = _map.Groups[layer.Group]; layerMeta = new LayerNodeMetadata(layer, layer.Selectable); _layers[layer.ObjectId] = layerMeta; } if (string.IsNullOrEmpty(layerMeta.LayerDefinitionContent)) return null; node.Tag = layerMeta; const int LAYER_VECTOR = 0; const int LAYER_RASTER = 1; const int LAYER_DWF = 2; XmlDocument doc = new XmlDocument(); doc.LoadXml(layerMeta.LayerDefinitionContent); int type = LAYER_VECTOR; XmlNodeList scaleRanges = doc.GetElementsByTagName("VectorScaleRange"); if (scaleRanges.Count == 0) { scaleRanges = doc.GetElementsByTagName("GridScaleRange"); if (scaleRanges.Count == 0) { scaleRanges = doc.GetElementsByTagName("DrawingLayerDefinition"); if (scaleRanges.Count == 0) return null; type = LAYER_DWF; } else type = LAYER_RASTER; } String[] typeStyles = new String[] { "PointTypeStyle", "LineTypeStyle", "AreaTypeStyle", "CompositeTypeStyle" }; String[] ruleNames = new String[] { "PointRule", "LineRule", "AreaRule", "CompositeRule" }; node.ToolTipText = string.Format(Properties.Resources.DefaultLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName); //Do this if not cached already from a previous run if (!layerMeta.HasTheme() || !layerMeta.HasDefaultIcons()) { for (int sc = 0; sc < scaleRanges.Count; sc++) { XmlElement scaleRange = (XmlElement)scaleRanges[sc]; XmlNodeList minElt = scaleRange.GetElementsByTagName("MinScale"); XmlNodeList maxElt = scaleRange.GetElementsByTagName("MaxScale"); String minScale, maxScale; minScale = "0"; maxScale = "1000000000000.0"; // as MDF's VectorScaleRange::MAX_MAP_SCALE if (minElt.Count > 0) minScale = minElt[0].ChildNodes[0].Value; if (maxElt.Count > 0) maxScale = maxElt[0].ChildNodes[0].Value; if (type != LAYER_VECTOR) break; bool bComposite = false; //Check TS count. Give precedence to composite type styles List<XmlNode> typeStyleCol = new List<XmlNode>(); XmlNodeList styleNodes = scaleRange.GetElementsByTagName(typeStyles[3]); List<RuleData> rules = new List<RuleData>(); if (styleNodes.Count > 0) { foreach (XmlNode n in styleNodes) { // We will check if this typestyle is going to be shown in the legend XmlNodeList showInLegend = ((XmlElement)n).GetElementsByTagName("ShowInLegend"); //NOXLATE if (showInLegend.Count > 0) if (!bool.Parse(showInLegend[0].ChildNodes[0].Value)) continue; // This typestyle does not need to be shown in the legend typeStyleCol.Add(n); var ruleData = new RuleData(); ruleData.GeomType = 3; ruleData.RuleNodes = ((XmlElement)n).GetElementsByTagName(ruleNames[3]); if (ruleData.RuleNodes.Count > 0) rules.Add(ruleData); } bComposite = true; } else { for (int t = 0; t < 3; t++) { styleNodes = scaleRange.GetElementsByTagName(typeStyles[t]); foreach (XmlNode n in styleNodes) { // We will check if this typestyle is going to be shown in the legend XmlNodeList showInLegend = ((XmlElement)n).GetElementsByTagName("ShowInLegend"); //NOXLATE if (showInLegend.Count > 0) if (!bool.Parse(showInLegend[0].ChildNodes[0].Value)) continue; // This typestyle does not need to be shown in the legend typeStyleCol.Add(n); var ruleData = new RuleData(); ruleData.GeomType = t; ruleData.RuleNodes = ((XmlElement)n).GetElementsByTagName(ruleNames[t]); if (ruleData.RuleNodes.Count > 0) rules.Add(ruleData); } } } //No type styles. Skip if (typeStyleCol.Count == 0) continue; //Determine if this is themed or not int nTotalRules = 0; foreach (RuleData r in rules) { nTotalRules += r.RuleNodes.Count; } bool bThemed = nTotalRules > 1; if (bThemed) { int catIndex = 0; for (int i = 0; i < rules.Count; i++) { RuleData theRule = rules[i]; ThemeCategory themeCat = new ThemeCategory() { MinScale = minScale, MaxScale = maxScale, GeometryType = theRule.GeomType }; //Non-composite styles must be processed once if (layerMeta.CategoryExists(themeCat) && theRule.GeomType != 3) continue; layerMeta.SetDefaultIcon(themeCat, Properties.Resources.lc_theme); node.ToolTipText = string.Format(Properties.Resources.ThemedLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName, nTotalRules); if (_legend.ThemeCompressionLimit > 0 && theRule.RuleNodes.Count > _legend.ThemeCompressionLimit) { AddThemeRuleNode(layerMeta, themeCat, node, theRule.GeomType, catIndex, theRule.RuleNodes, 0); node.Nodes.Add(CreateCompressedThemeNode(layerMeta, themeCat, theRule.RuleNodes.Count - 2)); AddThemeRuleNode(layerMeta, themeCat, node, theRule.GeomType, (catIndex + (theRule.RuleNodes.Count - 1)), theRule.RuleNodes, theRule.RuleNodes.Count - 1); } else { for (int r = 0; r < theRule.RuleNodes.Count; r++) { AddThemeRuleNode(layerMeta, themeCat, node, theRule.GeomType, (catIndex + r), theRule.RuleNodes, r); } } //Only bump catIndex if composite, as category indexes for composite styles are handled differently if (bComposite) catIndex += theRule.RuleNodes.Count; } } else { Trace.Assert(rules.Count == 1); Trace.Assert(rules[0].RuleNodes.Count == 1); RuleData theRule = rules[0]; ThemeCategory themeCat = new ThemeCategory() { MinScale = minScale, MaxScale = maxScale, GeometryType = theRule.GeomType }; if (layerMeta.CategoryExists(themeCat)) continue; if (LayerNodeMetadata.ScaleIsApplicable(_map.ViewScale, themeCat)) { if (!layerMeta.HasDefaultIconsAt(_map.ViewScale)) { try { var img = _map.GetLegendImage(layer.LayerDefinitionID, _map.ViewScale, 16, 16, "PNG", (theRule.GeomType + 1), -1); legendCallCount++; layerMeta.SetDefaultIcon(themeCat, img); node.ToolTipText = string.Format(Properties.Resources.DefaultLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName); } catch { //layerMeta.SetDefaultIcon(themeCat, Properties.Resources.lc_broken); } } } } //for (int geomType = 0; geomType < typeStyles.Length; geomType++) //{ // ThemeCategory themeCat = new ThemeCategory() // { // MinScale = minScale, // MaxScale = maxScale, // GeometryType = geomType // }; // if (layerMeta.CategoryExists(themeCat)) // continue; // int catIndex = 0; // XmlNodeList typeStyle = scaleRange.GetElementsByTagName(typeStyles[geomType]); // for (int st = 0; st < typeStyle.Count; st++) // { // // We will check if this typestyle is going to be shown in the legend // XmlNodeList showInLegend = ((XmlElement)typeStyle[st]).GetElementsByTagName("ShowInLegend"); // if (showInLegend.Count > 0) // if (!bool.Parse(showInLegend[0].ChildNodes[0].Value)) // continue; // This typestyle does not need to be shown in the legend // XmlNodeList rules = ((XmlElement)typeStyle[st]).GetElementsByTagName(ruleNames[geomType]); // if (rules.Count > 1) // { // layerMeta.SetDefaultIcon(themeCat, Properties.Resources.lc_theme); // node.ToolTipText = string.Format(Properties.Resources.ThemedLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName, rules.Count); // if (_legend.ThemeCompressionLimit > 0 && rules.Count > _legend.ThemeCompressionLimit) // { // AddThemeRuleNode(layerMeta, themeCat, node, geomType, 0, rules, 0); // node.Nodes.Add(CreateCompressedThemeNode(layerMeta, themeCat, rules.Count - 2)); // AddThemeRuleNode(layerMeta, themeCat, node, geomType, rules.Count - 1, rules, rules.Count - 1); // } // else // { // for (int r = 0; r < rules.Count; r++) // { // AddThemeRuleNode(layerMeta, themeCat, node, geomType, catIndex++, rules, r); // } // } // } // else // { // if (LayerNodeMetadata.ScaleIsApplicable(_map.ViewScale, themeCat)) // { // if (!layerMeta.HasDefaultIconsAt(_map.ViewScale)) // { // try // { // var img = _map.GetLegendImage(layer.LayerDefinitionID, // _map.ViewScale, // 16, // 16, // "PNG", // -1, // -1); // legendCallCount++; // layerMeta.SetDefaultIcon(themeCat, img); // node.ToolTipText = string.Format(Properties.Resources.DefaultLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName); // } // catch // { // //layerMeta.SetDefaultIcon(themeCat, Properties.Resources.lc_broken); // } // } // } // } // } //} } } else //Already cached { Trace.TraceInformation("Icons already cached for: " + layer.Name); node.Nodes.AddRange(layerMeta.CreateThemeNodesFromCachedMetadata(_map.ViewScale)); } } return node; }
private bool HasVisibleParent(RuntimeMapLayer layer) { var current = layer.Group; if (current != null) { var parent = _map.Groups[current]; if (parent != null) { return parent.Visible; } } return true; }
/// <summary> /// Constructs a new LayerSelection with a number of selected featured /// </summary> /// <param name="layer">The layer to represent</param> /// <param name="ids">The list of composite IDs that the layer supports</param> public LayerSelection(RuntimeMapLayer layer, IEnumerable <object[]> ids) : this(layer) { AddRange(ids); }
void OnMapLayerAdded(object sender, RuntimeMapLayer layer) { if (_bComputeLayerCsAndExtentOnFirstLayerAdded && _mapEditor.Map.Layers.Count == 1) { Debug.WriteLine("Computing map extents and CS based on first layer added"); try { ILayerDefinition layerDef = (ILayerDefinition)_conn.ResourceService.GetResource(layer.LayerDefinitionID); string wkt; IEnvelope env = layerDef.GetSpatialExtent(true, out wkt); if (SupportsMutableMapProperties(_mapEditor.Map)) { _mapEditor.Map.MapExtent = env; _mapEditor.Map.CoordinateSystem = wkt; if (CsHelper.DefaultCalculator != null) { _mapEditor.Map.MetersPerUnit = CsHelper.DefaultCalculator.Calculate(wkt, 1.0); } else { var calc = _mapEditor.Map.CurrentConnection.GetCalculator(); _mapEditor.Map.MetersPerUnit = calc.Calculate(wkt, 1.0); } _mapEditor.ReloadViewer(); } else { //We have to tear down the current runtime map, update the shadow copy //map definition and then rebuild a new runtime map _mapEditor.SyncMap(); IMapDefinition mdf = _mapEditor.GetMapDefinition(); mdf.Extents = env; mdf.CoordinateSystem = wkt; CleanupExistingMap(); //If local, we'd be rebuilding off of the resource ID and not its in-memory //object representation so flush _mapEditor.EditorService.SyncSessionCopy(); _mapEditor.RebuildRuntimeMap(); _mapEditor.ReloadViewer(); } Debug.WriteLine("Computed map extents and CS"); } catch (Exception ex) { Debug.WriteLine("Uh-Oh: " + ex.ToString()); } } }
internal void OnLayerLegendLabelChanged(RuntimeMapLayer layer, string legendLabel) { TrackChange(layer.ObjectId, true, Change.ChangeType.legendLabelChanged, legendLabel); }
public void InsertLayer(int index, RuntimeMapLayer layer) { this.Layers.Insert(index, layer); }
/// <summary> /// Gets the selection layer at a given index /// </summary> /// <param name="index">The index to get or set the item for</param> /// <returns>The item at the given index</returns> public LayerSelection this[RuntimeMapLayer index] => _layers[IndexOf(index)];
internal void OnLayerParentChanged(RuntimeMapLayer layer, string parentId) { TrackChange(layer.ObjectId, true, Change.ChangeType.parentChanged, parentId); }
/// <summary> /// Gets whether this selection contains the specified layer /// </summary> /// <param name="item"></param> /// <returns></returns> public bool Contains(RuntimeMapLayer item) => IndexOf(item) >= 0;
internal void OnLayerRemoved(RuntimeMapLayer layer) { //??? TrackChange(layer.ObjectId, true, Change.ChangeType.removed, string.Empty); }
internal void OnLayerSelectabilityChanged(RuntimeMapLayer layer, string selectability) { TrackChange(layer.ObjectId, true, Change.ChangeType.selectabilityChanged, selectability); }
internal void OnLayerVisibilityChanged(RuntimeMapLayer layer, string visibility) { //??? TrackChange(layer.ObjectId, true, Change.ChangeType.visibilityChanged, visibility); }
private bool HasVisibleParent(RuntimeMapLayer layer) { if (string.IsNullOrEmpty(layer.Group)) return true; var current = _map.Groups[layer.Group]; if (current != null) return current.Visible; return true; }
private RuntimeMapLayer DeserializeLayer(MgBinaryDeserializer d) { //TODO: Review when we split to specific implementations RuntimeMapLayer t = new RuntimeMapLayer(this); t.Deserialize(d); return t; }
private void drawOrderCtrl_LayerSelected(object sender, RuntimeMapLayer layer) { propGrid.SelectedObject = new LayerNodeMetadata(layer); }
private static bool IsRasterLayer(RuntimeMapLayer layer) { var cls = layer.GetClassDefinition(); return IsRasterClass(cls); }