/// <summary>
/// Create a new Linked Parameter with the given name
/// </summary>
/// <param name="name">The name of the linked parameter</param>
/// <param name="error">If an error occurs this will contain a message to describe it.</param>
/// <returns>True if it executed successfully</returns>
public bool NewLinkedParameter(string name, ref string error)
{
var lp = new LinkedParameterChange();
return(_Session.RunCommand(
XTMFCommand.CreateCommand("New Linked Parameter", (ref string e) =>
{
LinkedParameter linkedParameter = new LinkedParameter(name);
LinkedParameterModel newModel = new LinkedParameterModel(linkedParameter, _Session, _ModelSystem);
_RealLinkedParameters.Add(linkedParameter);
LinkedParameters.Add(newModel);
lp.Model = newModel;
lp.Index = LinkedParameters.Count - 1;
return true;
},
(ref string e) =>
{
LinkedParameters.RemoveAt(lp.Index);
_RealLinkedParameters.RemoveAt(lp.Index);
InvokeRemoved(lp);
return true;
},
(ref string e) =>
{
LinkedParameters.Insert(lp.Index, lp.Model);
_RealLinkedParameters.Insert(lp.Index, lp.Model.RealLinkedParameter);
return true;
}),
ref error
));
}
/// <summary>
/// Removes a parameter from this linked parameter
/// </summary>
/// <param name="toRemove">The parameter to remove</param>
/// <param name="error">An error message if this is not possible</param>
/// <returns>True if the parameter was removed, false if it was not.</returns>
public bool RemoveParameter(ParameterModel toRemove, ref string error)
{
LinkedParameterChange change = new LinkedParameterChange();
return(Session.RunCommand(XTMFCommand.CreateCommand(
// do
(ref string e) =>
{
// we need this outer lock to make sure that it doesn't change while we are checking to make sure that it is contained
lock (ParameterModelsLock)
{
if (!ParameterModels.Contains(toRemove))
{
e = "The parameter does not exist inside of the linked parameter!";
return false;
}
change.Index = NoCommandRemove(toRemove);
}
return true;
},
// undo
(ref string e) =>
{
return NoCommandAdd(toRemove, change.Index, ref e);
},
// redo
(ref string e) =>
{
NoCommandRemove(toRemove);
return true;
}
), ref error));
}
/// <summary>
/// Remove a linked parameter from the linked parameters
/// </summary>
/// <param name="linkedParameter">The linked parameter to remove</param>
/// <param name="error">If an error occurs this will contain a message to describe it.</param>
/// <returns>If the command was successful or not.</returns>
public bool RemoveLinkedParameter(LinkedParameterModel linkedParameter, ref string error)
{
var lp = new LinkedParameterChange();
return(this.Session.RunCommand(
XTMFCommand.CreateCommand((ref string e) =>
{
if ((lp.Index = this.LinkedParameters.IndexOf(linkedParameter)) < 0)
{
e = "The linked parameter was not found!";
return false;
}
lp.Model = this.LinkedParameters[lp.Index];
LinkedParameters.RemoveAt(lp.Index);
RealLinkedParameters.RemoveAt(lp.Index);
return true;
},
(ref string e) =>
{
LinkedParameters.Insert(lp.Index, lp.Model);
RealLinkedParameters.Insert(lp.Index, lp.Model.RealLinkedParameter);
return true;
},
(ref string e) =>
{
LinkedParameters.RemoveAt(lp.Index);
RealLinkedParameters.RemoveAt(lp.Index);
return true;
}),
ref error
));
}
private void InvokeRemoved(LinkedParameterChange lp)
{
var ev = LinkedParameterRemoved;
if (ev != null)
{
ev(this, new CollectionChangeEventArgs(CollectionChangeAction.Remove, lp.Model));
}
}
/// <summary>
/// Add a new parameter to this linked parameter
/// </summary>
/// <param name="toAdd">The parameter to add</param>
/// <param name="error">This contains an error message if this returns false</param>
/// <returns>True if we added the parameter to the linked parameter, false if it failed.</returns>
public bool AddParameter(ParameterModel toAdd, ref string error)
{
LinkedParameterChange change = new LinkedParameterChange();
var originalValue = toAdd.Value;
return(Session.RunCommand(XTMFCommand.CreateCommand(
// do
(ref string e) =>
{
if (ParameterModels.Contains(toAdd))
{
e = "The parameter was already contained in the linked parameter!";
return false;
}
// remove from the linked parameter it was already in
if ((change.OriginalContainedIn = ModelSystem.LinkedParameters.LinkedParameters.FirstOrDefault((lp) => lp.Contains(toAdd))) != null)
{
change.OriginalIndex = change.OriginalContainedIn.NoCommandRemove(toAdd);
}
NoCommandAdd(toAdd, (change.Index = ParameterModels.Count));
return true;
},
// undo
(ref string e) =>
{
NoCommandRemove(toAdd);
if (change.OriginalContainedIn != null)
{
change.OriginalContainedIn.NoCommandAdd(toAdd, change.OriginalIndex);
}
else
{
// if it isn't part of another linked parameter just add the value back
toAdd.SetValue(originalValue, ref e);
}
return true;
},
// redo
(ref string e) =>
{
if (change.OriginalContainedIn != null)
{
change.OriginalContainedIn.NoCommandRemove(toAdd);
}
NoCommandAdd(toAdd, change.Index);
return true;
}
), ref error));
}
private void InvokeRemoved(LinkedParameterChange lp)
{
LinkedParameterRemoved?.Invoke(this, new CollectionChangeEventArgs(CollectionChangeAction.Remove, lp.Model));
}
/// <summary>
/// Remove a linked parameter from the linked parameters
/// </summary>
/// <param name="linkedParameter">The linked parameter to remove</param>
/// <param name="error">If an error occurs this will contain a message to describe it.</param>
/// <returns>If the command was successful or not.</returns>
public bool RemoveLinkedParameter(LinkedParameterModel linkedParameter, ref string error)
{
var lp = new LinkedParameterChange();
return this.Session.RunCommand(
XTMFCommand.CreateCommand((ref string e) =>
{
if((lp.Index = this.LinkedParameters.IndexOf(linkedParameter)) < 0)
{
e = "The linked parameter was not found!";
return false;
}
lp.Model = this.LinkedParameters[lp.Index];
LinkedParameters.RemoveAt(lp.Index);
RealLinkedParameters.RemoveAt(lp.Index);
return true;
},
(ref string e) =>
{
LinkedParameters.Insert(lp.Index, lp.Model);
RealLinkedParameters.Insert(lp.Index, lp.Model.RealLinkedParameter);
return true;
},
(ref string e) =>
{
LinkedParameters.RemoveAt(lp.Index);
RealLinkedParameters.RemoveAt(lp.Index);
return true;
}),
ref error
);
}
/// <summary>
/// Create a new Linked Parameter with the given name
/// </summary>
/// <param name="name">The name of the linked parameter</param>
/// <param name="error">If an error occurs this will contain a message to describe it.</param>
/// <returns>True if it executed successfully</returns>
public bool NewLinkedParameter(string name, ref string error)
{
var lp = new LinkedParameterChange();
return this.Session.RunCommand(
XTMFCommand.CreateCommand((ref string e) =>
{
LinkedParameter linkedParameter = new LinkedParameter(name);
LinkedParameterModel newModel = new LinkedParameterModel(linkedParameter, Session, ModelSystem);
RealLinkedParameters.Add(linkedParameter);
LinkedParameters.Add(newModel);
lp.Model = newModel;
lp.Index = this.LinkedParameters.Count - 1;
return true;
},
(ref string e) =>
{
LinkedParameters.RemoveAt(lp.Index);
RealLinkedParameters.RemoveAt(lp.Index);
return true;
},
(ref string e) =>
{
LinkedParameters.Insert(lp.Index, lp.Model);
RealLinkedParameters.Insert(lp.Index, lp.Model.RealLinkedParameter);
return true;
}),
ref error
);
}
/// <summary>
/// Removes a parameter from this linked parameter
/// </summary>
/// <param name="toRemove">The parameter to remove</param>
/// <param name="error">An error message if this is not possible</param>
/// <returns>True if the parameter was removed, false if it was not.</returns>
public bool RemoveParameter(ParameterModel toRemove, ref string error)
{
LinkedParameterChange change = new LinkedParameterChange();
return Session.RunCommand(XTMFCommand.CreateCommand(
// do
(ref string e) =>
{
// we need this outer lock to make sure that it doesn't change while we are checking to make sure that it is contained
lock (ParameterModelsLock)
{
if(!ParameterModels.Contains(toRemove))
{
e = "The parameter does not exist inside of the linked parameter!";
return false;
}
change.Index = NoCommandRemove(toRemove);
}
return true;
},
// undo
(ref string e) =>
{
NoCommandAdd(toRemove, change.Index);
return true;
},
// redo
(ref string e) =>
{
NoCommandRemove(toRemove);
return true;
}
), ref error);
}
/// <summary>
/// Add a new parameter to this linked parameter
/// </summary>
/// <param name="toAdd">The parameter to add</param>
/// <param name="error">This contains an error message if this returns false</param>
/// <returns>True if we added the parameter to the linked parameter, false if it failed.</returns>
public bool AddParameter(ParameterModel toAdd, ref string error)
{
LinkedParameterChange change = new LinkedParameterChange();
var originalValue = toAdd.Value;
return Session.RunCommand(XTMFCommand.CreateCommand(
// do
(ref string e) =>
{
if(ParameterModels.Contains(toAdd))
{
e = "The parameter was already contained in the linked parameter!";
return false;
}
// remove from the linked parameter it was already in
if((change.OriginalContainedIn = ModelSystem.LinkedParameters.LinkedParameters.FirstOrDefault((lp) => lp.Contains(toAdd))) != null)
{
change.OriginalIndex = change.OriginalContainedIn.NoCommandRemove(toAdd);
}
NoCommandAdd(toAdd, (change.Index = ParameterModels.Count));
return true;
},
// undo
(ref string e) =>
{
NoCommandRemove(toAdd);
if(change.OriginalContainedIn != null)
{
change.OriginalContainedIn.NoCommandAdd(toAdd, change.OriginalIndex);
}
else
{
// if it isn't part of another linked parameter just add the value back
toAdd.SetValue(originalValue, ref e);
}
return true;
},
// redo
(ref string e) =>
{
if(change.OriginalContainedIn != null)
{
change.OriginalContainedIn.NoCommandRemove(toAdd);
}
NoCommandAdd(toAdd, change.Index);
return true;
}
), ref error);
}
