Exemple #1
0
        /// <summary>
        /// Executes a brand new editing operation that is part of the working session
        /// (as opposed to a historical session that is being deserialized from the database).
        /// </summary>
        /// <param name="op">The edit to execute</param>
        /// <param name="ff">The factory for creating new spatial features (specify null if
        /// the edit is not expected to create anything).</param>
        internal void Execute(FeatureFactory ff)
        {
            Debug.Assert(m_Session == CadastralMapModel.Current.WorkingSession);
            CadastralMapModel mapModel = this.MapModel;

            // Create the spatial features
            ProcessFeatures(ff);

            // Calculate any geometry for spatial features
            CalculateGeometry(null);

            // Index features that were created (and ensure the map extent has been
            // expanded to include the new features)
            Feature[] feats = ff.CreatedFeatures;

            if (feats.Length > 0)
            {
                // Attempt to associate new features with database attributes
                AttributeData.Load(feats);
                mapModel.AddToIndex(feats);

                // Define user-perceived IDs if necessary
                CreateIds(feats);

                // Ensure user-perceived ID objects have been indexed too
                mapModel.AddFeatureIds(feats);
            }

            // Point referenced features to this editing operation
            AddReferences();

            // Mark any new topological lines as "moved" so that they will be
            // intersected with the map
            PrepareForIntersect(feats);

            // Ensure the map structure has been updated to account for the new data.
            mapModel.CleanEdit();

            // Save the edit to the database
            m_Session.SaveOperation(this);
        }
Exemple #2
0
        /// <summary>
        /// Cancels all updates.
        /// </summary>
        internal void Cancel()
        {
            // No can do if an update is currently in progress!
            if (m_Cmd != null)
            {
                string msg = "You are in the middle of making an update." + System.Environment.NewLine;
                msg += "You must cancel that first.";
                MessageBox.Show(msg);
                return;
            }

            // If we've currently got a problem, treat the cancellation
            // request as a request to undo just the last revision
            if (m_CurrentUpdate != null)
            {
                m_CurrentUpdate.RevertChanges();
                m_CurrentUpdate = null;
                m_Problem       = null;

                CadastralMapModel model = CadastralMapModel.Current;
                model.EnsureFeaturesAreIndexed();
                model.CleanEdit();

                if (m_SelectedFeature != null)
                {
                    Run(m_SelectedFeature);
                }

                m_Info.OnFinishUpdate(null);
                ActiveDisplay.Redraw();
            }
            else
            {
                // If we saved any updates, undo them all.
                UndoAll();

                FinishCommand();
            }
        }
Exemple #3
0
        /// <summary>
        /// Applies a revised edit (as noted on a prior call to <see cref="AddUpdate"/>).
        /// </summary>
        void ApplyRevision()
        {
            UpdateOperation uop;

            // If we already have an update context, it means we're applying a revision in an attempt
            // to fix a rollforward problem.

            if (m_CurrentUpdate == null)
            {
                uop             = new UpdateOperation(m_Revisions);
                m_CurrentUpdate = new UpdateEditingContext(uop);
            }
            else
            {
                // Undo the previous recalculation
                m_CurrentUpdate.RevertChanges();

                // Include the latest revision
                uop = m_CurrentUpdate.UpdateSource;
                foreach (RevisedEdit rev in m_Revisions)
                {
                    uop.AddRevisedEdit(rev);
                }
            }

            m_Revisions = null;

            try
            {
                // Serialize the edit to a string BEFORE we apply the changes (otherwise we'll end
                // up serializing the modified values)
                string editString = uop.GetEditString();

                // Apply changes, then rework the map model to account for the update
                uop.ApplyChanges();
                m_CurrentUpdate.Recalculate();

                // Update topology
                uop.MapModel.CleanEdit();

                // Save the update as part of the working session
                uop.Session.SaveEditString(uop, editString);
                m_CurrentUpdate = null;
                m_NumUpdate++;
            }

            catch (RollforwardException rex)
            {
                // Remember the problem edit
                m_Problem = rex.Problem;

                // The spatial index may be missing stuff (since the recalc exited early)
                CadastralMapModel model = uop.MapModel;
                model.EnsureFeaturesAreIndexed();

                // Update topology and cleanup any junk
                model.CleanEdit();

                // Re-center on the problem edit if it's off-screen
                ISpatialDisplay display   = base.ActiveDisplay;
                IPosition       newCenter = m_Problem.GetRecenter(display.Extent);
                if (newCenter != null)
                {
                    display.Center = newCenter;
                }

                MessageBox.Show("Cannot re-work geometry due to edit " + m_Problem.EditSequence, "Problem",
                                MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }

            catch (Exception ex)
            {
                MessageBox.Show(ex.StackTrace, ex.Message);
                m_CurrentUpdate.RevertChanges();
                m_CurrentUpdate = null;
            }
        }