コード例 #1
0
        private async Task <bool> UpdatePolygonResultPreviewAsync(
            bool nonDefaultSide,
            [NotNull] Polyline sketchPolyline,
            [NotNull] List <Feature> polygonSelection)
        {
            ReshapeResult reshapeResult = null;

            if (polygonSelection.Count != 0)
            {
                // Idea: ReshapeOperation class that contains the options to build the rpc, cancellation token, time out settings and logging.

                // TODO: Keep this source and cancel in case finish sketch happens
                var cancellationTokenSource = new CancellationTokenSource(3000);

                reshapeResult = MicroserviceClient.TryReshape(
                    polygonSelection, sketchPolyline, null, false, true,
                    nonDefaultSide, cancellationTokenSource.Token);
            }

            // TODO: discard result if the user has since clicked again or some other event (finish / esc) happened

            // TODO in 2.6 and higher try:
            //FrameworkApplication.QueueIdleAction(
            //	() => _feedback?.UpdatePreview(reshapeResult.ResultFeatures));

            return(await QueuedTaskUtils.Run(
                       () => _feedback?.UpdatePreview(reshapeResult?.ResultFeatures)));
        }
コード例 #2
0
        public static async Task <MapPoint> GetOpenJawReplacementPointAsync(
            [NotNull] ReshapeGrpc.ReshapeGrpcClient rpcClient,
            [NotNull] Feature polylineFeature,
            [NotNull] Polyline reshapeLine,
            bool useNonDefaultReshapeSide)
        {
            var request = new OpenJawReshapeLineReplacementRequest()
            {
                UseNonDefaultReshapeSide = useNonDefaultReshapeSide
            };

            SpatialReference sr =
                await QueuedTaskUtils.Run(
                    () =>
            {
                Geometry geometryToReshape = polylineFeature.GetShape();

                request.Feature = ProtobufConversionUtils.ToGdbObjectMsg(
                    polylineFeature, geometryToReshape, true);

                request.ReshapePath = ProtobufConversionUtils.ToShapeMsg(reshapeLine);

                return(geometryToReshape.SpatialReference);
            });

            // Not in a queued task (but it is still called multiple times because...)
            ShapeMsg pointMsg = rpcClient.GetOpenJawReshapeLineReplaceEndPoint(request);

            return(await QueuedTaskUtils.Run(
                       () => (MapPoint)ProtobufConversionUtils.FromShapeMsg(pointMsg, sr)));
        }
コード例 #3
0
        protected override void OnToolKeyUp(MapViewKeyEventArgs k)
        {
            _msg.VerboseDebug("OnToolKeyUp");

            // TODO: Key pressed management
            //_shiftIsPressed = false;

            try
            {
                QueuedTaskUtils.Run(
                    delegate
                {
                    if ((k.Key == Key.LeftShift || k.Key == Key.RightShift) &&
                        SelectionCursor != null && IsInSelectionPhase())
                    {
                        SetCursor(SelectionCursor);
                    }

                    OnKeyUpCore(k);
                    return(true);
                });
            }
            catch (Exception e)
            {
                HandleError($"Error in tool key up ({Caption}): {e.Message}", e, true);
            }
        }
コード例 #4
0
ファイル: OneClickToolBase.cs プロジェクト: ProSuite/ProSuite
        protected override void OnToolKeyUp(MapViewKeyEventArgs k)
        {
            _msg.VerboseDebug("OnToolKeyUp");

            try
            {
                QueuedTaskUtils.Run(
                    delegate
                {
                    if (IsShiftKey(k.Key))
                    {
                        ShiftReleasedCore();
                    }

                    OnKeyUpCore(k);
                    return(true);
                });
            }
            catch (Exception e)
            {
                HandleError($"Error in tool key up ({Caption}): {e.Message}", e, true);
            }
            finally
            {
                PressedKeys.Remove(k.Key);
            }
        }
