public virtual void InvokeEditedEvent(BackupObject obj)
{
if (Edited != null)
{
Edited.Invoke(obj);
}
}
private void tryDelete(DrawableTile tile)
{
confirmation.Push("Are you sure you want to delete action for this tile?", () =>
{
Edited?.Invoke(tile, null);
});
}
public Message(dynamic Data)
{
_edited = new Edited(Data.edited);
_text = Data.message.text;
_ts = new Slack.TimeStamp((String)Data.message.ts);
_user = Data.message.user;
}
private void ViewModel_Deleted(object sender, EventArgs e)
{
if (sender is KeyBindingViewModel keyBinding)
{
_keyBindings.Remove(keyBinding.Model);
KeyBindings.Remove(keyBinding);
Edited?.Invoke(Command, _keyBindings);
}
}
public override int GetHashCode()
{
int hash = GetType().GetHashCode();
hash = (hash * 397) ^ MessageID.GetHashCode();
hash = (hash * 397) ^ Edited.GetHashCode();
return(hash);
}
public void Edit(string newTitle)
{
var oldTitle = Title;
Title = newTitle;
Edited.Fire(this, new EditedArgs {
OldTitle = oldTitle
});
}
public void Redo()
{
if (stackRedo.Any())
{
var op = stackRedo.Pop();
op.Invoke();
stackUndo.Push(op);
}
StatusChanged?.Invoke(stackUndo.Any(), stackRedo.Any());
Edited.Invoke();
}
public void AddOperation(Operation operation)
{
if (!IsOperationValid(operation))
{
return;
}
stackUndo.Push(operation);
stackRedo.Clear();
StatusChanged?.Invoke(stackUndo.Any(), stackRedo.Any());
Edited.Invoke();
}
public void RemoveVariable(NodeGraphVariable graphVariable)
{
NodeEditor.Assertions.IsTrue(Variables.Contains(graphVariable));
NodeEditor.Logger.Log <NodeGraph>("Removing variable '{0}'", graphVariable.Name);
Variables.Remove(graphVariable);
VariableRemoved.InvokeSafe(graphVariable);
graphVariable.Remove();
Edited.InvokeSafe(this);
}
public void Disconnect(NodeConnection connection)
{
bool containsConnection = Connections.Contains(connection);
NodeEditor.Assertions.IsTrue(containsConnection);
if (containsConnection)
{
Connections.Remove(connection);
NodeEditor.Logger.Log <NodeGraph>("Disconnected {0} from {1}.", connection.SourcePin.Node.Name, connection.TargetPin.Node.Name);
Edited.InvokeSafe(this);
}
}
/// <summary>
///
/// </summary>
/// <param name="Value"></param>
protected virtual void OnEdited(bool Value)
{
IsEditable = Value;
if (Value)
{
Focus();
}
else
{
Edited?.Invoke(this, new EventArgs <string>(Text));
}
}
public void Connect(NodeConnection connection)
{
bool hasConnection = Connections.Contains(connection);
NodeEditor.Assertions.IsFalse(hasConnection);
NodeEditor.Assertions.WarnIsNotNull(connection.SourcePin, "Attempted to connect two pins where the start pin was null.");
NodeEditor.Assertions.WarnIsNotNull(connection.TargetPin, "Attempted to connect two pins where the end pin was null.");
NodeEditor.Assertions.WarnIsFalse(connection.SourcePin == connection.TargetPin, "Attempted to connect a pin to itself.");
//Assert.IsFalse(connection.StartPin.WillPinConnectionCreateCircularDependency(connection.EndPin), "Pin connection would create a circular dependency!");
var canConnect = connection.SourcePin != null &&
connection.TargetPin != null &&
connection.SourcePin != connection.TargetPin;
if (canConnect)
{
var existingConnectionOnStartPin = Helper.GetConnections(connection.SourcePin);
var existingConnectionOnEndPin = Helper.GetConnections(connection.TargetPin);
if (connection.Type == NodeConnectionType.Execute)
{
// Only one connection is allowed between any two execute pins.
existingConnectionOnStartPin.ForEach(x => Connections.Remove(x));
existingConnectionOnEndPin.ForEach(x => Connections.Remove(x));
}
else if (connection.Type == NodeConnectionType.Value)
{
// Input pins on value types can never have multiple connections. Remove existing connections.
existingConnectionOnEndPin.ForEach(x => Connections.Remove(x));
}
var startPinId = connection.SourcePin.Index;
var endPinId = connection.TargetPin.Index;
connection.SourcePin.Connect(connection.TargetPin);
connection.TargetPin.Connect(connection.SourcePin);
// Check if the pin has changed after connecting. This will happen for dynamic pin types.
if (connection.SourcePin.Node.Pins[startPinId] != connection.SourcePin || connection.TargetPin.Node.Pins[endPinId] != connection.TargetPin)
{
connection = new NodeConnection(connection.LeftNode.Pins[startPinId], connection.RightNode.Pins[endPinId]);
}
Connections.Add(connection);
NodeEditor.Logger.Log <NodeGraph>("Connected {0}:(1) to {2}:{3}", connection.LeftNode.Name, connection.SourcePin.Name, connection.RightNode.Name, connection.TargetPin.Name);
Edited.InvokeSafe(this);
}
}
public async Task Add()
{
var newKeyBinding = new KeyBindingViewModel(new KeyBinding {
Command = Command
}, _dialogService);
if (await newKeyBinding.Edit().ConfigureAwait(true))
{
newKeyBinding.Deleted += ViewModel_Deleted;
newKeyBinding.Edited += ViewModel_Edited;
KeyBindings.Add(newKeyBinding);
_keyBindings.Add(newKeyBinding.Model);
Edited?.Invoke(Command, _keyBindings);
}
}
NodeGraphVariable AddVariable(NodeGraphVariableData graphVariableData)
{
NodeEditor.Assertions.IsFalse(Variables.Any(x => x.ID == graphVariableData.ID), "Tried to spawn a variable that has the same ID as an existing variable.");
var variable = new NodeGraphVariable(graphVariableData);
variable.NameChangeRequested += Variable_NameChangeRequested;
Variables.Add(variable);
NodeEditor.Logger.Log <NodeGraph>("Added variable '{0}' ({1})", variable.Name, variable.GetType());
VariableAdded.InvokeSafe(variable);
Edited.InvokeSafe(this);
return(variable);
}
void RegisterNode(Node node)
{
NodeEditor.Assertions.IsFalse(Nodes.Contains(node), "Node already exists in this graph.");
if (!Nodes.Contains(node))
{
NodeEditor.Logger.Log <NodeGraph>("Registered node.");
node.Destroyed += RemoveNode;
node.Changed += Node_Changed;
node.PinRemoved += Node_PinRemoved;
Nodes.Add(node);
NodeAdded.InvokeSafe(node);
Edited.InvokeSafe(this);
}
}
public override string ToString()
{
return($"Name: {Name}{Environment.NewLine}" +
$"Model: {Model}{Environment.NewLine}" +
$"Starship Class: {StarshipClass}{Environment.NewLine}" +
$"Manufacturer: {Manufacturer}{Environment.NewLine}" +
$"Cost in Credits: {CostInCredits}{Environment.NewLine}" +
$"Length: {Length}{Environment.NewLine}" +
$"Crew: {Crew}{Environment.NewLine}" +
$"Passengers: {Passengers}{Environment.NewLine}" +
$"Max Atmosphering Speed: {MaxAtmospheringSpeed}{Environment.NewLine}" +
$"Hyperdrive Rating: {HyperdriveRating}{Environment.NewLine}" +
$"MGLT: {Mglt}{Environment.NewLine}" +
$"Cargo Capacity: {CargoCapacity}{Environment.NewLine}" +
$"Consumables: {Consumables}{Environment.NewLine}" +
$"Films: {string.Join(", ", Films ?? new List<string>())}{Environment.NewLine}" +
$"Pilots: {string.Join(", ", Pilots ?? new List<string>())}{Environment.NewLine}" +
$"Url: {Url}{Environment.NewLine}" +
$"Created at: {Created.ToString("yyyy-MM-dd HH:mm")}{Environment.NewLine}" +
$"Edited at: {Edited.ToString("yyyy-MM-dd HH:mm")}{Environment.NewLine}");
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JToken token = JToken.Load(reader);
string special = token.Value <string>();
Edited edit = new Edited {
IsEdited = special == "true"
};
if (!edit.IsEdited)
{
double timeEdited;
if (double.TryParse(special, out timeEdited))
{
edit.IsEdited = true;
edit.TimeEdited = DateUtils.FromUnixTime((long)timeEdited);
}
}
return(edit);
}
public void RemoveNode(Node node)
{
NodeEditor.Assertions.IsTrue(Nodes.Contains(node), "Node Graph does not contain node.");
if (Nodes.Contains(node))
{
NodeEditor.Logger.Log <NodeGraph>("Removing node.");
Selection = null;
node.Dispose();
Nodes.Remove(node);
NodeRemoved.InvokeSafe(node);
// TODO: Gracefully handle disconnections...
var connections = Connections
.Where(x => x.SourcePin.Node.ID == node.ID || x.TargetPin.Node.ID == node.ID)
.ToList();
connections.ForEach(x => Disconnect(x));
Edited.InvokeSafe(this);
}
}
/// <summary>
/// Raises the <see cref="Edited" /> event.
/// </summary>
/// <param name="e">An <see cref="EditGlobalObjectEventArgs" /> that contains the event data. </param>
public virtual void OnEdited(EditGlobalObjectEventArgs e)
{
Edited?.Invoke(this, e);
}
/// <summary>
/// Raises the <see cref="Edited" /> event.
/// </summary>
/// <param name="e">An <see cref="EditPlayerObjectEventArgs" /> that contains the event data. </param>
public virtual void OnEdited(EditPlayerObjectEventArgs e)
{
Edited?.Invoke(this, e);
}
public void OnEdited(IRibbonControl control, string text) => Edited?.Invoke(control, text);
public void handleEdit()
{
Edited?.Invoke(this, Base);
}
private void Edit()
{
Edited?.Invoke(this, new EventArgs());
}
public void InvokeEdited()
{
Edited?.Invoke(this, EventArgs.Empty);
Dismiss();
}
/// <summary>
/// Called when curve gets edited.
/// </summary>
public void OnEdited()
{
Edited?.Invoke();
}
async void Save_Clicked(object sender, EventArgs e)
{
if (IsBusy || input.IsVisible)
{
return;
}
IsBusy = true;
var result = await DataBase.Manager.EditTextAsync(Name, Text);
if (result != DataBase.ReturnCode.Success)
{
IsBusy = false;
await DisplayAlert(Resource.Error, Resource.SaveFileError + " " + result.GetDescription(), Resource.Ok);
return;
}
string description;
if (string.IsNullOrWhiteSpace(Text))
{
description = Resource.EmptyFile;
}
else if (Settings.Storage.UseKeyWords)
{
try
{
var words = await CognitiveServices.TextAnalytics.KeyPhrasesAsync(new[] { Text });
if (words[0].Length > 0)
{
description = string.Join("; ", words[0]);
}
else
{
description = Resource.NoKeyWords;
}
}
catch (Exception ex)
{
await DisplayAlert(Resource.Error, Resource.GetKeyWordsError + " " + ex.Message, Resource.Ok);
description = Text;
}
}
else
{
description = Text.Trim();
}
if (description.Length > 200)
{
description = description.Substring(0, 200);
}
result = await DataBase.Manager.EditDescriptionAsync(Name, description);
if (result != DataBase.ReturnCode.Success)
{
IsBusy = false;
await DisplayAlert(Resource.Error, Resource.UpdatingDescriptionError + " " + result.GetDescription(), Resource.Ok);
return;
}
Edited?.Invoke(this, new EditEventArgs(Name, description, Text));
IsBusy = false;
}
public virtual void OnEdited(PlayerEditEventArgs e)
{
AssertNotDisposed();
Edited?.Invoke(this, e);
}
void Node_PinRemoved(NodePin pin)
{
Disconnect(pin);
Edited.InvokeSafe(this);
}
void Node_Changed(Node node)
{
NodeEditor.Logger.Log <NodeGraph>("Node {0} changed.", node.Name);
Edited.InvokeSafe(this);
}
protected virtual void OnEdited(EditedEventArgs eventArgs)
{
Edited?.Invoke(this, eventArgs);
}
