// Use the EditOperation in the RowChangedEventArgs to append actions to be executed.
        //  Your actions will become part of the operation and combined into one item on the undo stack

        private void HookEvents()
        {
            // subscribe to the RowCreatedEvent
            Table table = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>().FirstOrDefault().GetTable();

            RowCreatedEvent.Subscribe(MyRowCreatedEvent, table);
        }
        internal static void subRowEvent()
        {
            Dockpane1ViewModel pane = FrameworkApplication.DockPaneManager.Find(_dockPaneID) as Dockpane1ViewModel;

            QueuedTask.Run(() =>
            {
                if (MapView.Active.GetSelectedLayers().Count == 0)
                {
                    MessageBox.Show("Select a feature class from the Content 'Table of Content' first.");
                    Utils.RunOnUIThread(() => {
                        var contentsPane = FrameworkApplication.DockPaneManager.Find("esri_core_contentsDockPane");
                        contentsPane.Activate();
                    });
                    return;
                }
                //Listen for row events on a layer
                var featLayer      = MapView.Active.GetSelectedLayers().First() as FeatureLayer;
                var layerTable     = featLayer.GetTable();
                pane.SelectedLayer = featLayer as BasicFeatureLayer;

                //subscribe to row events
                var rowCreateToken  = RowCreatedEvent.Subscribe(pane.onCreatedRowEvent, layerTable);
                var rowChangedToken = RowChangedEvent.Subscribe(pane.onRowChangedEvent, layerTable);
            });
        }
        private void onProjectOpened(ProjectEventArgs obj)
        {
            //subscribe to edit completed event
            //this is across all maps and layers in the project
            EditCompletedEvent.Subscribe(onEditCompleted);

            //subscribe to row events for a certain layer in a certain map
            //look for a map named 'Layers' in the project
            var mapProjItem = Project.Current.GetItems <MapProjectItem>().FirstOrDefault(item => item.Name == "Layers");

            if (mapProjItem == null)
            {
                return;
            }

            //run on MCT
            QueuedTask.Run(() =>
            {
                var theMap = mapProjItem.GetMap();

                //look for a layer named 'Parcels' in the map
                var featLayer = theMap.FindLayers("Parcels").FirstOrDefault() as FeatureLayer;
                if (featLayer == null)
                {
                    return;
                }
                var layerTable = featLayer.GetTable();

                //setup row events
                _rowCreateToken  = RowCreatedEvent.Subscribe(onRowCreateEvent, layerTable);
                _rowDeleteToken  = RowDeletedEvent.Subscribe(onRowDeleteEvent, layerTable);
                _rowChangedToken = RowChangedEvent.Subscribe(onRowChangedEvent, layerTable);
            });
        }
        protected override void OnClick()
        {
            QueuedTask.Run(async() =>
            {
                //find layer and derive geodatabase
                var cpLayer = MapView.Active.Map.FindLayers("CrowdPlanning").FirstOrDefault() as FeatureLayer;

                if (cpLayer == null)
                {
                    return;
                }
                var geodatabase = cpLayer.GetFeatureClass().GetDatastore() as Geodatabase;

                //Advise if the project has edits. Need to clear edits to make schema changes.
                if (Project.Current.HasEdits)
                {
                    MessageBox.Show("Please save or discard edits", "Pending Edits");
                    return;
                }

                //Delete and Create the editlog table
                //For the purpose of this sample, start with a fresh table
                var mva = Geoprocessing.MakeValueArray(geodatabase.GetPath().AbsolutePath, "EditLog");
                var cts = new System.Threading.CancellationTokenSource();
                await Geoprocessing.ExecuteToolAsync("CreateTable_management", mva);

                //add fields to editlog
                var tablePath = geodatabase.GetPath().AbsolutePath + @"\EditLog";
                mva           = Geoprocessing.MakeValueArray(tablePath, "Layer", "STRING");
                await Geoprocessing.ExecuteToolAsync("AddField_management", mva);
                mva = Geoprocessing.MakeValueArray(tablePath, "OID", "LONG");
                await Geoprocessing.ExecuteToolAsync("AddField_management", mva);
                mva = Geoprocessing.MakeValueArray(tablePath, "Date", "DATE");
                await Geoprocessing.ExecuteToolAsync("AddField_management", mva);
                mva = Geoprocessing.MakeValueArray(tablePath, "EditType", "STRING");
                await Geoprocessing.ExecuteToolAsync("AddField_management", mva);

                _ehTable = MapView.Active.Map.FindStandaloneTables("EditLog").FirstOrDefault();

                //setup row events for layer
                if (_rowChangedToken == null)
                {
                    _rowChangedToken = RowChangedEvent.Subscribe(OnRowEvent, cpLayer.GetTable());
                }
                if (_rowCreatedToken == null)
                {
                    _rowCreatedToken = RowCreatedEvent.Subscribe(OnRowEvent, cpLayer.GetTable());
                }
                if (_rowDeletedToken == null)
                {
                    _rowDeletedToken = RowDeletedEvent.Subscribe(OnRowEvent, cpLayer.GetTable());
                }
            });
        }
