/// <summary>
/// Pushes a <see cref="Command"/> into the undo stack or appends it to the currently active transaction,
/// if one such exists
/// </summary>
/// <param name="command">The command</param>
/// <exception cref="exception.IrreversibleCommandDuringActiveUndoRedoTransactionException">
/// When trying to push a irreversible <see cref="Command"/> during an active transaction
/// </exception>
private void pushCommand(Command command)
{
if (IsTransactionActive)
{
if (!command.CanUnExecute)
{
throw new exception.IrreversibleCommandDuringActiveUndoRedoTransactionException(
"Can not execute an irreversible command when a transaction is active");
}
CompositeCommand compo = mActiveTransactions.Peek();
ObjectListProvider <Command> list = compo.ChildCommands;
list.Insert(list.Count, command);
command.ParentComposite = compo;
}
else
{
if (command.CanUnExecute)
{
mUndoStack.Push(command);
if (mRedoStack.Contains(m_DirtyMarkerCommand))
{
m_DirtyMarkerCommand = null;
}
mRedoStack.Clear();
}
else
{
FlushCommands();
}
}
}
/// <summary>
/// Append commands to transfer the attributes of a node to another (used, TODO, role, page number)
/// </summary>
public static void AppendCopyNodeAttributes(CompositeCommand command, ProjectView.ProjectView view,
EmptyNode from, EmptyNode to)
{
if (from.TODO && !to.TODO)
{
command.ChildCommands.Insert(command.ChildCommands.Count, new Commands.Node.ToggleNodeTODO(view, to));
}
if ((!from.Used && to.Used) && (to.Role_ != EmptyNode.Role.Page && to.Role_ != EmptyNode.Role.Heading))
{
command.ChildCommands.Insert(command.ChildCommands.Count, new Commands.Node.ToggleNodeUsed(view, to));
}
// role of next phrase is copied to selected phrase only when next phrase is page, heading or silence.
// The priority is highest for page, followed by heading followed by silence. If next phrase is of higher priority only then its role is copied.
if (from.Role_ == EmptyNode.Role.Page && to.Role_ != EmptyNode.Role.Page)
{
command.ChildCommands.Insert(command.ChildCommands.Count, new Commands.Node.SetPageNumber(view, to, from.PageNumber.Clone()));
}
else if ((to.Role_ != EmptyNode.Role.Heading && to.Role_ != EmptyNode.Role.Page) &&
(from.Role_ != EmptyNode.Role.Plain &&
(from.Role_ != EmptyNode.Role.Silence || to is PhraseNode)))
{
if (from.Role_ == EmptyNode.Role.Heading && to.Role_ != EmptyNode.Role.Page)
{
command.ChildCommands.Insert(command.ChildCommands.Count, new Commands.Node.AssignRole(view, from, EmptyNode.Role.Plain, null));
command.ChildCommands.Insert(command.ChildCommands.Count, new Commands.Node.AssignRole(view, to, EmptyNode.Role.Heading, null));
}
else
{
command.ChildCommands.Insert(command.ChildCommands.Count, new Commands.Node.AssignRole(view, to, from.Role_, from.CustomRole));
}
}
}
protected override void OnDeleteCommandExecutedOverride(object sender, ExecutedRoutedEventArgs e)
{
var compositeRemoveCommand = new CompositeCommand("Remove Connections");
foreach (var item in this.SelectedItems)
{
var container = this.ContainerGenerator.ContainerFromItem(item) as IShape;
if (container != null)
{
foreach (var connection in this.GetConnectionsForShape(container).ToList())
{
compositeRemoveCommand.AddCommand(new UndoableDelegateCommand("Remove Connection",
new Action<object>((o) => this.RemoveConnection(connection)),
new Action<object>((o) => this.AddConnection(connection))));
}
}
}
base.OnDeleteCommandExecutedOverride(sender, e);
if (compositeRemoveCommand.Commands.Count() > 0)
{
compositeRemoveCommand.Execute();
((this.UndoRedoService.UndoStack.FirstOrDefault() as CompositeCommand).Commands as IList<Telerik.Windows.Diagrams.Core.ICommand>).Add(compositeRemoveCommand);
}
}
public void ExecuteForCommand()
{
ICommand setX = new SetVariableCommand("x", new ConstantExpression(0));
ICommand setY = new SetVariableCommand("y", new ConstantExpression(0));
List <ICommand> commands = new List <ICommand>();
commands.Add(setX);
commands.Add(setY);
ICommand initialCommand = new CompositeCommand(commands);
IExpression condition = new CompareExpression(ComparisonOperator.Less, new VariableExpression("x"), new ConstantExpression(6));
IExpression addXtoY = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("y"), new VariableExpression("x"));
ICommand addToY = new SetVariableCommand("y", addXtoY);
ICommand endCommand = new SetVariableCommand("x", new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("x"), new ConstantExpression(1)));
ForCommand forcmd = new ForCommand(initialCommand, condition, endCommand, addToY);
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("y", null);
forcmd.Execute(environment);
Assert.AreEqual(15, environment.GetValue("y"));
}
public void ExecuteCompositeCommand()
{
BindingEnvironment environment = new BindingEnvironment();
SetVariableCommand command1 = new SetVariableCommand("foo", new ConstantExpression("bar"));
SetVariableCommand command2 = new SetVariableCommand("one", new ConstantExpression(1));
SetVariableCommand command3 = new SetVariableCommand("bar", new VariableExpression("foo"));
List <ICommand> commands = new List <ICommand>();
commands.Add(command1);
commands.Add(command2);
commands.Add(command3);
CompositeCommand command = new CompositeCommand(commands);
environment.SetValue("foo", null);
environment.SetValue("one", null);
command.Execute(environment);
Assert.AreEqual("bar", environment.GetValue("foo"));
Assert.AreEqual(1, environment.GetValue("one"));
Assert.AreEqual("bar", environment.GetValue("bar"));
}
public void ExecuteWhileCommand()
{
IExpression incrementX = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new ConstantExpression(1), new VariableExpression("x"));
IExpression decrementY = new ArithmeticBinaryExpression(ArithmeticOperator.Subtract, new VariableExpression("y"), new ConstantExpression(1));
ICommand setX = new SetVariableCommand("x", incrementX);
ICommand setY = new SetVariableCommand("y", decrementY);
List <ICommand> commands = new List <ICommand>();
commands.Add(setX);
commands.Add(setY);
ICommand command = new CompositeCommand(commands);
IExpression yexpr = new VariableExpression("y");
WhileCommand whilecmd = new WhileCommand(yexpr, command);
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("x", 0);
environment.SetValue("y", 5);
whilecmd.Execute(environment);
Assert.AreEqual(0, environment.GetValue("y"));
Assert.AreEqual(5, environment.GetValue("x"));
}
public MainPageViewModel(INavigationService navService, IDialogService dialogService, ISettingService settingService, IResourceLoader resourceLoader)
{
_navService = navService;
_dialogService = dialogService;
_settingService = settingService;
_resourceLoader = resourceLoader;
CurrentPageIndex = 1;
MaxPageIndex = 2;
TrangDocTruyen = Wrapper.SiteTruyen.LuongSonBac;
TheLoaiDangXem = Wrapper.TagTruyen.Default;
GenerateData();
IsLoading = false;
JumpPageCommand = new DelegateCommand <string>(AddPage);
LoadingNextPageCommand = new CompositeCommand();
LoadingNextPageCommand.RegisterCommand(JumpPageCommand);
LoadingNextPageCommand.RegisterCommand(LoadingTheLoaiCommand);
LoadingPreviousCommand = new CompositeCommand();
LoadingPreviousCommand.RegisterCommand(JumpPageCommand);
LoadingPreviousCommand.RegisterCommand(LoadingTheLoaiCommand);
NavigateChapterCommand = new DelegateCommand <object>(NavigateChapter);
FirstLoadCommand = new DelegateCommand(FisrtLoad);
SearchPageCommand = new DelegateCommand <string>(Search);
ClearSearchPageCommand = new DelegateCommand(ClearSearch);
ChangeSiteTruyenCommand = new DelegateCommand <SiteTruyenVM>(
async(value) =>
{
ChangeSiteTruyen(value);
await LoadingTheLoaiCommand.Execute();
});
ListViewScrollValue = 0;
}
public static CompositeCommand GetMergeCommand(ProjectView.ProjectView view, EmptyNode node, EmptyNode next)
{
if (node != null && next != null)
{
CompositeCommand command =
view.Presentation.CreateCompositeCommand(Localizer.Message("merge_phrase_with_next"));
if (node is PhraseNode)
{
AppendCopyNodeAttributes(command, view, next, node);
if (next is PhraseNode)
{
command.ChildCommands.Insert(command.ChildCommands.Count, new Commands.Node.MergeAudio(view, (PhraseNode)node, (PhraseNode)next));
}
else
{
command.ChildCommands.Insert(command.ChildCommands.Count, new Commands.Node.Delete(view, next));
}
}
else
{
AppendCopyNodeAttributes(command, view, node, next);
command.ChildCommands.Insert(command.ChildCommands.Count, new Commands.Node.Delete(view, node));
}
return(command);
}
return(null);
}
public static ICommand Then(this ICommand left, ICommand right)
{
var command = new CompositeCommand();
command.Add(left);
command.Add(right);
return(command);
}
public ArticleViewModel(INewsFeedService newsFeedService,
IRegionManager regionManager,
IEventAggregator eventAggregator)
{
this.saveAllCommand = new CompositeCommand();
this.saveAllCommand.RegisterCommand(new SaveProductsCommand());
this.saveAllCommand.RegisterCommand(new SaveOrdersCommand());
}
public static IDisposable RegisterWorkitemCommand(string commandName, IWorkItem workItem, Action action)
{
CompositeCommand compositeCommand = GetCompositeCommandByName(commandName, workItem);
ICommand command = new DelegateCommand(action);
compositeCommand.RegisterCommand(command);
return(new DisposableAction(() => compositeCommand.UnregisterCommand(command)));
}
public void RunDefaultImageEnchancement()
{
var composite = new CompositeCommand();
composite.Add(new ResizeCommand());
composite.Add(new BlackAndWhiteFilterCommand());
composite.Execute();
}
public static CompositeCommand GetSplitCommand(ProjectView.ProjectView view, PhraseNode phrase, double time)
{
CompositeCommand command =
view.Presentation.CreateCompositeCommand(Localizer.Message("split_phrase"));
AppendSplitCommandWithProperties(view, command, phrase, time, false);
return(command);
}
public void VisitComposite(CompositeCommand Composite)
{
System.Console.WriteLine("Composite");
foreach (IScriptCommand command in Composite.Commands)
{
command.Accept(this);
}
}
protected ICommand CombineCommands(ICommand command1, ICommand command2)
{
CompositeCommand command = new CompositeCommand();
command.RegisterCommand(command1);
command.RegisterCommand(command2);
return(command);
}
private CompositeCommand GetCommandForImportAudioFileInEachSection(PhraseNode phraseNode, SectionNode section)
{
CompositeCommand command = m_Presentation.CreateCompositeCommand(Localizer.Message("import_phrases"));
Commands.Node.AddNode addCmd = new Commands.Node.AddNode(m_ProjectView, phraseNode, section, section.PhraseChildCount, false);
command.ChildCommands.Insert(command.ChildCommands.Count, addCmd);
return(command);
}
public DeleteExistingEntityCommandExecutor(CompositeCommand command, IRegionManager regionManager, IEventAggregator eventAggregator, IEntityDeleteService <U> entityDeleteService)
{
_regionManager = regionManager;
_eventAggregator = eventAggregator;
_entityDeleteService = entityDeleteService;
commandHandler = new DelegateCommand <U>(ExecuteCommand);
command.RegisterCommand(commandHandler);
}
private void RegisterSingleCommand(CompositeCommand compositeCommand, DelegateCommand command)
{
if (compositeCommand.RegisteredCommands.Count > 0)
{
compositeCommand.UnregisterCommand(compositeCommand.RegisteredCommands[0]);
}
compositeCommand.RegisterCommand(command);
}
public void CanExecuteEmptyCommandWithAtLeastOneMustBeExecutable(bool atLeastOneMustBeExecutable, bool expectedValue)
{
var compositeCommand = new CompositeCommand();
compositeCommand.AtLeastOneMustBeExecutable = atLeastOneMustBeExecutable;
Assert.AreEqual(expectedValue, ((ICatelCommand)compositeCommand).CanExecute(null));
}
public void RegisteringCommandInItselfThrows()
{
Assert.Throws <ArgumentException>(() =>
{
var compositeCommand = new CompositeCommand();
compositeCommand.RegisterCommand(compositeCommand);
});
}
public void RegisteringCommandWithNullThrows()
{
Assert.Throws <ArgumentNullException>(() =>
{
var compositeCommand = new CompositeCommand();
compositeCommand.RegisterCommand(null);
});
}
/// <summary>
/// Called when [apply template].
/// </summary>
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
_btnSave = GetTemplateChild("Part_SaveButton") as Button;
_btnNext = GetTemplateChild("Part_NextButton") as Button;
_btnCancel = GetTemplateChild("Part_CancelButton") as Button;
_focusElement = GetTemplateChild("Part_Focus") as Grid;
_contentPresenter = GetTemplateChild("PART_ContentPresenter") as ContentPresenter;
_maximizeGrid = GetTemplateChild("PART_MaximizeGrid") as Grid;
_rootGrid = GetTemplateChild("PART_RootGrid") as Grid;
_saveCompositeCommand = new CompositeCommand();
_saveCompositeCommand.RegisterCommand(new DelegateCommand(ExecuteSaveCommand));
if (SaveCommand != null)
{
_saveCompositeCommand.RegisterCommand(SaveCommand);
if (!_afterSaveCommandIntialized)
{
_afterSaveCommandIntialized = true;
_saveCompositeCommand.RegisterCommand(new DelegateCommand(AfterSaveCommandExecute));
}
}
_btnSave.Command = _saveCompositeCommand;
var contentBinding = new Binding();
contentBinding.Source = this;
contentBinding.Path = new PropertyPath(PropertyUtil.ExtractPropertyName(() => Content));
_btnSave.SetBinding(ButtonBase.CommandParameterProperty, contentBinding);
_btnNext.Click += NextClicked;
_btnCancel.Click += CancelClick;
LostFocus += Content_LostFocus;
_focusElement.MouseLeftButtonDown += Content_MouseLeftButtonDown;
AddHandler(MouseLeftButtonDownEvent, new MouseButtonEventHandler(EditableExpander_MouseLeftButtonDown), true);
MouseLeftButtonDown += EditableExpander_MouseLeftButtonDown;
if (IsExpanded)
{
VisualStateManager.GoToState(this, "RevealState", true);
}
if (UsingEditableContentTemplate())
{
ContentTemplate = EditableContentTemplate;
}
_templateApplied = true;
UpdateContentPresenter();
if (IsEditing)
{
TurnOnEditing();
}
else
{
TurnOffEditing();
}
}
private void PushUndoStack()
{
// Undo/Redo
ISupportUndo pageVMUndo = designerCanvas.DataContext as ISupportUndo;
IGroupOperation pageVMGroup = designerCanvas.DataContext as IGroupOperation;
if (pageVMUndo == null)
{
return;
}
CompositeCommand cmds = new CompositeCommand();
IPagePropertyData Page = designerCanvas.DataContext as IPagePropertyData;
bool bHasGroup = Page.GetSelectedwidgets().Any(a => a.IsGroup);
// Create undoable command for widgets
foreach (WidgetViewModBase item in _infoItems)
{
item.PropertyMementos.SetPropertyNewValue("Left", item.Raw_Left);
item.PropertyMementos.SetPropertyNewValue("Top", item.Raw_Top);
if (item.WidgetType == WidgetType.Toast && item.Top != 0)
{
item.PropertyMementos.SetPropertyNewValue("DisplayPosition", ToastDisplayPosition.UserSetting);
}
PropertyChangeCommand cmd = new PropertyChangeCommand(item, item.PropertyMementos);
cmds.AddCommand(cmd);
}
// Create undoable command for groups
if (pageVMGroup != null)
{
List <Guid> groupGuids = _groups.Select(x => x.WidgetID).ToList();
if (designerItem.ParentID != Guid.Empty)
{
groupGuids.Add(designerItem.ParentID);
}
if (groupGuids.Count > 0)
{
UpdateGroupCommand cmd = new UpdateGroupCommand(pageVMGroup, groupGuids);
cmds.AddCommand(cmd);
}
}
// Push to undo stack
if (cmds.Count > 0)
{
List <IWidgetPropertyData> allSelects = _selectionService.GetSelectedWidgets();
cmds.AddCommand(new SelectCommand(pageVMGroup, allSelects));
cmds.DeselectAllWidgetsFirst();
pageVMUndo.UndoManager.Push(cmds);
}
}
public void RegisteringCommandTwiceThrows()
{
var compositeCommand = new CompositeCommand();
var duplicateCommand = new TestCommand();
compositeCommand.RegisterCommand(duplicateCommand);
compositeCommand.RegisterCommand(duplicateCommand);
}
/// <summary>
/// Fires the <see cref="TransactionCancelled"/> event
/// </summary>
private void NotifyTransactionCancelled(CompositeCommand command)
{
EventHandler <TransactionCancelledEventArgs> d = TransactionCancelled;
if (d != null)
{
d(this, new TransactionCancelledEventArgs(this, command));
}
}
/// <summary>
/// Constructor estático.
/// </summary>
static EditionCommands()
{
activateRecordCommand = new CompositeCommand();
deleteRecordCommand = new CompositeCommand();
editRecordCommand = new CompositeCommand();
getRecordsCommand = new CompositeCommand();
newRecordCommand = new CompositeCommand();
saveRecordCommand = new CompositeCommand();
}
public static void Behavioral_CommandComposite()
{
// This is a composite command
var composite = new CompositeCommand();
composite.Add(new ResizeCommand());
composite.Add(new BlackAndWhiteCommand());
composite.Execute();
}
static void TestCompositeCommand()
{
var composite = new CompositeCommand();
composite.Add(new ResizeCommand());
composite.Add(new BlackAndWhiteCommand());
composite.Execute();
}
public void DecompileCompositeCommand()
{
IExpression expression = new ArithmeticBinaryExpression(ArithmeticOperation.Add, new ConstantExpression(1), new ConstantExpression(2));
ICommand command1 = new SetCommand("a", expression);
ICommand command2 = new SetCommand("b", expression);
ICommand command = new CompositeCommand(new ICommand[] { command1, command2 });
Assert.AreEqual("{\r\na = (1 + 2);\r\nb = (1 + 2);\r\n}\r\n", this.Decompile(command));
}
private static void EvaluateCommands(string text, Context context)
{
Parser parser = new Parser(text);
var result = parser.ParseCommands();
var command = new CompositeCommand(result);
command.Execute(context);
}
private UndoableDelegateCommand CreateRemoveConnectionCommand(IConnection connection)
{
var compositeRemoveConnectionCommand = new CompositeCommand(CommandNames.RemoveConnections);
UndoableDelegateCommand removeCommand = new UndoableDelegateCommand(CommandNames.RemoveConnection, s => this.Diagram.RemoveConnection(connection), s => this.Diagram.AddConnection(connection));
compositeRemoveConnectionCommand.AddCommand(removeCommand);
return(compositeRemoveConnectionCommand);
}
public void CanExecuteChangedWithMultipleCommands()
{
var command1 = new DelegateCommand(() => { }, () => true);
var command2 = new DelegateCommand<int>(i => { }, _ => true);
var compositeCommand = new CompositeCommand();
bool canExecuteEventFired = false;
EventHandler eventHandler = (sender, eventArgs) =>
{
Assert.AreSame(compositeCommand, sender);
Assert.IsNotNull(eventArgs);
canExecuteEventFired = true;
};
compositeCommand.CanExecuteChanged += eventHandler;
compositeCommand.RegisterCommand(command1);
compositeCommand.RegisterCommand(command2);
Assert.IsFalse(EventConsumer.EventCalled);
command1.RaiseCanExecuteChanged();
Assert.IsTrue(canExecuteEventFired);
canExecuteEventFired = false;
command2.RaiseCanExecuteChanged();
Assert.IsTrue(canExecuteEventFired);
canExecuteEventFired = false;
compositeCommand.UnregisterCommand(command1);
Assert.IsTrue(canExecuteEventFired); // Unregister also raises CanExecuteChanged.
canExecuteEventFired = false;
command1.RaiseCanExecuteChanged();
Assert.IsFalse(canExecuteEventFired);
command2.RaiseCanExecuteChanged();
Assert.IsTrue(canExecuteEventFired);
canExecuteEventFired = false;
compositeCommand.UnregisterCommand(command2);
Assert.IsTrue(canExecuteEventFired); // Unregister also raises CanExecuteChanged.
canExecuteEventFired = false;
command1.RaiseCanExecuteChanged();
command2.RaiseCanExecuteChanged();
Assert.IsFalse(canExecuteEventFired);
}
private void DeleteShape(IShape shape)
{
var compositeRemoveShapeCommand = new CompositeCommand(CommandNames.RemoveShapes);
var observableGraphSource = this.GraphSource as IObservableGraphSource;
if (observableGraphSource != null)
{
foreach (var connection in this.GetConnectionsForShape(shape))
{
compositeRemoveShapeCommand.AddCommand(this.CreateRemoveConnectionCommand(connection, observableGraphSource));
if (!shape.Equals(connection.Target))
{
compositeRemoveShapeCommand.AddCommand(this.CreateRemoveShapeCommand(connection.Target, observableGraphSource));
}
}
compositeRemoveShapeCommand.AddCommand(this.CreateRemoveShapeCommand(shape, observableGraphSource));
this.UndoRedoService.ExecuteCommand(compositeRemoveShapeCommand);
}
}
public void CanExecuteWithMultipleCommands()
{
bool canExecuteCommand1 = false;
bool canExecuteCommand2 = false;
var command1 = new DelegateCommand(
() => { },
() => canExecuteCommand1);
var command2 = new DelegateCommand<int>(
i => Assert.AreEqual(123, i),
i =>
{
Assert.AreEqual(123, i);
return canExecuteCommand2;
});
var compositeCommand = new CompositeCommand();
Assert.IsFalse(compositeCommand.CanExecute(123));
compositeCommand.RegisterCommand(command1);
compositeCommand.RegisterCommand(command2);
Assert.IsFalse(compositeCommand.CanExecute(123));
canExecuteCommand1 = true;
Assert.IsFalse(compositeCommand.CanExecute(123));
canExecuteCommand2 = true;
Assert.IsTrue(compositeCommand.CanExecute(123));
canExecuteCommand1 = false;
compositeCommand.UnregisterCommand(command1);
Assert.IsTrue(compositeCommand.CanExecute(123));
canExecuteCommand2 = false;
Assert.IsFalse(compositeCommand.CanExecute(123));
canExecuteCommand1 = true;
canExecuteCommand2 = true;
compositeCommand.UnregisterCommand(command2);
Assert.IsFalse(compositeCommand.CanExecute(123));
}
// Use this for initialization
void Start(){
t = new EnterFrameTimer(200);
t.OnTimer = onTimer;
t.Start();
ConsoleCommand command;
CompositeCommand cc = new CompositeCommand(CompositeCommandMode.SEQUENCE);
cc.OnCommandItemComplete = delegate(AbstractCommand _command) {
Debug.Log("Item Complete" + " " + (_command as ConsoleCommand).index.ToString());
};
cc.OnCommandComplete = delegate(AbstractCommand _command) {
Debug.Log("All Complete");
};
int max = 10;
for (int i = 0; i < max; i++) {
command = new ConsoleCommand();
command.index = i;
cc.AddCommand(command);
}
cc.Execute();
}
internal void CommitItemFontColor(Brush oldFontColor, Brush newFontColor)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand("Change Items Font Color");
foreach (var item in this.SelectedItems)
{
var ensureDifferentItem = item;
var command = new UndoableDelegateCommand("Change Item Font Color",
p =>
{
if (newFontColor != null)
{
ensureDifferentItem.Foreground = newFontColor;
}
},
p =>
{
if (oldFontColor != null)
{
ensureDifferentItem.Foreground = oldFontColor;
}
});
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
}
public override LineBufferOperationResults InsertLines(
int lineIndex,
int count)
{
var composite = new CompositeCommand<BlockCommandContext>(true, false);
using (project.Blocks.AcquireLock(RequestLock.Write))
{
for (int i = 0;
i < count;
i++)
{
var block = new Block(project.Blocks);
var command = new InsertIndexedBlockCommand(lineIndex, block);
composite.Commands.Add(command);
}
var context = new BlockCommandContext(project);
project.Commands.Do(composite, context);
return GetOperationResults();
}
}
private CompositeCommand CreateRemoveShapeCommand(RadDiagramShapeBase shape)
{
if (shape == null) return null;
var compositeRemoveShapeCommand = new CompositeCommand(CommandNames.RemoveShapes);
var removeCommand = new UndoableDelegateCommand(CommandNames.RemoveShape, s => this.Diagram.RemoveShape(shape), s => this.Diagram.AddShape(shape));
var parentContainer = shape.ParentContainer;
if (parentContainer != null)
{
var execute = new Action<object>((o) => parentContainer.RemoveItem(shape));
var undo = new Action<object>((o) =>
{
if (!parentContainer.Items.Contains(shape))
parentContainer.AddItem(shape);
});
compositeRemoveShapeCommand.AddCommand(new UndoableDelegateCommand(CommandNames.RemoveItemFromContainer, execute, undo));
}
foreach (var changeSourceCommand in shape.OutgoingLinks.Union(shape.IncomingLinks).ToList().Select(connection => this.CreateRemoveConnectionCommand(connection)))
{
compositeRemoveShapeCommand.AddCommand(changeSourceCommand);
}
compositeRemoveShapeCommand.AddCommand(removeCommand);
var container = shape as RadDiagramContainerShape;
if (container != null)
{
for (int i = container.Items.Count - 1; i >= 0; i--)
{
var shapeToRemove = container.Items[i] as RadDiagramShapeBase;
if (shapeToRemove != null)
compositeRemoveShapeCommand.AddCommand(this.CreateRemoveShapeCommand(shapeToRemove));
else
{
var connection = container.Items[i] as IConnection;
if (connection != null && connection.Source == null && connection.Target == null)
compositeRemoveShapeCommand.AddCommand(this.CreateRemoveConnectionCommand(container.Items[i] as IConnection));
}
}
}
return compositeRemoveShapeCommand;
}
private UndoableDelegateCommand CreateRemoveConnectionCommand(IConnection connection)
{
var compositeRemoveConnectionCommand = new CompositeCommand(CommandNames.RemoveConnections);
UndoableDelegateCommand removeCommand = new UndoableDelegateCommand(CommandNames.RemoveConnection, s => this.Diagram.RemoveConnection(connection), s => this.Diagram.AddConnection(connection));
compositeRemoveConnectionCommand.AddCommand(removeCommand);
return compositeRemoveConnectionCommand;
}
private void OnItemsChanging(object sender, DiagramItemsChangingEventArgs e)
{
if (this.isClear) return;
if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove)
{
var rowModel = e.OldItems.ElementAt(0) as RowModel;
var command = new CompositeCommand("Remove Connections");
if (rowModel != null)
{
this.RemoveRowModel(rowModel, command);
if (command.Commands.Count() > 0)
this.diagram.UndoRedoService.ExecuteCommand(command);
}
else
{
var tableModel = e.OldItems.ElementAt(0) as TableModel;
if (tableModel != null)
{
foreach (var item in tableModel.InternalItems)
{
this.RemoveRowModel(item as RowModel, command);
}
if (command.Commands.Count() > 0)
this.diagram.UndoRedoService.ExecuteCommand(command);
tableModel.InternalItems.Clear();
}
}
}
}
internal void CommitConnectionTargetCapType(CapType? oldTargetCapType, CapType? newTargetCapType)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand("Change Connections Target Cap Type");
foreach (var conn in this.SelectedConnections)
{
var ensureDifferentConnection = conn;
var command = new UndoableDelegateCommand("Change Connection Target Cap Type",
p => ensureDifferentConnection.TargetCapType = newTargetCapType.HasValue ? newTargetCapType.Value : CapType.None,
p => ensureDifferentConnection.TargetCapType = oldTargetCapType.HasValue ? oldTargetCapType.Value : CapType.None);
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
}
private void RemoveContainer(MainContainerShapeBase container, RadDiagramShapeBase itemToRemove)
{
if (container == null || itemToRemove == null) return;
CompositeCommand command = new CompositeCommand("Remove horizontal container");
if (container.IsCollapsed)
{
command.AddCommand(new UndoableDelegateCommand("Update container",
new Action<object>((o) =>
{
container.IsCollapsed = false;
}),
new Action<object>((o) =>
{
container.IsCollapsed = true;
})));
}
command.AddCommand(this.CreateRemoveShapeCommand(itemToRemove));
if (container.IsCollapsed)
{
command.AddCommand(new UndoableDelegateCommand("Update container",
new Action<object>((o) =>
{
}),
new Action<object>((o) =>
{
})));
}
this.Diagram.UndoRedoService.ExecuteCommand(command);
}
internal void CommitShapeHeight(double newHeight)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand(CommandNames.ResizeShapes);
foreach (var shape in this.SelectedShapes)
{
var ensureDifferentShape = shape;
var ensureOldValue = ensureDifferentShape.Height;
var command = new UndoableDelegateCommand(CommandNames.ResizeShape,
p => ensureDifferentShape.Height = newHeight,
p => ensureDifferentShape.Height = ensureOldValue);
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
this.OnBoundsChanged();
}
public void CanExecuteChangedEventShouldBeWeak()
{
var command1 = new DelegateCommand(() => { }, null);
var command2 = new DelegateCommand<int>(i => { }, null);
var compositeCommand = new CompositeCommand();
compositeCommand.RegisterCommand(command1);
compositeCommand.RegisterCommand(command2);
compositeCommand.CanExecuteChanged += new EventConsumer().EventHandler;
// Garbage collect the EventConsumer.
GC.Collect();
EventConsumer.Clear();
command1.RaiseCanExecuteChanged();
command2.RaiseCanExecuteChanged();
Assert.IsFalse(EventConsumer.EventCalled);
}
internal void CommitItemStrokeThickness(double oldStrokeThickness, double newStrokeThickness)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand("Change Items Border Thickness");
foreach (var item in this.SelectedItems)
{
var ensureDifferentItem = item;
var command = new UndoableDelegateCommand("Change Item Border Thikness",
p => ensureDifferentItem.StrokeThickness = newStrokeThickness,
p => ensureDifferentItem.StrokeThickness = oldStrokeThickness);
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
}
public void ExecuteMultipleCommands()
{
bool command1Called = false;
bool command2Called = false;
var command1 = new DelegateCommand(
() => command1Called = true,
() => true);
var command2 = new DelegateCommand<int>(
i =>
{
Assert.AreEqual(123, i);
command2Called = true;
},
i =>
{
Assert.AreEqual(123, i);
return true;
});
var compositeCommand = new CompositeCommand();
compositeCommand.RegisterCommand(command1);
compositeCommand.RegisterCommand(command2);
compositeCommand.Execute(123);
Assert.IsTrue(command1Called);
Assert.IsTrue(command2Called);
command1Called = false;
command2Called = false;
compositeCommand.UnregisterCommand(command1);
compositeCommand.Execute(123);
Assert.IsFalse(command1Called);
Assert.IsTrue(command2Called);
}
internal void CommitItemStrokeDashArray(DoubleCollection oldStrokeDashArray, DoubleCollection newStrokeDashArray)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand("Change Items Border Dash Style");
foreach (var item in this.SelectedItems)
{
var ensureDifferentItem = item;
var command = new UndoableDelegateCommand("Change Item Border Dash Style",
p => ensureDifferentItem.StrokeDashArray = newStrokeDashArray,
p => ensureDifferentItem.StrokeDashArray = oldStrokeDashArray);
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
}
private void RemoveRowModel(RowModel rowModel, CompositeCommand command)
{
var container = this.diagram.ContainerGenerator.ContainerFromItem(rowModel) as IShape;
if (container == null) return;
foreach (var connection in this.diagram.GetConnectionsForShape(container).ToList())
{
var link = this.diagram.ContainerGenerator.ItemFromContainer(connection) as LinkViewModelBase<NodeViewModelBase>;
command.AddCommand(new UndoableDelegateCommand(
"Remove link",
new Action<object>((o) => this.dc.RemoveLink(link)),
new Action<object>((o) => this.dc.AddLink(link))));
}
}
internal void CommitItemColorStyle(ColorStyle oldColorStyle, ColorStyle newColorStyle)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand("Change Items Color Style");
foreach (var item in this.SelectedItems)
{
var ensureDifferentItem = item;
var command = new UndoableDelegateCommand("Change Item Color Style",
p =>
{
if (newColorStyle != null)
{
ensureDifferentItem.Background = newColorStyle.Fill;
ensureDifferentItem.BorderBrush = newColorStyle.Stroke;
ensureDifferentItem.Stroke = newColorStyle.Stroke;
}
},
p =>
{
if (oldColorStyle != null)
{
ensureDifferentItem.Background = oldColorStyle.Fill;
ensureDifferentItem.BorderBrush = oldColorStyle.Stroke;
ensureDifferentItem.Stroke = oldColorStyle.Stroke;
}
});
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
}
internal void CommitItemLabel(string oldLabel, string newLabel)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand("Change Items Content");
foreach (var item in this.SelectedItems)
{
var ensureDifferentItem = item;
var command = new UndoableDelegateCommand("Change Item Content",
p => ensureDifferentItem.Content = newLabel,
p => ensureDifferentItem.Content = oldLabel);
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
}
internal void CommitItemFontFamily(FontFamily oldFontFamily, FontFamily newFontFamily)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand("Change Items Font Family");
foreach (var item in this.SelectedItems)
{
var ensureDifferentItem = item;
var command = new UndoableDelegateCommand("Change Item Font Family",
p => ensureDifferentItem.FontFamily = newFontFamily,
p => ensureDifferentItem.FontFamily = oldFontFamily);
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
}
public void ProcessImmediateEdits(
BlockCommandContext context,
Block block,
int textIndex)
{
// Get the plugin settings from the project.
ImmediateBlockTypesSettings settings = Settings;
// Grab the substring from the beginning to the index and compare that
// in the dictionary.
string text = block.Text.Substring(0, textIndex);
if (!settings.Replacements.ContainsKey(text))
{
// We want to fail as fast as possible.
return;
}
// If the block type is already set to the same name, skip it.
string blockTypeName = settings.Replacements[text];
BlockType blockType = Project.BlockTypes[blockTypeName];
if (block.BlockType == blockType)
{
return;
}
// Perform the substitution with a replace operation and a block change
// operation.
var replaceCommand =
new ReplaceTextCommand(
new BlockPosition(block.BlockKey, 0), textIndex, string.Empty);
var changeCommand = new ChangeBlockTypeCommand(block.BlockKey, blockType);
// Create a composite command that binds everything together.
var compositeCommand = new CompositeCommand<BlockCommandContext>(true, false);
compositeCommand.Commands.Add(replaceCommand);
compositeCommand.Commands.Add(changeCommand);
// Add the command to the deferred execution so the command could
// be properly handled via the undo/redo management.
block.Project.Commands.DeferDo(compositeCommand);
}
internal void CommitItemFontSize(double? oldFontSize, double? newFontSize)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand("Change Items Font Size");
foreach (var item in this.SelectedItems)
{
var ensureDifferentItem = item;
var command = new UndoableDelegateCommand("Change Item Font Size",
p =>
{
if (newFontSize.HasValue)
{
ensureDifferentItem.FontSize = newFontSize.Value;
}
},
p =>
{
if (oldFontSize.HasValue)
{
ensureDifferentItem.FontSize = oldFontSize.Value;
}
});
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
}
internal void CommitShapePositionY(double newPositionY)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand(CommandNames.MoveItems);
foreach (var shape in this.SelectedShapes)
{
var ensureDifferentShape = shape;
var ensureOldValue = ensureDifferentShape.Position.Y;
var command = new UndoableDelegateCommand(CommandNames.MoveItem,
p => ensureDifferentShape.Position = new Point(ensureDifferentShape.Position.X, newPositionY),
p => ensureDifferentShape.Position = new Point(ensureDifferentShape.Position.X, ensureOldValue));
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
this.OnBoundsChanged();
}
private static void DetachConnections(RadDiagram diagram)
{
if (diagram.SelectedItems.Count() > 1)
{
CompositeCommand changeSourcesCompositeCommand = new CompositeCommand("Detach ends");
foreach (var connection in diagram.SelectedItems.OfType<IConnection>())
{
if (!diagram.SelectedItems.Contains(connection.Source))
{
changeSourcesCompositeCommand.AddCommand(new ChangeSourceCommand(connection, null, connection.StartPoint));
}
if (!diagram.SelectedItems.Contains(connection.Target))
{
changeSourcesCompositeCommand.AddCommand(new ChangeTargetCommand(connection, null, connection.EndPoint));
}
}
changeSourcesCompositeCommand.Execute();
AttachedProperties.SetPendingCommand(diagram, changeSourcesCompositeCommand);
}
}
internal void CommitShapeRotaionAngle(double newRotaionAngle)
{
if (this.owner == null)
{
return;
}
var compositeCommand = new CompositeCommand(CommandNames.RotateItems);
foreach (var shape in this.SelectedShapes)
{
var ensureDifferentShape = shape;
var ensureOldValue = ensureDifferentShape.RotationAngle;
var command = new UndoableDelegateCommand(CommandNames.RotateItem,
p => ensureDifferentShape.RotationAngle = newRotaionAngle,
p => ensureDifferentShape.RotationAngle = ensureOldValue);
compositeCommand.AddCommand(command);
}
this.owner.UndoRedoService.ExecuteCommand(compositeCommand);
this.OnBoundsChanged();
}
private void AddContainer(MainContainerShapeBase container, IShape itemToAdd)
{
if (container == null || itemToAdd == null) return;
CompositeCommand command = new CompositeCommand("Add new container");
if (container.IsCollapsed)
{
command.AddCommand(new UndoableDelegateCommand("Update container",
new Action<object>((o) =>
{
container.IsCollapsed = false;
}),
new Action<object>((o) =>
{
container.IsCollapsed = true;
})));
}
command.AddCommand(new UndoableDelegateCommand("Add Container",
new Action<object>((o) =>
{
container.Items.Add(itemToAdd);
container.IsCollapsed = false;
}),
new Action<object>((o) =>
{
this.Diagram.RemoveShape(itemToAdd);
container.IsCollapsed = false;
})));
this.Diagram.UndoRedoService.ExecuteCommand(command);
}