Exemplo n.º 1
0
        private static Dictionary <Table, List <long> > GetOidsByTable(
            IReadOnlyDictionary <MapMember, IReadOnlyCollection <long> > oidsByMapMember)
        {
            var result = new Dictionary <Table, List <long> >();

            foreach (KeyValuePair <MapMember, IReadOnlyCollection <long> > pair in oidsByMapMember)
            {
                MapMember mapMember = pair.Key;
                if (!(mapMember is FeatureLayer featureLayer))
                {
                    continue;
                }

                Table table = featureLayer.GetTable();

                if (!result.ContainsKey(table))
                {
                    result.Add(table, pair.Value.ToList());
                }
                else
                {
                    result[table].AddRange(pair.Value);
                }
            }

            return(result);
        }
        /// <summary>
        /// Initialize a QueryBuilderControlProperties with the specified mapMember.  Use the current definition query of that mapMember (if it exists) to extend the
        /// initialization.
        /// </summary>
        /// <param name="mapMember">MapMember to initialize the QueryBuilderControlProperties. </param>
        private void BuildControlProperties(MapMember mapMember)
        {
            // find the current definition query for the mapMember
            string            expression = "";
            BasicFeatureLayer fLayer     = mapMember as BasicFeatureLayer;
            StandaloneTable   table      = mapMember as StandaloneTable;

            if (fLayer != null)
            {
                expression = fLayer.DefinitionQuery;
            }
            else if (table != null)
            {
                expression = table.DefinitionQuery;
            }

            // create it
            var props = new QueryBuilderControlProperties()
            {
                MapMember  = mapMember,
                Expression = expression,
            };

            // set the binding properties
            this.ControlProperties = props;
            MapMemberName          = mapMember?.Name ?? "";

            // keep track of the original expression
            _origExpression = expression;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Use a null mapMember to reset the QueryBuilderControlProperties.
        /// </summary>
        private void ClearControlProperties()
        {
            // reset the control
            MapMember mapMember = null;

            BuildControlProperties(mapMember);
        }
 public static void ValidateDefinition(this MapMember mm, string xmlDefinition)
 {
     if (mm != null)
     {
         ValidateXML(xmlDefinition);
     }
 }
 /// <summary>
 /// Constructor initializing the base class with the layer and object id associated with the pop-up content
 /// </summary>
 //public DynamicPopupContent(MapMember mapMember, long id, List<HierarchyRow> hierarchyRows) : base(mapMember, id)
 public DynamicPopupContent(MapMember mapMember, long id, string featureClassName, RelateInfo relateInfo) : base(mapMember, id)
 {
     //Set property indicating the html content will be generated on demand when the content is viewed.
     IsDynamicContent  = true;
     _featureClassName = featureClassName;
     _id         = id;
     _relateInfo = relateInfo;
 }
 /// <summary>
 /// Constructor initializing the base class with the layer and object id associated with the pop-up content
 /// </summary>
 //public DynamicPopupContent(MapMember mapMember, long id, List<HierarchyRow> hierarchyRows) : base(mapMember, id)
 public DynamicPopupContent(MapMember mapMember, long id, string featureClassName, RelateInfo relateInfo) : base(mapMember, id)
 {
     //Set property indicating the html content will be generated on demand when the content is viewed.
     IsDynamicContent = true;
     _featureClassName = featureClassName;
     _id = id;
     _relateInfo = relateInfo;
 }
Exemplo n.º 7
0
        private void CreateTableControlContent(MapMember mapTableToAdd)
        {
            TableControlContent tableContent = null;

            if (TableControlContentFactory.IsMapMemberSupported(mapTableToAdd))
            {
                tableContent = TableControlContentFactory.Create(mapTableToAdd);
            }

            LabelsTableContent = tableContent;
        }
Exemplo n.º 8
0
        protected async void ChangeParcelType()
        {
            await QueuedTask.Run(async() =>
            {
                //check for selected layer
                if (MapView.Active.GetSelectedLayers().Count == 0)
                {
                    System.Windows.MessageBox.Show("Please select a source layer in the table of contents", "Change Parcel Type");
                    return;
                }

                //first get the feature layer that's selected in the table of contents
                var sourcePolygonL = MapView.Active.GetSelectedLayers().First() as FeatureLayer;

                var layers = MapView.Active.Map.GetLayersAsFlattenedList();
                var pfL    = layers.FirstOrDefault(l => l is ParcelLayer) as ParcelLayer;

                string sTargetParcelType = "Tax"; //Microsoft.VisualBasic.Interaction.InputBox("Target Parcel Type:", "Copy Parcel Lines To", "Tax");

                if (sTargetParcelType.Trim().Length == 0)
                {
                    return;
                }

                #region Change parcel type
                var targetFeatLyr = layers.FirstOrDefault(l => l.Name == "Tax" && l is FeatureLayer) as FeatureLayer; //the target parcel polygon feature layer

                if (pfL == null || sourcePolygonL == null)
                {
                    return;
                }

                //add polygon layers and the feature ids to change the type on to a new KeyValuePair
                MapMember mapMemberSource = sourcePolygonL as MapMember;
                var ids            = new List <long>(sourcePolygonL.GetSelection().GetObjectIDs());
                var kvp            = new KeyValuePair <MapMember, List <long> >(mapMemberSource, ids);
                var sourceFeatures = new List <KeyValuePair <MapMember, List <long> > > {
                    kvp
                };

                var editOper = new EditOperation()
                {
                    Name            = "Change Parcel Type",
                    ProgressMessage = "Change Parcel Type...",
                    ShowModalMessageAfterFailure = true,
                    SelectNewFeatures            = true,
                    SelectModifiedFeatures       = false
                };

                editOper.ChangeParcelType(pfL, sourceFeatures, targetFeatLyr, -1);
                await editOper.ExecuteAsync();
                #endregion
            });
        }
Exemplo n.º 9
0
        public void ShowPopup(MapMember mapMember, long objectID)
        {
            //Get the active map view.
            var mapView = MapView.Active;

            if (mapView == null)
            {
                return;
            }

            mapView.ShowPopup(mapMember, objectID);
        }
Exemplo n.º 10
0
 public PickableFeatureItem(MapMember mapMember, Feature feature, string text)
 {
     _feature      = feature;
     _featureLayer = mapMember as FeatureLayer;
     Oid           = feature.GetObjectID();
     ItemText      = text;
     QueuedTask.Run(() =>
     {
         Geometry      = feature.GetShape();
         _itemImageUri = GetImagePath(Geometry);
     });
 }
        private void GetLayerNode(Layer lyr, XmlDocument doc)
        {
            Layer plyr = MapView.Active.Map.FindLayer(lyr.URI, true);


            MapMember mm = lyr;
            XmlNode   lnd;

            lnd = doc.SelectSingleNode("//Layers/String[text()='" + lyr.URI + "']");
            CIMService cs = new MapMemberService((MapMember)lyr);
            //var xmlLayer = GetlayerDefinitionAsync(lyr);
            var xmlLayer = cs.GetDefinitionAsync();
            XmlDocumentFragment xfrag = doc.CreateDocumentFragment();

            xfrag.InnerXml = xmlLayer.Result;
            XmlNode nd = xfrag.FirstChild;

            switch (lyr.GetType().Name)
            {
            case "GroupLayer":
                lnd.AppendChild(xfrag);
                GroupLayer glyr = (GroupLayer)lyr;
                foreach (var layer in glyr.Layers)
                {
                    lnd = doc.SelectSingleNode("//Layers/String[text()='" + lyr.URI + "']");
                    GetLayerNode(layer, doc);
                }
                break;

            case "FeatureLayer":
                var cfl = CIMFeatureLayer.FromXml(xmlLayer.Result);

                GetRenderer(cfl.Renderer, nd, ReportDir);
                lnd.AppendChild(nd);
                break;

            case "RasterLayer":
                var crl = CIMRasterLayer.FromXml(xmlLayer.Result);
                //GetRenderer(crl., nd, ReportDir);
                lnd.AppendChild(nd);
                break;

            case "StandaloneTable":
                lnd = doc.SelectSingleNode("//StandaloneTables/String[text()='" + lyr.URI + "']");
                lnd.AppendChild(nd);
                break;

            default:
                lnd.AppendChild(nd);
                break;
            }
        }
 public static Task <string> GetDefinitionXmlAsync(this MapMember mm)
 {
     return(QueuedTask.Run(() => {
         if (mm == null)
         {
             return "";
         }
         if (mm is Layer)
         {
             return ((Layer)mm).GetDefinition().ToXml();
         }
         return ((StandaloneTable)mm).GetDefinition().ToXml();
     }));
 }
Exemplo n.º 13
0
        protected async void AssignFeaturesToRecord()
        {
            await QueuedTask.Run(async() =>
            {
                //check for selected layer
                if (MapView.Active.GetSelectedLayers().Count == 0)
                {
                    System.Windows.MessageBox.Show("Please select a source feature layer in the table of contents", "Assign Features To Record");
                    return;
                }

                //first get the feature layer that's selected in the table of contents
                var srcFeatLyr          = MapView.Active.GetSelectedLayers().First() as FeatureLayer;
                var layers              = MapView.Active.Map.GetLayersAsFlattenedList();
                var myParcelFabricLayer = layers.FirstOrDefault(l => l is ParcelLayer) as ParcelLayer;
                if (myParcelFabricLayer == null)
                {
                    return;
                }

                var theActiveRecord = myParcelFabricLayer.GetActiveRecord();
                if (theActiveRecord == null)
                {
                    System.Windows.MessageBox.Show("There is no Active Record. Please set the active record and try again.", "Copy Line Features To");
                    return;
                }
                #region Assign features to active record
                var guid     = theActiveRecord.Guid;
                var editOper = new EditOperation()
                {
                    Name            = "Assign Features to Record",
                    ProgressMessage = "Assign Features to Record...",
                    ShowModalMessageAfterFailure = true,
                    SelectNewFeatures            = true,
                    SelectModifiedFeatures       = false
                };
                //add parcel type layers and their feature ids to a new KeyValuePair
                MapMember mapMemberSource = srcFeatLyr as MapMember;
                var ids            = new List <long>(srcFeatLyr.GetSelection().GetObjectIDs());
                var kvp            = new KeyValuePair <MapMember, List <long> >(mapMemberSource, ids);
                var sourceFeatures = new List <KeyValuePair <MapMember, List <long> > > {
                    kvp
                };

                editOper.AssignFeaturesToRecord(myParcelFabricLayer, sourceFeatures, guid, ParcelRecordAttribute.CreatedByRecord);
                await editOper.ExecuteAsync();
                #endregion
            });
        }
Exemplo n.º 14
0
        public static IEnumerable <Feature> GetFeatures([NotNull] MapMember mapMember,
                                                        [NotNull] List <long> oidList,
                                                        bool recycling = false)
        {
            var basicFeatureLayer = mapMember as BasicFeatureLayer;

            if (basicFeatureLayer == null)
            {
                yield break;
            }

            foreach (Feature feature in GetFeatures(basicFeatureLayer, oidList, recycling))
            {
                yield return(feature);
            }
        }
 public static Task SetDefinitionAsync(this MapMember mm, string xmlDefinition)
 {
     ValidateXML(xmlDefinition);//This can throw!
     return(QueuedTask.Run(() => {
         if (mm is Layer)
         {
             var baseLayer = DeserializeXmlDefinition <CIMBaseLayer>(xmlDefinition);
             ((Layer)mm).SetDefinition(baseLayer);
         }
         else
         {
             var table = DeserializeXmlDefinition <CIMStandaloneTable>(xmlDefinition);
             ((StandaloneTable)mm).SetDefinition(table);
         }
     }));
 }
Exemplo n.º 16
0
        public TabItemViewModel(MapMember mapMember,
                                DependencyObject visualTreeRoot)
        {
            TableContent   = TableControlContentFactory.Create(mapMember);
            MapMember      = mapMember;
            VisualTreeRoot = visualTreeRoot;

            MenuItem zoomItem = new MenuItem()
            {
                Header           = "Zoom to Feature",
                Command          = ZoomToRowCommand,
                CommandParameter = this
            };

            RowContextMenu = new ContextMenu();
            RowContextMenu.Items.Add(zoomItem);
        }
        public DefinitionFilterItem(MapMember mapMember, DefinitionQuery definitionQuery)
        {
            //if (definitionFilter == null) return;
            _mapMember        = mapMember;
            _queryExpression  = definitionQuery?.WhereClause;
            _expressionName   = definitionQuery?.Name;
            _definitionFilter = definitionQuery;
            var queryBuilderControlProps = new QueryBuilderControlProperties
            {
                Expression     = CurrentDefinitionQuery?.WhereClause,
                EditClauseMode = true,
                MapMember      = ItemMapMember,
                AutoValidate   = true
            };

            ControlProperties = queryBuilderControlProps;
            _isActiveFilter   = IsDefinitionFilterActive();
        }
        public DefinitionFilterItem(MapMember mapMember, CIMDefinitionFilter definitionFilter)
        {
            //if (definitionFilter == null) return;
            _mapMember        = mapMember;
            _queryExpression  = definitionFilter?.DefinitionExpression;
            _expressionName   = definitionFilter?.Name;
            _definitionFilter = definitionFilter;
            var queryBuilderControlProps = new QueryBuilderControlProperties
            {
                Expression     = DefinitionFilter?.DefinitionExpression,
                EditClauseMode = true,
                MapMember      = ItemMapMember,
                AutoValidate   = true
            };

            ControlProperties = queryBuilderControlProps;
            _isActiveFilter   = IsDefinitionFilterActive();
        }
Exemplo n.º 19
0
        public void ShowPopupWithWindowDef(MapMember mapMember, long objectID)
        {
            if (MapView.Active == null)
            {
                return;
            }
            // Sample code: https://github.com/ArcGIS/arcgis-pro-sdk-community-samples/blob/master/Map-Exploration/CustomIdentify/CustomIdentify.cs
            var topLeftCornerPoint = new System.Windows.Point(200, 200);
            var popupDef           = new PopupDefinition()
            {
                Append   = true,                             // if true new record is appended to existing (if any)
                Dockable = true,                             // if true popup is dockable - if false Append is not applicable
                Position = topLeftCornerPoint,               // Position of top left corner of the popup (in pixels)
                Size     = new System.Windows.Size(200, 400) // size of the popup (in pixels)
            };

            MapView.Active.ShowPopup(mapMember, objectID, popupDef);
        }
Exemplo n.º 20
0
        private async Task GetStyleItemForLayerAsync(MapMember mapMember)
        {
            StyleItemType styleItemType = StyleItemType.Color;

            //Selected layer is a FeatureLayer
            if (mapMember is FeatureLayer)
            {
                var featureLayer     = mapMember as FeatureLayer;
                var featureShapeType = featureLayer.ShapeType;
                switch (featureShapeType)
                {
                case esriGeometryType.esriGeometryPoint:
                    styleItemType = StyleItemType.PointSymbol;
                    break;

                case esriGeometryType.esriGeometryMultipoint:
                    styleItemType = StyleItemType.PointSymbol;
                    break;

                case esriGeometryType.esriGeometryLine:
                    styleItemType = StyleItemType.LineSymbol;
                    break;

                case esriGeometryType.esriGeometryPolyline:
                    styleItemType = StyleItemType.LineSymbol;
                    break;

                case esriGeometryType.esriGeometryPolygon:
                    styleItemType = StyleItemType.PolygonSymbol;
                    break;

                default:
                    break;
                }
                SelectedStyleItemType = styleItemType;
            }
            //Selected Layer is a GraphicsLayer
            if (mapMember is GraphicsLayer)
            {
                await GetStyleItemForGraphicsLayerAsync(mapMember as GraphicsLayer);
            }
        }
Exemplo n.º 21
0
        /// PopupContent.IsDynamicContent, PopupContent.OnCreateHtmlContent
        /// <example>
        /// <code title="Show A Dynamic Pop-up" description="Show a custom pop-up with dynamically generated content." region="Show A Dynamic Pop-up" source="..\..\ArcGIS\SharedArcGIS\SDK\Examples\ArcGIS.Desktop.Mapping\MapExploration\Popup_Examples.cs" lang="CS"/>
        /// </example>
        #region Show A Dynamic Pop-up
        public void ShowDynamicPopup(MapMember mapMember, List <long> objectIDs)
        {
            //Get the active map view.
            var mapView = MapView.Active;

            if (mapView == null)
            {
                return;
            }

            //Create popup whose content is created the first time the item is requested.
            var popups = new List <PopupContent>();

            foreach (var id in objectIDs)
            {
                popups.Add(new DynamicPopupContent(mapMember, id));
            }

            mapView.ShowCustomPopup(popups);
        }
Exemplo n.º 22
0
 private void ApplyFilterChangesToLayer(MapMember mapMember)
 {
     QueuedTask.Run(() => {
         //Apply these filters to the Selected Map Member
         if (mapMember is BasicFeatureLayer)
         {
             var selectedMapMemberAsLayer = mapMember as BasicFeatureLayer;
             selectedMapMemberAsLayer.InsertDefinitionQuery(new DefinitionQuery {
                 WhereClause = ThisDefinitionFilterItem.QueryExpression
             });
         }
         if (mapMember is StandaloneTable)
         {
             var selectedMapMemberAsTable = mapMember as StandaloneTable;
             selectedMapMemberAsTable.InsertDefinitionQuery(new DefinitionQuery {
                 WhereClause = ThisDefinitionFilterItem.QueryExpression
             });
         }
     });
 }
Exemplo n.º 23
0
        // todo daro Use MapViewInitialized or DrawComplete?
        //private void OnMapViewInitialized(MapViewEventArgs e)
        //{
        //	// https://community.esri.com/t5/arcgis-pro-sdk-questions/how-to-wait-for-mapview-to-load/td-p/831290
        //	// https://community.esri.com/t5/arcgis-pro-sdk-questions/initialize-module-when-map-loaded/m-p/816108#M2596

        //	// fires every time a view is initialized
        //	// todo daro obj.MapView or MapView.Active?

        //	foreach (var pair in _uriByWorklistName)
        //	{
        //		// ReSharper disable once UnusedVariable
        //		string worklistName = pair.Key;
        //		// ReSharper disable once UnusedVariable
        //		string uri = pair.Value;
        //	}
        //}

        private void OnMapMemberPropertiesChanged(MapMemberPropertiesChangedEventArgs e)
        {
            ViewUtils.Try(() =>
            {
                List <MapMember> mapMembers          = e.MapMembers.ToList();
                List <MapMemberEventHint> eventHints = e.EventHints.ToList();

                if (mapMembers.Count == 0)
                {
                    return;
                }

                Assert.AreEqual(mapMembers.Count, eventHints.Count,
                                $"Unequal count of {nameof(MapMember)} and {nameof(MapMemberEventHint)}");

                for (var index = 0; index < mapMembers.Count; index++)
                {
                    if (eventHints[index] != MapMemberEventHint.Name)
                    {
                        continue;
                    }

                    MapMember mapMember = mapMembers[index];

                    string uri  = LayerUtils.GetUri(mapMember);
                    string name = WorkListUtils.ParseName(uri);

                    if (!_viewsByWorklistName.TryGetValue(name, out IWorkListObserver view))
                    {
                        continue;
                    }

                    if (view.View == null)
                    {
                        continue;
                    }

                    ViewUtils.RunOnUIThread(() => { view.View.Title = mapMember.Name; });
                }
            }, _msg);
        }
Exemplo n.º 24
0
        public static async Task <IEnumerable <long> > GetSelectedIdsFor(MapMember layer)
        {
            if (layer == null)
            {
                return(Enumerable.Empty <long>());
            }

            var selection = await GetSelection(layer.Map);

            return(selection
                   .SelectMany(pair => {
                if (pair.Key is BasicFeatureLayer selectedLayer)
                {
                    if (selectedLayer == layer)
                    {
                        return pair.Value;
                    }
                }

                return null;
            }));
        }
        private void ApplyFilterChangesToLayer(MapMember mapMember, System.Collections.ObjectModel.ObservableCollection <DefinitionFilterItem> definitionFilters)
        {
            //Get the definition filters from the collection of DefinitionFilters
            var defFilters = new List <CIMDefinitionFilter>();

            foreach (var filter in definitionFilters)
            {
                defFilters.Add(filter.DefinitionFilter);
            }
            QueuedTask.Run(() => {
                //Apply these filters to the Selected Map Member
                if (mapMember is BasicFeatureLayer)
                {
                    var selectedMapMemberAsLayer = mapMember as BasicFeatureLayer;
                    selectedMapMemberAsLayer.SetDefinitionFilters(defFilters);
                }
                if (mapMember is StandaloneTable)
                {
                    var selectedMapMemberAsTable = mapMember as StandaloneTable;
                    selectedMapMemberAsTable.SetDefinitionFilters(defFilters);
                }
            });
        }
        private void CreateTableControlContent()
        {
            TableControlContent tableContent = null;

            var       selectedLyrs = MapView.Active.GetSelectedLayers();
            var       selectedSTs  = MapView.Active.GetSelectedStandaloneTables();
            MapMember item         = null;

            if (selectedLyrs != null && selectedLyrs.Count == 1)
            {
                item = selectedLyrs[0];
            }
            else if (selectedSTs != null && selectedSTs.Count == 1)
            {
                item = selectedSTs[0];
            }
            if (TableControlContentFactory.IsMapMemberSupported(item))
            {
                tableContent = TableControlContentFactory.Create(item);
            }

            TableContent = tableContent;
        }
        private async void OnMapSelectionChanged(MapSelectionChangedEventArgs args)
        {
            bool contains = false;

            foreach (var selection in args.Selection)
            {
                MapMember    mapMember = selection.Key;
                FeatureLayer layer     = mapMember as FeatureLayer;

                if (layer == Layer)
                {
                    _selection = selection.Value;
                    contains   = true;
                    await GenerateGmlAsync();

                    if (IsVisibleInGlobespotter)
                    {
                        if (_vectorLayerList.EditTool != EditTools.SketchPointTool)
                        {
                            Measurements = await ReloadSelectionAsync();
                        }
                        else
                        {
                            _updateMeasurements = true;
                        }
                    }
                }
            }

            if ((!contains) && (_selection != null))
            {
                Measurements = null;
                _selection   = null;
                await GenerateGmlAsync();
            }
        }
Exemplo n.º 28
0
        /// <summary>
        /// Build a QueryBuilderControlProperties for the specified mapView.  Finds the first BasicFeatureLayer or StandAloneTable highlighted in the TOC.
        /// </summary>
        /// <param name="mapView">a mapView.</param>
        private void BuildControlProperties(MapView mapView)
        {
            MapMember mapMember = null;

            if (mapView != null)
            {
                // only interested in basicFeatureLayers ... they are the ones with definition queries
                var selectedTOCLayers = mapView.GetSelectedLayers().OfType <BasicFeatureLayer>();
                var selectedTOCTables = mapView.GetSelectedStandaloneTables();

                // take layers over tables... but only take the first
                if (selectedTOCLayers.Count() > 0)
                {
                    mapMember = selectedTOCLayers.First();
                }
                else if (selectedTOCTables.Count() > 0)
                {
                    mapMember = selectedTOCTables.First();
                }
            }

            // build the control properties
            BuildControlProperties(mapMember);
        }
Exemplo n.º 29
0
 /// <summary>
 /// Constructor initializing the base class with the layer and object id associated with the pop-up content
 /// </summary>
 public DynamicPopupContent(MapMember mapMember, long id) : base(mapMember, id)
 {
     //Set property indicating the html content will be generated on demand when the content is viewed.
     IsDynamicContent = true;
 }
 /// <summary>
 /// Constructor initializing the base class with the layer and object id associated with the pop-up content
 /// </summary>
 public DynamicPopupContent(MapMember mapMember, long id) : base(mapMember, id)
 {
   //Set property indicating the html content will be generated on demand when the content is viewed.
   IsDynamicContent = true;
 }
Exemplo n.º 31
0
 public DynamicPopupContent(MapMember mapMember, long objectID)
 {
     MapMember        = mapMember;
     ID               = objectID;
     IsDynamicContent = true;
 }
Exemplo n.º 32
0
 public static string GetUri([NotNull] MapMember mapMember)
 {
     return(mapMember.URI);
 }