Exemple #5
0
        protected void subRowEvent()
        {
            QueuedTask.Run(() =>
            {
                //Listen for row events on a layer
                var featLayer  = MapView.Active.GetSelectedLayers().First() as FeatureLayer;
                var layerTable = featLayer.GetTable();

                //subscribe to row events
                var rowCreateToken = RowCreatedEvent.Subscribe(onRowEvent, layerTable);
                var rowChangeToken = RowChangedEvent.Subscribe(onRowEvent, layerTable);
                var rowDeleteToken = RowDeletedEvent.Subscribe(onRowEvent, layerTable);
            });
        }
Exemple #6
0
 /// <summary>
 /// setup event listeners for a given featurelayer (with featurelayer name)
 /// </summary>
 /// <param name="activeMapView"></param>
 /// <param name="featureLayerName"></param>
 private void SetUpRowEventListener(MapView activeMapView, string featureLayerName)
 {
     // Find our polygon feature layer
     _workedOnPolygonLayer = activeMapView.Map.GetLayersAsFlattenedList().FirstOrDefault((fl) => fl.Name == featureLayerName) as FeatureLayer;
     UpdateStatusText((_workedOnPolygonLayer == null)
           ? $@"{featureLayerName} NOT found"
           : $@"Listening to {featureLayerName} changes");
     // setup event listening ...
     QueuedTask.Run(() =>
     {
         _onRowChangedEvent = RowChangedEvent.Subscribe(OnRowChangedEvent, _workedOnPolygonLayer.GetTable());
         _onRowCreatedEvent = RowCreatedEvent.Subscribe(OnRowCreatedEvent, _workedOnPolygonLayer.GetTable());
     });
 }
Exemple #7
0
        protected void SetupEvents()
        {
            QueuedTask.Run(() =>
            {
                var featLayer  = MapView.Active.GetSelectedLayers().First() as FeatureLayer;
                var layerTable = featLayer.GetTable();

                //subscribe to row events for a layer
                var rowCreateToken = RowCreatedEvent.Subscribe(onRowEvent, layerTable);
                var rowChangeToken = RowChangedEvent.Subscribe(onRowEvent, layerTable);
                var rowDeleteToken = RowDeletedEvent.Subscribe(onRowEvent, layerTable);
            });

            //subscribe to editevents
            var editComplete = EditCompletedEvent.Subscribe(onEditComplete);
        }
        private bool Register()
        {
            var layers = MapView.Active.Map.GetLayersAsFlattenedList().OfType <FeatureLayer>();

            QueuedTask.Run(() => {
                foreach (var fl in layers)
                {
                    var fc     = fl.GetFeatureClass();
                    var tokens = new List <SubscriptionToken>();
                    //These events are fired once ~per feature~,
                    //per table
                    tokens.Add(RowCreatedEvent.Subscribe((rc) => RowEventHandler(rc), fc));
                    tokens.Add(RowChangedEvent.Subscribe((rc) => RowEventHandler(rc), fc));
                    tokens.Add(RowDeletedEvent.Subscribe((rc) => RowEventHandler(rc), fc));
                    _rowevents[fl.Name] = tokens;
                }

                //This event is fired once per edit execute
                //Note: This event won't fire if the edits were cancelled
                _editevents.Add(EditCompletingEvent.Subscribe((ec) =>
                {
                    RecordEvent("EditCompletingEvent", "");
                    //can also cancel edit in the completing event...
                    //cancels everything (that is cancealable)
                    //
                    //you'll need to modify the RowEventHandler() to prevent if
                    //from doing the cancel or this will never get called
                    if (_cancelEdit)
                    {
                        ec.CancelEdit($"EditCompletingEvent, edit cancelled");
                        AddEntry("*** edits cancelled");
                        AddEntry("---------------------------------");
                    }
                }));
                //This event is fired after all the edits are completed (and on
                //save, discard, undo, redo) and is fired once
                _editevents.Add(EditCompletedEvent.Subscribe((ec) => {
                    HandleEditCompletedEvent(ec);
                    return(Task.FromResult(0));
                }));
            });
            return(true);
        }
        public async Task <bool> InitializeEventsAsync()
        {
            bool result = (Layer.ConnectionStatus == ConnectionStatus.Connected);

            if (result)
            {
                MapSelectionChangedEvent.Subscribe(OnMapSelectionChanged);
                DrawCompleteEvent.Subscribe(OnDrawCompleted);

                await QueuedTask.Run(() =>
                {
                    var table   = Layer.GetTable();
                    _rowChanged = RowChangedEvent.Subscribe(OnRowChanged, table);
                    _rowDeleted = RowDeletedEvent.Subscribe(OnRowDeleted, table);
                    _rowCreated = RowCreatedEvent.Subscribe(OnRowCreated, table);
                });
            }

            await LoadMeasurementsAsync();

            return(result);
        }