/// <summary> /// Reacts to selection of the OK button in the dialog. /// </summary> /// <param name="wnd">The dialog window. If this matches the dialog that /// this command knows about, the command will be executed (and, on success, /// the dialog will be destroyed). If it's some other window, it must /// be a sub-dialog created by our guy, so let it handle the request.</param> /// <returns></returns> internal override bool DialFinish(Control wnd) { if (m_Dialog == null) { MessageBox.Show("LineExtensionUI.DialFinish - No dialog!"); return(false); } // If we are doing an update, alter the original operation. UpdateUI up = this.Update; if (up != null) { // Get the original operation. LineExtensionOperation pop = (up.GetOp() as LineExtensionOperation); if (pop == null) { MessageBox.Show("LineExtensionUI.DialFinish - Unexpected edit type."); return(false); } // Remember the changes as part of the UI object (the original edit remains // unchanged for now) UpdateItemCollection changes = pop.GetUpdateItems(m_Dialog.IsExtendFromEnd, m_Dialog.Length); if (!up.AddUpdate(pop, changes)) { return(false); } } else { // Get info from the dialog m_IsExtendFromEnd = m_Dialog.IsExtendFromEnd; m_Length = m_Dialog.Length; IdHandle idh = m_Dialog.PointId; CadastralMapModel map = CadastralMapModel.Current; m_LineType = (m_Dialog.WantLine ? map.DefaultLineType : null); // Execute the edit LineExtensionOperation op = null; try { op = new LineExtensionOperation(m_ExtendLine, m_IsExtendFromEnd, m_Length); op.Execute(idh, m_LineType); } catch (Exception ex) { MessageBox.Show(ex.StackTrace, ex.Message); return(false); } } // Destroy the dialog(s). KillDialogs(); // Get the base class to finish up. return(FinishCommand()); }
/// <summary> /// Handles the Finish button. /// </summary> /// <returns>The point created at the intersection (null if an error was reported). /// The caller is responsible for disposing of the dialog and telling the controller /// the command is done)</returns> internal override PointFeature Finish() { // The intersection SHOULD be defined (the Finish button should have // been disabled if it wasn't) IPosition x = intersectInfo.Intersection; if (x == null) { MessageBox.Show("No intersection. Nothing to save"); return(null); } // If we're not doing an update, just save the edit UpdateUI up = (GetCommand() as UpdateUI); if (up == null) { return(SaveDirLine()); } // Remember the changes as part of the UI object (the original edit remains // unchanged for now) IntersectDirectionAndLineOperation op = (IntersectDirectionAndLineOperation)up.GetOp(); UpdateItemCollection changes = op.GetUpdateItems(getDirection.Direction, getLine.Line, intersectInfo.ClosestPoint); if (!up.AddUpdate(op, changes)) { return(null); } // Return the point previously created at the intersect return(op.IntersectionPoint); }
/// <summary> /// Initializes a new instance of the <see cref="RevisedEdit"/> class /// using the data read from persistent storage. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> internal RevisedEdit(EditDeserializer editDeserializer) { InternalIdValue id = editDeserializer.ReadInternalId(DataField.RevisedEdit); m_Edit = editDeserializer.MapModel.FindOperation(id); m_Changes = (m_Edit as IRevisable).ReadUpdateItems(editDeserializer); }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); throw new NotImplementedException(); return(result); }
/// <summary> /// Remembers details for an updated edit. /// </summary> /// <param name="revisedEdit">The edit that is being revised</param> /// <param name="changes">The changes to apply</param> /// <returns>True if an update was recorded, false if the supplied change collection is empty (in that /// case, the user receives a warning message).</returns> /// <remarks>This will be called when the user has finished making changes to an old /// edit. The call comes from the UI for the revised edit, which goes on to call /// CommandUI.FinishCommand, which routes back to UpdateUI.FinishCommand when an /// update UI is in progress.</remarks> internal bool AddUpdate(Operation revisedEdit, UpdateItemCollection changes) { if (changes.Count == 0) { MessageBox.Show("You do not appear to have made any changes."); return(false); } // Remember the revision that will be applied by ApplyRevision. In the vast majority of cases, // there should only be one revised edit per editing dialog. Currently, the only situation // where more than one revision is involved is an update where both sides of a subdivided line // get updated. var rev = new RevisedEdit(revisedEdit, changes); if (m_Revisions == null) { m_Revisions = new RevisedEdit[] { rev }; } else { Array.Resize <RevisedEdit>(ref m_Revisions, m_Revisions.Length + 1); m_Revisions[m_Revisions.Length - 1] = rev; } return(true); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteObservation <Direction>(editSerializer, DataField.Direction); data.WriteObservation <Observation>(editSerializer, DataField.Distance); data.WriteFeature <PointFeature>(editSerializer, DataField.From); data.WriteItem <bool>(editSerializer, DataField.Default); }
/// <summary> /// Exchanges any previously generated update items (this is currently done /// by <see cref="NewPointForm.GetUpdateItems"/>). /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { // Do nothing! This method is here because it is specified by the IRevisable // interface. But, while the NewPointOperation can be updated, it is unlike // other edits because we are explicitly changing a position (rather than // changing observations that are used to calculate a position). // Data exchange ordinarily happens before anything is moved, because // it may alter the calculation sequence. While explicitly changing a // position will not alter the sequence, it will move the point a little // too soon (the UpdateEditingContext.Recalculate method is responsible // for removing stuff from the spatial index, re-calculating geometry, // and re-adding to the spatial index). Ok, we could try fixing up the // index as part of this method. But if we do that, the old geometry // would not get remembered as part of the UpdateEditingContext (which // gets utilized in the event of a rollback). // To get around all this, the data exchange will be deferred until // CalculateGeometry is called (see implementation below). // ...the only problem with the above is that during deserialization, data // exchange occurs at the moment the update is encountered in the deserialization // stream. Subsequently, CalculateGeometry will be called with a null editing // context, so the update info will not be available. So do the exchange if // the model is just being loaded. if (MapModel.WorkingSession == null) { ApplyUpdateItems(null, data); } }
/// <summary> /// Reacts to selection of the OK button in the dialog. /// </summary> /// <param name="wnd">The dialog window. If this matches the dialog that /// this command knows about, the command will be executed (and, on success, /// the dialog will be destroyed). If it's some other window, it must /// be a sub-dialog created by our guy, so let it handle the request.</param> /// <returns></returns> internal override bool DialFinish(Control wnd) { if (m_Dialog == null) { MessageBox.Show("SimpleLineSubdivisionUI.DialFinish - No dialog!"); return(false); } // De-select the line that's being split Controller.ClearSelection(); // Get info from the dialog. m_Length = m_Dialog.Length; // If we are doing an update, alter the original operation. UpdateUI up = this.Update; if (up != null) { // Get the original operation. SimpleLineSubdivisionOperation pop = (up.GetOp() as SimpleLineSubdivisionOperation); if (pop == null) { MessageBox.Show("SimpleLineSubdivisionUI.DialFinish - Unexpected edit type."); return(false); } // Remember the changes as part of the UI object (the original edit remains // unchanged for now) UpdateItemCollection changes = pop.GetUpdateItems(m_Length, m_Dialog.IsFromEnd); if (!up.AddUpdate(pop, changes)) { return(false); } } else { // Execute the edit SimpleLineSubdivisionOperation op = null; try { op = new SimpleLineSubdivisionOperation(m_Line, m_Length, m_Dialog.IsFromEnd); op.Execute(); } catch (Exception ex) { MessageBox.Show(ex.StackTrace, ex.Message); return(false); } } // Destroy the dialog(s). KillDialogs(); // Get the base class to finish up. return(FinishCommand()); }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); result.ReadObservation <Direction>(editDeserializer, DataField.Direction1); result.ReadObservation <Direction>(editDeserializer, DataField.Direction2); return(result); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="isFromEnd">True if extending from the end of the line</param> /// <param name="length">The observed length of the extension</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(bool isFromEnd, Distance length) { UpdateItemCollection result = new UpdateItemCollection(); result.AddItem <bool>(DataField.ExtendFromEnd, m_IsExtendFromEnd, isFromEnd); result.AddObservation <Distance>(DataField.Distance, m_Length, length); return(result); }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); result.ReadItem <bool>(editDeserializer, DataField.ExtendFromEnd); result.ReadObservation <Distance>(editDeserializer, DataField.Distance); return(result); }
/// <summary> /// Exchanges any previously generated update items (this is currently done /// by <see cref="NewPointForm.GetUpdateItems"/>). /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { // Only exchange if the model is being loaded - see comments in NewPointOperation.ExchangeData if (MapModel.WorkingSession == null) { ApplyUpdateItems(null, data); } }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dir1">1st direction observation.</param> /// <param name="dir2">2nd direction observation.</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir1, Direction dir2) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation <Direction>(DataField.Direction1, m_Direction1, dir1); result.AddObservation <Direction>(DataField.Direction2, m_Direction2, dir2); return(result); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteFeature <LineFeature>(editSerializer, DataField.RefLine); data.WriteObservation <Observation>(editSerializer, DataField.Offset); data.WriteFeature <LineFeature>(editSerializer, DataField.Term1); data.WriteFeature <LineFeature>(editSerializer, DataField.Term2); data.WriteItem <bool>(editSerializer, DataField.ReverseArc); }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); result.ReadItem <double>(editDeserializer, DataField.X); result.ReadItem <double>(editDeserializer, DataField.Y); return(result); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dist">The new observed distance.</param> /// <param name="isFromEnd">Is the distance observed from the end of the line?</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Distance dist, bool isFromEnd) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation <Distance>(DataField.Distance, m_Distance, dist); result.AddItem <bool>(DataField.EntryFromEnd, m_IsFromEnd, isFromEnd); return(result); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="newPosition">The revised position</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Position newPosition) { UpdateItemCollection result = new UpdateItemCollection(); result.AddItem <double>(DataField.X, m_NewPoint.Easting.Meters, newPosition.X); result.AddItem <double>(DataField.Y, m_NewPoint.Northing.Meters, newPosition.Y); return(result); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dir">The direction (could contain an offset).</param> /// <param name="length">The length of the sideshot arm (either a <see cref="Distance"/> /// or an <see cref="OffsetPoint"/>).</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir, Observation length) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation <Direction>(DataField.Direction, m_Direction, dir); result.AddObservation <Observation>(DataField.Length, m_Length, length); return(result); }
/// <summary> /// Applies changes to this editing operation. /// </summary> /// <param name="ctx">The editing context (null if the model is being deserialized)</param> /// <param name="data">The changes to apply</param> void ApplyUpdateItems(EditingContext ctx, UpdateItemCollection data) { double x = data.ExchangeValue <double>(DataField.X, m_NewPoint.Easting.Meters); double y = data.ExchangeValue <double>(DataField.Y, m_NewPoint.Northing.Meters); PointGeometry pg = new PointGeometry(x, y); m_NewPoint.ApplyPointGeometry(ctx, pg); }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_Direction = data.ExchangeObservation <Direction>(this, DataField.Direction, m_Direction); m_Distance = data.ExchangeObservation <Observation>(this, DataField.Distance, m_Distance); m_From = data.ExchangeFeature <PointFeature>(this, DataField.From, m_From); m_Default = data.ExchangeValue <bool>(DataField.Default, m_Default); AssignObservedLengths(); }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="LineSubdivisionUpdateForm.GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { UpdateItem face = data.GetUpdateItem(DataField.Face); if (face != null) { m_Face.ExchangeData(face); } }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); result.ReadObservation <Direction>(editDeserializer, DataField.Direction); result.ReadFeature <LineFeature>(editDeserializer, DataField.Line); result.ReadFeature <PointFeature>(editDeserializer, DataField.CloseTo); return(result); }
///// <summary> ///// Executes this operation. ///// </summary> ///// <param name="wantsplit">True if line should be split at the intersection.</param> ///// <param name="pointType">The entity type to assign to the intersection point.</param> ///// <param name="dirEnt">The entity type for any line that should be added along the direction ///// line. Specify null if you don't want a line.</param> //internal void Execute(bool wantsplit, IEntity pointType, IEntity dirEnt) //{ // // Calculate the position of the point of intersection. // IPosition xsect; // PointFeature closest; // if (!m_Direction.Intersect(m_Line, m_CloseTo, out xsect, out closest)) // throw new Exception("Cannot calculate intersection point"); // // Add the intersection point // m_Intersection = AddIntersection(xsect, pointType); // // Are we splitting the input line? If so, do it. // m_IsSplit = wantsplit; // if (m_IsSplit) // SplitLine(m_Intersection, m_Line, out m_LineA, out m_LineB); // // If we have a defined entity type for the direction line, add a line too. // CadastralMapModel map = MapModel; // if (dirEnt != null) // m_DirLine = map.AddLine(m_Direction.From, m_Intersection, dirEnt, this); // // Peform standard completion steps // Complete(); //} /// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dir">The direction to intersect.</param> /// <param name="line">The line to intersect.</param> /// <param name="closeTo">The point the intersection has to be close to. Used if /// there is more than one intersection to choose from. If null is specified, a /// default point will be selected.</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir, LineFeature line, PointFeature closeTo) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation <Direction>(DataField.Direction, m_Direction, dir); result.AddFeature <LineFeature>(DataField.Line, m_Line, line); result.AddFeature <PointFeature>(DataField.CloseTo, m_CloseTo, closeTo); return(result); }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); result.ReadObservation <Direction>(editDeserializer, DataField.Direction); result.ReadObservation <Observation>(editDeserializer, DataField.Distance); result.ReadFeature <PointFeature>(editDeserializer, DataField.From); result.ReadItem <bool>(editDeserializer, DataField.Default); return(result); }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_Direction = data.ExchangeObservation <Direction>(this, DataField.Direction, m_Direction); m_Length = data.ExchangeObservation <Observation>(this, DataField.Length, m_Length); if (m_Line != null) { m_Line.ObservedLength = (m_Length as Distance); } }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_IsExtendFromEnd = data.ExchangeValue <bool>(DataField.ExtendFromEnd, m_IsExtendFromEnd); m_Length = data.ExchangeObservation <Distance>(this, DataField.Distance, m_Length); if (m_NewLine != null) { m_NewLine.ObservedLength = m_Length; } }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_Distance1 = data.ExchangeObservation <Observation>(this, DataField.Distance1, m_Distance1); m_From1 = data.ExchangeFeature <PointFeature>(this, DataField.From1, m_From1); m_Distance2 = data.ExchangeObservation <Observation>(this, DataField.Distance2, m_Distance2); m_From2 = data.ExchangeFeature <PointFeature>(this, DataField.From2, m_From2); m_Default = data.ExchangeValue <bool>(DataField.Default, m_Default); AssignObservedLengths(); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dist1">1st distance observation.</param> /// <param name="from1">The point the 1st distance was observed from.</param> /// <param name="dist2">2nd distance observation.</param> /// <param name="from2">The point the 2nd distance was observed from.</param> /// <param name="isdefault">True if the default intersection is required (the one that has the /// lowest bearing with respect to the 2 from points). False for the other one (if any).</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir, Observation distance, PointFeature from, bool isdefault) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation <Direction>(DataField.Direction, m_Direction, dir); result.AddObservation <Observation>(DataField.Distance, m_Distance, distance); result.AddFeature <PointFeature>(DataField.From, m_From, from); result.AddItem <bool>(DataField.Default, m_Default, isdefault); return(result); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/> and <see cref="WriteUpdateItems"/>). /// </summary> /// <param name="face">The revised observed lengths for each subdivision section</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method). Never null, but may be an empty collection /// if the supplied face does not involve any changes.</returns> internal UpdateItemCollection GetUpdateItems(LineSubdivisionFace face) { UpdateItemCollection result = new UpdateItemCollection(); if (!m_Face.HasIdenticalObservedLengths(face)) { result.Add(m_Face.GetUpdateItem(DataField.Face, face.ObservedLengths)); } return(result); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { // The logic that follows is based on the update items that get defined by GetUpdateItems UpdateItem face = data.GetUpdateItem(DataField.Face); if (face != null) { editSerializer.WritePersistentArray <Distance>(DataField.Face, (Distance[])face.Value); } }
/// <summary> /// Initializes a new instance of the <see cref="RevisedEdit"/> class. /// </summary> /// <param name="revisedEdit">The edit being updated (not null). Must implement /// <see cref="IRevisable"/>.</param> /// <exception cref="ArgumentNullException">If either <paramref name="edit"/> or /// <paramref name="changes"/> is null.</exception> /// <exception cref="ArgumentException">If <paramref name="revisedEdit"/> does not /// implement <see cref="IRevisable"/>.</exception> internal RevisedEdit(Operation revisedEdit, UpdateItemCollection changes) : base() { if (revisedEdit == null || changes == null) throw new ArgumentNullException(); if (!(revisedEdit is IRevisable)) throw new ArgumentException(); m_Changes = changes; m_Edit = revisedEdit; }
/// <summary> /// Exchanges any previously generated update items (this is currently done /// by <see cref="NewPointForm.GetUpdateItems"/>). /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { // Do nothing! This method is here because it is specified by the IRevisable // interface. But, while the NewPointOperation can be updated, it is unlike // other edits because we are explicitly changing a position (rather than // changing observations that are used to calculate a position). // Data exchange ordinarily happens before anything is moved, because // it may alter the calculation sequence. While explicitly changing a // position will not alter the sequence, it will move the point a little // too soon (the UpdateEditingContext.Recalculate method is responsible // for removing stuff from the spatial index, re-calculating geometry, // and re-adding to the spatial index). Ok, we could try fixing up the // index as part of this method. But if we do that, the old geometry // would not get remembered as part of the UpdateEditingContext (which // gets utilized in the event of a rollback). // To get around all this, the data exchange will be deferred until // CalculateGeometry is called (see implementation below). // ...the only problem with the above is that during deserialization, data // exchange occurs at the moment the update is encountered in the deserialization // stream. Subsequently, CalculateGeometry will be called with a null editing // context, so the update info will not be available. So do the exchange if // the model is just being loaded. if (MapModel.WorkingSession == null) ApplyUpdateItems(null, data); }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); if (editDeserializer.IsNextField(DataField.Face)) { Distance[] face = editDeserializer.ReadPersistentArray<Distance>(DataField.Face); result.Add(new UpdateItem(DataField.Face, face)); } return result; }
/// <summary> /// Modifies this edit by applying the values in the supplied update items /// (as produced via a prior call to <see cref="GetUpdateItems"/>). /// </summary> /// <param name="data">The update items to apply to this edit.</param> /// <returns>The original values for the update items.</returns> public override void ExchangeData(UpdateItemCollection data) { m_Distance = data.ExchangeObservation<Distance>(this, DataField.Distance, m_Distance); m_IsFromEnd = data.ExchangeValue<bool>(DataField.EntryFromEnd, m_IsFromEnd); if (m_IsFromEnd) m_NewLine2.ObservedLength = m_Distance; else m_NewLine1.ObservedLength = m_Distance; }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); throw new NotImplementedException(); return result; }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="newPosition">The revised position</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Position newPosition) { UpdateItemCollection result = new UpdateItemCollection(); result.AddItem<double>(DataField.X, m_NewPoint.Easting.Meters, newPosition.X); result.AddItem<double>(DataField.Y, m_NewPoint.Northing.Meters, newPosition.Y); return result; }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="isFromEnd">True if extending from the end of the line</param> /// <param name="length">The observed length of the extension</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(bool isFromEnd, Distance length) { UpdateItemCollection result = new UpdateItemCollection(); result.AddItem<bool>(DataField.ExtendFromEnd, m_IsExtendFromEnd, isFromEnd); result.AddObservation<Distance>(DataField.Distance, m_Length, length); return result; }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_Direction1 = data.ExchangeObservation<Direction>(this, DataField.Direction1, m_Direction1); m_Direction2 = data.ExchangeObservation<Direction>(this, DataField.Direction2, m_Direction2); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dir">The direction (could contain an offset).</param> /// <param name="length">The length of the sideshot arm (either a <see cref="Distance"/> /// or an <see cref="OffsetPoint"/>).</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir, Observation length) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation<Direction>(DataField.Direction, m_Direction, dir); result.AddObservation<Observation>(DataField.Length, m_Length, length); return result; }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteObservation<Direction>(editSerializer, DataField.Direction1); data.WriteObservation<Direction>(editSerializer, DataField.Direction2); }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); result.ReadObservation<Direction>(editDeserializer, DataField.Direction1); result.ReadObservation<Direction>(editDeserializer, DataField.Direction2); return result; }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dir1">1st direction observation.</param> /// <param name="dir2">2nd direction observation.</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir1, Direction dir2) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation<Direction>(DataField.Direction1, m_Direction1, dir1); result.AddObservation<Direction>(DataField.Direction2, m_Direction2, dir2); return result; }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_IsExtendFromEnd = data.ExchangeValue<bool>(DataField.ExtendFromEnd, m_IsExtendFromEnd); m_Length = data.ExchangeObservation<Distance>(this, DataField.Distance, m_Length); if (m_NewLine != null) m_NewLine.ObservedLength = m_Length; }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dist">The new observed distance.</param> /// <param name="isFromEnd">Is the distance observed from the end of the line?</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Distance dist, bool isFromEnd) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation<Distance>(DataField.Distance, m_Distance, dist); result.AddItem<bool>(DataField.EntryFromEnd, m_IsFromEnd, isFromEnd); return result; }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); result.ReadItem<double>(editDeserializer, DataField.X); result.ReadItem<double>(editDeserializer, DataField.Y); return result; }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="LineSubdivisionUpdateForm.GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { UpdateItem face = data.GetUpdateItem(DataField.Face); if (face != null) m_Face.ExchangeData(face); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteItem<double>(editSerializer, DataField.X); data.WriteItem<double>(editSerializer, DataField.Y); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteObservation<Direction>(editSerializer, DataField.Direction); data.WriteObservation<Observation>(editSerializer, DataField.Distance); data.WriteFeature<PointFeature>(editSerializer, DataField.From); data.WriteItem<bool>(editSerializer, DataField.Default); }
/// <summary> /// Applies changes to this editing operation. /// </summary> /// <param name="ctx">The editing context (null if the model is being deserialized)</param> /// <param name="data">The changes to apply</param> void ApplyUpdateItems(EditingContext ctx, UpdateItemCollection data) { double x = data.ExchangeValue<double>(DataField.X, m_NewPoint.Easting.Meters); double y = data.ExchangeValue<double>(DataField.Y, m_NewPoint.Northing.Meters); PointGeometry pg = new PointGeometry(x, y); m_NewPoint.ApplyPointGeometry(ctx, pg); }
/// <summary> /// Exchanges update items that were previously generated. /// </summary> /// <param name="data">The update data to apply to this edit (modified to /// hold the values that were previously defined for this edit)</param> /// <exception cref="NotImplementedException">Thrown always. Derived classes that are /// update capable must override (I'm not sure why this isn't part of the IRevisable /// interface)</exception> public virtual void ExchangeData(UpdateItemCollection data) { throw new NotImplementedException(); }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/>). /// </summary> /// <param name="dist1">1st distance observation.</param> /// <param name="from1">The point the 1st distance was observed from.</param> /// <param name="dist2">2nd distance observation.</param> /// <param name="from2">The point the 2nd distance was observed from.</param> /// <param name="isdefault">True if the default intersection is required (the one that has the /// lowest bearing with respect to the 2 from points). False for the other one (if any).</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method).</returns> internal UpdateItemCollection GetUpdateItems(Direction dir, Observation distance, PointFeature from, bool isdefault) { UpdateItemCollection result = new UpdateItemCollection(); result.AddObservation<Direction>(DataField.Direction, m_Direction, dir); result.AddObservation<Observation>(DataField.Distance, m_Distance, distance); result.AddFeature<PointFeature>(DataField.From, m_From, from); result.AddItem<bool>(DataField.Default, m_Default, isdefault); return result; }
/// <summary> /// Exchanges update items that were previously generated via /// a call to <see cref="GetUpdateItems"/>. /// </summary> /// <param name="data">The update data to apply to the edit (modified to /// hold the values that were previously defined for the edit)</param> public override void ExchangeData(UpdateItemCollection data) { m_Direction = data.ExchangeObservation<Direction>(this, DataField.Direction, m_Direction); m_Length = data.ExchangeObservation<Observation>(this, DataField.Length, m_Length); if (m_Line != null) m_Line.ObservedLength = (m_Length as Distance); }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); result.ReadObservation<Direction>(editDeserializer, DataField.Direction); result.ReadObservation<Observation>(editDeserializer, DataField.Distance); result.ReadFeature<PointFeature>(editDeserializer, DataField.From); result.ReadItem<bool>(editDeserializer, DataField.Default); return result; }
/// <summary> /// Obtains update items for a revised version of this edit /// (for later use with <see cref="ExchangeData"/> and <see cref="WriteUpdateItems"/>). /// </summary> /// <param name="face">The revised observed lengths for each subdivision section</param> /// <returns>The items representing the change (may be subsequently supplied to /// the <see cref="ExchangeUpdateItems"/> method). Never null, but may be an empty collection /// if the supplied face does not involve any changes.</returns> internal UpdateItemCollection GetUpdateItems(LineSubdivisionFace face) { UpdateItemCollection result = new UpdateItemCollection(); if (!m_Face.HasIdenticalObservedLengths(face)) result.Add(m_Face.GetUpdateItem(DataField.Face, face.ObservedLengths)); return result; }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { // The logic that follows is based on the update items that get defined by GetUpdateItems UpdateItem face = data.GetUpdateItem(DataField.Face); if (face != null) editSerializer.WritePersistentArray<Distance>(DataField.Face, (Distance[])face.Value); }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { throw new NotImplementedException(); }
/// <summary> /// Remembers details for an updated edit. /// </summary> /// <param name="revisedEdit">The edit that is being revised</param> /// <param name="changes">The changes to apply</param> /// <returns>True if an update was recorded, false if the supplied change collection is empty (in that /// case, the user receives a warning message).</returns> /// <remarks>This will be called when the user has finished making changes to an old /// edit. The call comes from the UI for the revised edit, which goes on to call /// CommandUI.FinishCommand, which routes back to UpdateUI.FinishCommand when an /// update UI is in progress.</remarks> internal bool AddUpdate(Operation revisedEdit, UpdateItemCollection changes) { if (changes.Count == 0) { MessageBox.Show("You do not appear to have made any changes."); return false; } // Remember the revision that will be applied by ApplyRevision. In the vast majority of cases, // there should only be one revised edit per editing dialog. Currently, the only situation // where more than one revision is involved is an update where both sides of a subdivided line // get updated. var rev = new RevisedEdit(revisedEdit, changes); if (m_Revisions == null) { m_Revisions = new RevisedEdit[] { rev }; } else { Array.Resize<RevisedEdit>(ref m_Revisions, m_Revisions.Length + 1); m_Revisions[m_Revisions.Length - 1] = rev; } return true; }
/// <summary> /// Reads back updates made to an editing operation. /// </summary> /// <param name="editDeserializer">The mechanism for reading back content.</param> /// <returns>The changes made to the edit</returns> public UpdateItemCollection ReadUpdateItems(EditDeserializer editDeserializer) { UpdateItemCollection result = new UpdateItemCollection(); result.ReadObservation<Distance>(editDeserializer, DataField.Distance); result.ReadItem<bool>(editDeserializer, DataField.EntryFromEnd); return result; }
/// <summary> /// Writes updates for an editing operation to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> /// <param name="data">The collection of changes to write</param> public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data) { data.WriteObservation<Distance>(editSerializer, DataField.Distance); data.WriteItem<bool>(editSerializer, DataField.EntryFromEnd); }