コード例 #5
0
        //protected override void OnKeyUpCore(MapViewKeyEventArgs k)
        //{
        //	_msg.VerboseDebug("OnKeyUpCore");

        //	if (k.Key == _keyToggleNonDefaultSide)
        //	{
        //		_nonDefaultSideMode = ! _nonDefaultSideMode;

        //		k.Handled = true;
        //	}
        //	else if (k.Key == Key.Space)
        //	{
        //		k.Handled = true;
        //	}

        //	base.OnKeyUpCore(k);
        //}

        //protected override async Task HandleKeyUpAsync(MapViewKeyEventArgs k)
        //{
        //	// At 2.5 this is never called (despite setting k.Handled = true above).
        // TODO: Test in 2.6/2.7
        //	try
        //	{
        //		if (k.Key == _keyToggleNonDefaultSide ||
        //		    k.Key == Key.Space)
        //		{
        //			_updateFeedbackTask = UpdateFeedbackAsync(_nonDefaultSideMode);

        //			await _updateFeedbackTask;
        //		}
        //	}
        //	catch (Exception e)
        //	{
        //		_msg.Warn("Error generating preview", e);
        //	}
        //	finally
        //	{
        //		_updateFeedbackTask = null;
        //	}
        //}

        protected override async Task <bool> OnEditSketchCompleteCoreAsync(
            Geometry sketchGeometry, EditingTemplate editTemplate, MapView activeView,
            CancelableProgressor cancelableProgressor = null)
        {
            _feedback.Clear();

            // TODO: cancel all running background tasks...

            var polyline = (Polyline)sketchGeometry;

            List <Feature> selection;

            // Or allow selecting next feature already?
            SetCursor(Cursors.Wait);

            bool success = await QueuedTaskUtils.Run(async() =>
            {
                selection = GetApplicableSelectedFeatures(activeView).ToList();

                var potentiallyAffectedFeatures =
                    GetAdjacentFeatures(selection, cancelableProgressor);

                // This timout should be enough even in extreme circumstances:
                int timeout = selection.Count * 10000;
                _cancellationTokenSource = new CancellationTokenSource(timeout);

                ReshapeResult result = MicroserviceClient.Reshape(
                    selection, polyline, potentiallyAffectedFeatures, true, true,
                    _nonDefaultSideMode, _cancellationTokenSource.Token);

                if (result == null)
                {
                    return(false);
                }

                Dictionary <Feature, Geometry> resultFeatures =
                    result.ResultFeatures.ToDictionary(r => r.Feature,
                                                       r => r.UpdatedGeometry);

                LogReshapeResults(result, selection.Count);

                success = await SaveAsync(resultFeatures);

                // At some point, hopefully, read-only operations on the CIM model can run in parallel
                await ToolUtils.FlashResultPolygonsAsync(activeView, resultFeatures);

                return(success);
            });

            _nonDefaultSideMode = false;

            //if (!_advancedReshapeOptions.RemainInSketchMode)
            {
                StartSelectionPhase();
            }

            return(success);            // taskSave.Result;
        }
コード例 #6
0
        protected override bool HandleEscape()
        {
            QueuedTaskUtils.Run(
                () =>
            {
                SelectionUtils.ClearSelection(ActiveMapView.Map);

                ResetDerivedGeometries();

                StartSelectionPhase();

                return(true);
            });

            return(true);
        }
コード例 #7
0
        protected override void OnToolKeyDown(MapViewKeyEventArgs k)
        {
            _msg.VerboseDebug("OnToolKeyDown");

            try
            {
                PressedKeys.Add(k.Key);

                if (IsModifierKey(k.Key) || HandledKeys.Contains(k.Key))
                {
                    k.Handled = true;
                }

                if (k.Key == _keyShowOptionsPane)
                {
                    ShowOptionsPane();
                }

                // Cancel outside a queued task otherwise the current task that blocks the queue
                // cannot be cancelled.
                if (k.Key == Key.Escape)
                {
                    HandleEscape();
                }

                QueuedTaskUtils.Run(
                    delegate
                {
                    if (IsShiftKey(k.Key) &&
                        SelectionCursorShift != null && IsInSelectionPhase())
                    {
                        SetCursor(SelectionCursorShift);
                    }

                    OnKeyDownCore(k);

                    return(true);
                });
            }
            catch (Exception e)
            {
                HandleError($"Error in tool key down ({Caption}): {e.Message}", e, true);
            }
        }
コード例 #8
0
ファイル: EraseToolBase.cs プロジェクト: esride-jts/ProSuite
        protected override async Task <bool> OnEditSketchCompleteCoreAsync(
            Geometry sketchGeometry,
            EditingTemplate editTemplate,
            MapView activeView,
            CancelableProgressor cancelableProgressor = null)
        {
            var polygon = (Polygon)sketchGeometry;

            var resultFeatures = await QueuedTaskUtils.Run(
                () => CalculateResultFeatures(activeView, polygon),
                cancelableProgressor);

            var taskSave  = QueuedTaskUtils.Run(() => SaveAsync(resultFeatures));
            var taskFlash = QueuedTaskUtils.Run(() => FlashAsync(activeView, resultFeatures));

            await Task.WhenAll(taskFlash, taskSave);

            return(taskSave.Result);
        }
