Ejemplo n.º 1
0
        protected override void OnToolDeactivateCore(bool hasMapViewChanged)
        {
            _feedback?.Clear();
            _feedback = null;

            base.OnToolDeactivateCore(hasMapViewChanged);
        }
Ejemplo n.º 2
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;
        }