コード例 #9
0
        private async Task <bool> UpdateFeedbackAsync(bool nonDefaultSide)
        {
            var sketchPolyline = await GetCurrentSketchAsync() as Polyline;

            if (sketchPolyline == null || sketchPolyline.IsEmpty || sketchPolyline.PointCount < 2)
            {
                _feedback?.Clear();
                return(true);
            }

            // Snapshot:
            MapView activeMapView = ActiveMapView;

            List <Feature> polylineSelection;
            List <Feature> polygonSelection;

            bool result =
                await QueuedTaskUtils.Run(
                    async() =>
            {
                List <Feature> selection =
                    GetApplicableSelectedFeatures(activeMapView).ToList();

                polylineSelection =
                    GdbObjectUtils.Filter(selection, GeometryType.Polyline).ToList();

                polygonSelection =
                    GdbObjectUtils.Filter(selection, GeometryType.Polygon).ToList();

                bool updated =
                    await UpdateOpenJawReplacedEndpointAsync(nonDefaultSide, sketchPolyline,
                                                             polylineSelection);

                updated |= await UpdatePolygonResultPreviewAsync(
                    nonDefaultSide, sketchPolyline,
                    polygonSelection);

                return(updated);
            });

            return(result);
        }
コード例 #10
0
        private void OnMapSelectionChanged(MapSelectionChangedEventArgs args)
        {
            _msg.VerboseDebug("OnToolActivateAsync");

            try
            {
                QueuedTaskUtils.Run(
                    delegate
                {
                    // Used to clear derived geometries etc.
                    bool result = OnMapSelectionChangedCore(args);

                    return(result);
                });
            }
            catch (Exception e)
            {
                HandleError($"Error OnSelectionChanged: {e.Message}", e, true);
            }
        }
コード例 #11
0
        protected override bool HandleEscape()
        {
            QueuedTaskUtils.Run(
                delegate
            {
                if (IsInSketchMode)
                {
                    // if sketch is empty, also remove selection and return to selection phase

                    if (!RequiresSelection)
                    {
                        // remain in sketch mode, just reset the sketch
                        ResetSketch();
                    }
                    else
                    {
                        Geometry sketch = GetCurrentSketchAsync().Result;

                        if (sketch != null && !sketch.IsEmpty)
                        {
                            ResetSketch();
                        }
                        else
                        {
                            SelectionUtils.ClearSelection(ActiveMapView.Map);

                            StartSelectionPhase();
                        }
                    }
                }
                else
                {
                    ClearSketchAsync();
                    SelectionUtils.ClearSelection(ActiveMapView.Map);
                }

                return(true);
            });
            return(true);
        }
コード例 #12
0
        protected override void OnToolKeyDown(MapViewKeyEventArgs k)
        {
            _msg.VerboseDebug("OnToolKeyDown");

            try
            {
                if (IsModifierKey(k.Key) || HandledKeys.Contains(k.Key))
                {
                    k.Handled = true;
                }

                if (k.Key == _keyShowOptionsPane)
                {
                    ShowOptionsPane();
                }

                QueuedTaskUtils.Run(
                    delegate
                {
                    if (k.Key == Key.Escape)
                    {
                        return(HandleEscape());
                    }

                    if ((k.Key == Key.LeftShift || k.Key == Key.RightShift) &&
                        SelectionCursorShift != null && IsInSelectionPhase())
                    {
                        SetCursor(SelectionCursorShift);
                    }

                    OnKeyDownCore(k);

                    return(true);
                });
            }
            catch (Exception e)
            {
                HandleError($"Error in tool key down ({Caption}): {e.Message}", e, true);
            }
        }
コード例 #13
0
 protected override Task <bool> OnSketchModifiedAsync()
 {
     return(QueuedTaskUtils.Run(OnSketchModifiedCore));
 }
コード例 #14
0
        private async Task <bool> OnSelectionSketchComplete(Geometry sketchGeometry,
                                                            CancelableProgressor progressor)
        {
            // TODO: Add Utils method to KeyboardUtils to do it in the WPF way
            SelectionCombinationMethod selectionMethod =
                KeyboardUtils.IsModifierPressed(Keys.Shift)
                                        ? SelectionCombinationMethod.XOR
                                        : SelectionCombinationMethod.New;

            Geometry selectionGeometry;
            var      pickerWindowLocation = new Point(0, 0);

            Dictionary <BasicFeatureLayer, List <long> > candidatesOfManyLayers =
                await QueuedTaskUtils.Run(() =>
            {
                DisposeOverlays();

                selectionGeometry    = GetSelectionGeometry(sketchGeometry);
                pickerWindowLocation =
                    MapView.Active.MapToScreen(selectionGeometry.Extent.Center);

                // find all features spatially related with selectionGeometry
                return(FindFeaturesOfAllLayers(selectionGeometry));
            });

            if (!candidatesOfManyLayers.Any())
            {
                //no candidate (user clicked into empty space): clear selection
                await QueuedTask.Run(() =>
                {
                    SelectionUtils.ClearSelection(ActiveMapView.Map);
                });

                return(false);
            }

            if (SketchingMoveType == SketchingMoveType.Click)
            {
                //note if necessary add a virtual core method here for overriding

                if (GetSelectionSketchMode() == SelectionMode.Original
                    )             //alt was pressed: select all xy
                {
                    await QueuedTask.Run(() =>
                    {
                        Selector.SelectLayersFeaturesByOids(
                            candidatesOfManyLayers, selectionMethod);
                    });
                }

                // select a single feature using feature reduction and picker
                else
                {
                    IEnumerable <KeyValuePair <BasicFeatureLayer, List <long> > > candidatesOfLayers =
                        await QueuedTask.Run(
                            () => GeometryReducer.GetReducedset(candidatesOfManyLayers));

                    // show picker if more than one candidate
                    if (GeometryReducer.ContainsManyFeatures(candidatesOfManyLayers))
                    {
                        List <IPickableItem> pickables = new List <IPickableItem>();
                        foreach (var layerCandidates in candidatesOfLayers)
                        {
                            pickables.AddRange(
                                await QueuedTask.Run(
                                    () => PickerUI.Picker.CreatePickableFeatureItems(
                                        layerCandidates)));
                        }

                        var picker = new PickerUI.Picker(pickables, pickerWindowLocation);

                        var item = await picker.PickSingle() as PickableFeatureItem;

                        if (item != null)
                        {
                            var kvp = new KeyValuePair <BasicFeatureLayer, List <long> >(
                                item.Layer, new List <long> {
                                item.Oid
                            });

                            await QueuedTask.Run(() =>
                            {
                                Selector.SelectLayersFeaturesByOids(
                                    kvp, selectionMethod);
                            });
                        }
                    }
                    else
                    {
                        await QueuedTask.Run(() =>
                        {
                            Selector.SelectLayersFeaturesByOids(
                                candidatesOfLayers.First(), selectionMethod);
                        });
                    }
                }
            }

            if (SketchingMoveType == SketchingMoveType.Drag)
            {
                //CTRL was pressed: picker shows FC's to select from
                if (GetSelectionSketchMode() == SelectionMode.UserSelect)
                {
                    List <IPickableItem> pickingCandidates = await QueuedTask.Run(() =>
                    {
                        List <FeatureClassInfo> featureClassInfos =
                            Selector.GetSelectableFeatureclassInfos();

                        return(PickableItemAdapter.Get(featureClassInfos));
                    });

                    var picker = new PickerUI.Picker(pickingCandidates, pickerWindowLocation);

                    var item = await picker.PickSingle() as PickableFeatureClassItem;

                    if (item != null)
                    {
                        await QueuedTask.Run(() =>
                        {
                            item.BelongingFeatureLayers.ForEach(layer =>
                            {
                                List <long> oids = candidatesOfManyLayers[layer];
                                QueryFilter qf   = new QueryFilter {
                                    ObjectIDs = oids
                                };
                                layer.Select(qf, selectionMethod);
                            });
                        });
                    }
                }

                //no modifier pressed: select all in envelope
                else
                {
                    await QueuedTask.Run(() =>
                    {
                        Selector.SelectLayersFeaturesByOids(
                            candidatesOfManyLayers, selectionMethod);
                    });
                }
            }

            MapView activeMapView = MapView.Active;

            await QueuedTask.Run(() =>
                                 ProcessSelection(
                                     SelectionUtils.GetSelectedFeatures(activeMapView),
                                     progressor));

            return(true);
        }