protected override IScriptCommand executeInner(ParameterDic pm, ItemsControl ic, RoutedEventArgs evnt, IUIInput input, IList <IUIInputProcessor> inpProcs)
{
if (!_update)
{
var selectedIdList = pm.ContainsKey("SelectedIdList") ? pm["SelectedIdList"] as List <int>
: new List <int>();
logger.Debug(String.Format("Highlighting {0} items", selectedIdList.Count()));
for (int i = 0; i < ic.Items.Count; i++)
{
DependencyObject item = ic.ItemContainerGenerator.ContainerFromIndex(i);
if (item != null)
{
bool isSelecting = selectedIdList.Contains(i);
//UIEventHubProperties.SetIsSelecting(item, isSelecting);
var selectable = (item as FrameworkElement).DataContext as ISelectable;
if (selectable != null)
{
selectable.IsSelecting = isSelecting;
}
}
}
}
else
{
List <object> unselectedList = pm["UnselectedList"] as List <object>;
List <int> unselectedIdList = pm["UnselectedIdList"] as List <int>;
List <object> selectedList = pm["SelectedList"] as List <object>;
List <int> selectedIdList = pm["SelectedIdList"] as List <int>;
logger.Debug(String.Format("Highlighting {0} items", selectedIdList.Count()));
logger.Debug(String.Format("De-highlighting {0} items", unselectedIdList.Count()));
for (int i = 0; i < ic.Items.Count; i++)
{
DependencyObject ele = ic.ItemContainerGenerator.ContainerFromIndex(i);
ISelectable item = ic.Items[i] as ISelectable;
if (ele != null)
{
bool isSelecting = UIEventHubProperties.GetIsSelecting(ele);
if (isSelecting && unselectedList.Contains(ele))
{
item.IsSelecting = false;
}
//AttachedProperties.SetIsSelecting(item, false);
else if (!isSelecting && selectedList.Contains(ele))
{
item.IsSelecting = true;
}
//AttachedProperties.SetIsSelecting(ele, true);
}
}
}
return(NextCommand);
}
public override IScriptCommand Execute(ParameterDic pm)
{
IProfile[] rootProfiles = pm.GetValue <IProfile[]>(ProfilesKey);
if (rootProfiles == null || rootProfiles.Length == 0)
{
return(ResultCommand.Error(new ArgumentException(ProfilesKey)));
}
if (rootProfiles.Length == 1)
{
pm.SetValue(DestinationKey, rootProfiles[0]);
return(NextCommand);
}
else
{
IWindowManager wm = pm.GetValue <IWindowManager>(WindowManagerKey) ?? new WindowManager();
logger.Debug("Showing");
SelectProfileViewModel spvm = new SelectProfileViewModel(rootProfiles);
if (wm.ShowDialog(spvm).Value)
{
logger.Info(String.Format("Selected {0}", spvm.SelectedRootProfile));
pm.SetValue(DestinationKey, spvm.SelectedRootProfile);
return(NextCommand);
}
else
{
logger.Debug("Cancelled");
return(CancelCommand);
}
}
}
public override IScriptCommand Execute(ParameterDic pm)
{
System.Diagnostics.Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = WindowStyle;
startInfo.FileName = pm.ReplaceVariableInsideBracketed(ExecutableKey);
string workingDirectory = pm.ReplaceVariableInsideBracketed(WorkingDirectoryKey);
if (!String.IsNullOrEmpty(workingDirectory))
{
startInfo.WorkingDirectory = workingDirectory;
}
startInfo.Arguments = pm.ReplaceVariableInsideBracketed(ArgumentKey);
process.StartInfo = startInfo;
if (ResultCodeKey != null)
{
process.WaitForExit();
}
process.Start();
if (ResultCodeKey != null)
{
pm.SetValue(ResultCodeKey, process.ExitCode);
}
return(NextCommand);
}
public override IScriptCommand Execute(ParameterDic pm)
{
object value = Value;
if (ValueFunc != null)
{
value = ValueFunc();
}
if (value is string)
{
string valueString = (string)value;
if (valueString.StartsWith("{") && valueString.EndsWith("}"))
{
value = pm.GetValue(valueString);
}
}
if (pm.SetValue <Object>(VariableKey, value, SkipIfExists))
{
logger.Debug(String.Format("{0} = {1}", VariableKey, value));
}
// else logger.Debug(String.Format("Skipped {0}, already exists.", VariableKey));
return(NextCommand);
}
public static T RunScript <T>(string resultVariable = "{Result}", ParameterDic initialParameters = null,
params IScriptCommand[] commands)
{
initialParameters = initialParameters ?? new ParameterDic();
RunScript(initialParameters, false, commands);
return(initialParameters.GetValue(resultVariable, default(T)));
}
public static async Task Test_CopyStream()
{
//Prepare
MemoryStream msSource = new MemoryStream();
StreamWriter swSource = new StreamWriter(msSource);
swSource.Write(dummyPath);
swSource.Flush();
msSource.Seek(0, SeekOrigin.Begin);
MemoryStream msDest = new MemoryStream();
StreamReader reader = new StreamReader(msDest);
CopyStream copyStream = new CopyStream();
ParameterDic pd = new ParameterDic()
{
{ copyStream.SourceKey, msSource },
{ copyStream.DestinationKey, msDest }
};
//Action
IScriptCommand retCmd = await copyStream.ExecuteAsync(pd);
msDest.Seek(0, SeekOrigin.Begin);
string read = reader.ReadToEnd();
//Assert
Assert.AreEqual(dummyPath, read);
}
private bool dragStart(ParameterDic pm, IUIInput input, string mode)
{
ISupportDrag isd = pm.GetValue <ISupportDrag>(DragSourceKey);
if (pm.GetValue <string>(DragDropModeKey) == null && isd != null)
{
var draggables = isd.GetDraggables();
IDataObject dataObj = isd is ISupportShellDrag ?
(isd as ISupportShellDrag).GetDataObject(draggables) : null;
DragDropEffectsEx effect = isd.QueryDrag(draggables);
pm.SetValue(DragDropModeKey, mode);
pm.SetValue(DragDropDeviceKey, input.InputType);
pm.SetValue(DragDropDraggingItemsKey, draggables);
pm.SetValue(DragDropEffectsKey, effect);
pm.SetValue(DragDropDragSourceKey, isd);
pm.SetValue(ParameterDic.CombineVariable(DragDropDragSourceKey, ".IsDraggingFrom", false), true);
pm.SetValue(DragDropStartPositionKey, pm.GetValue <Point>(CurrentPositionAdjustedKey));
pm.SetValue(InputKey, new DragInput(input, dataObj, DragDropEffectsEx.Copy, (eff) => { }));
return(true);
}
return(false);
}
public override IScriptCommand Execute(ParameterDic pm)
{
KeyEventArgs keyEvent = pm.GetValue <KeyEventArgs>(RoutedEventArgsKey);
if (keyEvent == null)
{
return(OtherwiseCommand);
}
object keygestureObject = !KeyGestureKey.StartsWith("{") ? KeyGestureKey : pm.GetValue(KeyGestureKey);
KeyGesture gesture = null;
if (keygestureObject is KeyGesture)
{
gesture = (KeyGesture)keygestureObject;
}
if (keygestureObject is string)
{
gesture = (KeyGesture)converter.ConvertFrom(keygestureObject);
}
return(gesture != null &&
keyEvent.Key == gesture.Key &&
keyEvent.KeyboardDevice.Modifiers == gesture.Modifiers ?
NextCommand : OtherwiseCommand);
}
public override IScriptCommand Execute(ParameterDic pm)
{
if (SkipIfExists && pm.HasValue(DestinationKey))
{
return(NextCommand);
}
IEnumerable <IDraggable> value = new List <IDraggable>();
ISupportShellDrop issd = pm.GetValue <ISupportShellDrop>(ISupportDropKey);
IDataObject dataObj = pm.GetValue <IDataObject>(DataObjectKey);
if (dataObj.GetDataPresent(typeof(ISupportDrag)))
{
ISupportDrag isd = (ISupportDrag)dataObj.GetData(typeof(ISupportDrag));
value = isd.GetDraggables();
}
else
if (issd != null && dataObj != null)
{
value = (issd.QueryDropDraggables(dataObj) ?? new List <IDraggable>());
}
pm.SetValue(DestinationKey, value, SkipIfExists);
return(NextCommand);
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
IEntryModel entryModel = pm.GetValue <IEntryModel>(EntryKey);
if (entryModel == null)
{
return(ResultCommand.Error(new ArgumentException(EntryKey + " is not found or not IEntryModel")));
}
IDiskProfile profile = entryModel.Profile as IDiskProfile;
if (profile == null)
{
return(ResultCommand.Error(new NotSupportedException(EntryKey + "'s Profile is not IDiskProfile")));
}
using (var stream = await profile.DiskIO.OpenStreamAsync(entryModel, Access, pm.CancellationToken))
{
ParameterDic pmClone = pm.Clone();
pmClone.SetValue(StreamKey, stream);
logger.Debug(String.Format("{0} = Stream of {1}", StreamKey, EntryKey));
await ScriptRunner.RunScriptAsync(pmClone, NextCommand);
}
if (Access == FileAccess.ReadWrite || Access == FileAccess.Write)
{
return(CoreScriptCommands.NotifyEntryChangedProfile(ChangeType.Changed, null, EntryKey, ThenCommand));
}
else
{
return(ThenCommand);
}
}
protected override IScriptCommand executeInner(ParameterDic pm, ItemsControl ic, RoutedEventArgs evnt, IUIInput input, IList <IUIInputProcessor> inpProcs)
{
var scp = ControlUtils.GetScrollContentPresenter(ic);
IChildInfo icInfo = UITools.FindVisualChild <Panel>(scp) as IChildInfo;
if (icInfo == null)
{
return(ResultCommand.Error(new NotSupportedException()));
}
Rect selectionBound = pm.GetValue <Rect>(SelectionBoundAdjustedKey);
List <object> selectedList = new List <object>();
List <int> selectedIdList = new List <int>();
for (int i = 0; i < ic.Items.Count; i++)
{
if (icInfo.GetChildRect(i).IntersectsWith(selectionBound))
{
selectedList.Add(ic.Items[i]);
selectedIdList.Add(i);
}
}
pm.SetValue(SelectedListKey, selectedList);
pm.SetValue(SelectedIdListKey, selectedIdList);
logger.Debug(String.Format("Selected = {0}", selectedIdList.Count()));
return(NextCommand);
}
private void setVMProperty <T>(ExplorerParameterType property, T value)
{
ParameterDic pd = new ParameterDic();
pd.SetValue("{PropertyValue}", value, false);
_evm.Commands.Execute(UIScriptCommands.ExplorerSetParameter(property, "{PropertyValue}"), pd);
}
private T getVMProperty <T>(ExplorerParameterType property)
{
ParameterDic pd = new ParameterDic();
_evm.Commands.Execute(UIScriptCommands.ExplorerGetParameter(property, "{OutputValue}"), pd);
return(pd.GetValue <T>("{OutputValue}"));
}
protected override IScriptCommand executeInner(ParameterDic pm, UIElement sender, RoutedEventArgs evnt, IUIInput input, IList <IUIInputProcessor> inpProcs)
{
Point position = input.Position;
//Console.WriteLine(input.IsDragging.ToString() + position.ToString());
switch (PositionRelativeTo)
{
case PositionRelativeToType.Sender:
position = input.PositionRelativeTo(sender);
break;
case PositionRelativeToType.Scp:
var scp = ControlUtils.GetScrollContentPresenter(sender is Control ? (Control)sender : UITools.FindAncestor <Control>(sender));
position = input.PositionRelativeTo(scp);
break;
case PositionRelativeToType.Panel:
var parentPanel = UITools.FindAncestor <Panel>(sender);
position = input.PositionRelativeTo(parentPanel);
break;
case PositionRelativeToType.Window:
var parentWindow = Window.GetWindow(sender);
position = input.PositionRelativeTo(parentWindow);
break;
}
//Console.WriteLine(position);
return(ScriptCommands.Assign(DestinationKey, position, SkipIfExists, NextCommand));
}
public ParameterDic Convert(object sender, object parameter, params object[] additionalParameters)
{
var retVal = new ParameterDic();
retVal.SetValue(_variableName, sender);
return(retVal);
}
protected override IScriptCommand executeInner(ParameterDic pm, UIElement sender, RoutedEventArgs evnt, IUIInput input, IList <IUIInputProcessor> inpProcs)
{
DragEventArgs devnt = evnt as DragEventArgs;
ISupportDrop dropTarget = pm.GetValue <ISupportDrop>(DropTargetKey);
IEnumerable <IDraggable> draggables = pm.GetValue <IEnumerable <IDraggable> >(DraggablesKey);
DragDropEffectsEx allowedEffects = pm.HasValue(AllowedEffectsKey) ? pm.GetValue <DragDropEffectsEx>(AllowedEffectsKey)
: devnt != null ? (DragDropEffectsEx)devnt.AllowedEffects : DragDropEffectsEx.All;
if (dropTarget != null && draggables != null)
{
QueryDropEffects queryDropEffect = QueryDropEffects.None;
if (devnt != null)
{
queryDropEffect = dropTarget.QueryDrop(draggables, allowedEffects);
devnt.Effects = (DragDropEffects)queryDropEffect.SupportedEffects;
}
else
{
queryDropEffect = dropTarget.QueryDrop(draggables, allowedEffects);
}
pm.SetValue(DestinationKey, queryDropEffect, SkipIfExists);
}
return(NextCommand);
}
protected override IScriptCommand executeInner(ParameterDic pm, UIElement sender, RoutedEventArgs evnt, IUIInput input, IList <IUIInputProcessor> inpProcs)
{
if (evnt is GiveFeedbackEventArgs)
{
GiveFeedbackEventArgs gevnt = evnt as GiveFeedbackEventArgs;
if (CursorType != null)
{
gevnt.UseDefaultCursors = false;
Mouse.SetCursor(CursorType);
gevnt.Handled = true;
}
else
{
gevnt.UseDefaultCursors = true;
}
}
else if (evnt is QueryCursorEventArgs)
{
QueryCursorEventArgs qevnt = evnt as QueryCursorEventArgs;
if (CursorType != null)
{
qevnt.Cursor = CursorType;
qevnt.Handled = true;
}
}
return(NextCommand);
}
public override IScriptCommand Execute(ParameterDic pm)
{
switch (Mode)
{
case RunMode.Parallel:
case RunMode.Queue:
ScriptRunner.RunScript(pm, ScriptCommands);
break;
case RunMode.Sequence:
foreach (var cmd in ScriptCommands)
{
ScriptRunner.RunScript(pm, cmd);
if (pm.Error != null)
{
return(ResultCommand.Error(pm.Error));
}
}
break;
default:
return(ResultCommand.Error(new NotSupportedException(Mode.ToString())));
}
if (pm.Error != null)
{
return(ResultCommand.Error(pm.Error));
}
else
{
return(NextCommand);
}
}
public static async Task Test_DiskCreatePath()
{
//Prepare
DiskCreatePath cmd = new DiskCreatePath();
var mockProfile = new Mock <IDiskProfile>();
var mockModel = new Mock <IEntryModel>();
mockProfile.Setup(p => p.Path).Returns(PathHelper.Disk);
mockProfile.Setup(p => p.DiskIO.CreateAsync(dummyPath, false, It.IsAny <System.Threading.CancellationToken>()))
.Returns(() => Task.FromResult(mockModel.Object))
.Verifiable();
ParameterDic pd = new ParameterDic()
{
{ cmd.ProfileKey, mockProfile.Object },
{ cmd.PathKey, dummyPath }
};
//Action
await cmd.ExecuteAsync(pd);
//Assert
Assert.IsTrue(pd.ContainsKey(cmd.DestinationKey));
Assert.AreEqual(mockModel.Object, pd[cmd.DestinationKey]);
mockProfile.Verify();
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
var flValue = pm.GetValue(FileListKey);
IFileListViewModel flvm = flValue is IExplorerViewModel ?
(flValue as IExplorerViewModel).FileList :
flValue as IFileListViewModel;
if (flvm == null)
{
return(ResultCommand.Error(new KeyNotFoundException(FileListKey)));
}
IEntryModel[] value = new IEntryModel[] { };
switch (AssignType)
{
case FileListAssignType.All:
value = flvm.ProcessedEntries.EntriesHelper.AllNonBindable
.Select(evm => evm.EntryModel).ToArray();
break;
case FileListAssignType.Selected:
value = flvm.Selection.SelectedItems.Select(evm => evm.EntryModel).ToArray();
break;
default:
return(ResultCommand.Error(new NotSupportedException("AssignType")));
}
return(ScriptCommands.Assign(DestinationKey, value, false, NextCommand));
}
public override IScriptCommand Execute(ParameterDic pm)
{
IExplorerViewModel evm = pm.GetValue <IExplorerViewModel>(ExplorerKey);
if (evm == null)
{
return(ResultCommand.Error(new KeyNotFoundException(ExplorerKey)));
}
ParameterDic startupParameters = new ParameterDic();
foreach (var key in VariableKeys.Split(','))
{
var val = pm.GetValue(key);
startupParameters.SetValue(key, val);
}
addStartupParameters(evm.Commands, startupParameters);
addStartupParameters(evm.FileList.Commands, startupParameters);
addStartupParameters(evm.DirectoryTree.Commands, startupParameters);
addStartupParameters(evm.Navigation.Commands, startupParameters);
addStartupParameters(evm.Breadcrumb.Commands, startupParameters);
return(NextCommand);
}
private bool parseEntryAndProfile(ParameterDic pm, string key, string profileKey,
out string[] entryPath, out IProfile profile)
{
object value = pm.GetValue(key);
if (value is string)
{
value = new string[] { value as string }
}
;
if (value is string[])
{
entryPath = value as string[];
profile = pm.GetValue <IProfile>(profileKey);
return(true);
}
if (value is IEntryModel)
{
value = new IEntryModel[] { value as IEntryModel }
}
;
if (value is IEntryModel[])
{
IEntryModel[] ems = value as IEntryModel[];
entryPath = ems.Select(em => em.FullPath).ToArray();
profile = ems.First().Profile;
return(true);
}
entryPath = null;
profile = null;
return(false);
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
IWindowManager wm = pm.GetValue <IWindowManager>(WindowManagerKey) ?? new WindowManager();
IEventAggregator events = pm.GetValue <IEventAggregator>(EventAggregatorKey) ?? new EventAggregator();
TabbedExplorerViewModel tevm = new TabbedExplorerViewModel(wm, events);
pm.SetValue(DestinationKey, tevm);
tevm.Initializer = new ScriptCommandInitializer()
{
StartupParameters = pm,
WindowManager = wm,
Events = events,
OnModelCreated = ScriptCommands.Run(OnModelCreatedKey),
OnViewAttached = ScriptCommands.Run(OnViewAttachedKey)
};
if (pm.HasValue(OnTabExplorerCreatedKey))
{
await tevm.Commands.ExecuteAsync(pm.GetValue <IScriptCommand>(OnTabExplorerCreatedKey));
}
tevm.OnTabExplorerAttachedKey = OnTabExplorerAttachedKey;
object enableTabsWhenOneTab = pm.GetValue("{EnableTabsWhenOneTab}");
tevm.EnableTabsWhenOneTab = !(enableTabsWhenOneTab is bool) || (bool)enableTabsWhenOneTab;
logger.Info(String.Format("Showing {0}", tevm));
wm.ShowWindow(tevm);
return(NextCommand);
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
string[] sourcePaths, destinationPaths;
IProfile sourceProfile, destinationProfile;
parseEntryAndProfile(pm, SourceEntryKey, SourceProfileKey, out sourcePaths, out sourceProfile);
if (!parseEntryAndProfile(pm, DestinationEntryKey, DestinationProfileKey, out destinationPaths, out destinationProfile))
{
logger.Error(String.Format("Failed to parse {0} or {1}", DestinationEntryKey, DestinationProfileKey));
return(NextCommand);
}
logger.Info(String.Format("({0}) {1} -> {2}", ChangeType, sourcePaths, destinationPaths));
if (ChangeType == ChangeType.Moved && sourceProfile != null && destinationProfile != null && sourcePaths != null)
{
if (sourceProfile != destinationProfile)
{
sourceProfile.Events.PublishOnCurrentThread(new EntryChangedEvent(ChangeType.Deleted, sourcePaths));
destinationProfile.Events.PublishOnCurrentThread(new EntryChangedEvent(ChangeType.Created, destinationPaths));
}
else
{
destinationProfile.Events.PublishOnCurrentThread(new EntryChangedEvent(destinationPaths.FirstOrDefault(), sourcePaths.FirstOrDefault()));
}
}
else
{
destinationProfile.Events.PublishOnCurrentThread(new EntryChangedEvent(ChangeType, destinationPaths));
}
return(NextCommand);
}
public override IScriptCommand Execute(ParameterDic pm)
{
string variable = pm.ReplaceVariableInsideBracketed(VariableKey);
print(variable);
return(NextCommand);
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
var evm = pm.GetValue <IExplorerViewModel>(ExplorerKey);
var dm = DirectoryEntryKey == null ? null :
(await pm.GetValueAsEntryModelArrayAsync(DirectoryEntryKey)).FirstOrDefault();
if (evm == null)
{
var events = pm.GetValue <IEventAggregator>(EventsKey);
if (events != null)
{
events.PublishOnUIThread(new DirectoryChangedEvent(this, dm, null));
}
else
{
return(ResultCommand.Error(new ArgumentNullException(ExplorerKey)));
}
}
else
{
await evm.GoAsync(dm);
}
logger.Info("Path = " + dm.FullPath);
return(NextCommand);
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
try
{
var srcProfile = _srcModel.Profile as IDiskProfile;
var destProfile = _destDirModel.Profile as IDiskProfile;
var progress = pm.ContainsKey("Progress") ? pm["Progress"] as IProgress <TransferProgress> : NullTransferProgress.Instance;
var destMapping = (_destDirModel.Profile as IDiskProfile).DiskIO.Mapper[_destDirModel];
var srcMapping = (_srcModel.Profile as IDiskProfile).DiskIO.Mapper[_srcModel];
string destName = PathFE.GetFileName(srcMapping.IOPath);
string destFullName = destProfile.Path.Combine(_destDirModel.FullPath, destName); //PathFE.Combine(destMapping.IOPath, destName);
if (_srcModel.IsDirectory)
{
Func <IEntryModel, bool> filter = em => !em.IsDirectory || (em is SzsRootModel);
Func <IEntryModel, bool> lookupFilter = em => em.IsDirectory && !(em is SzsRootModel);
return(WPFScriptCommands.List(_srcModel, filter, lookupFilter, true, ems =>
new SimpleScriptCommandAsync("BatchTransfer", pd => transferAsync(pm, ems, progress,
new NotifyChangedCommand(_destDirModel.Profile, destFullName,
_srcModel.Profile, _srcModel.FullPath, Defines.ChangeType.Changed)))));
}
else
{
return(IOScriptCommands.DiskTransfer(_srcModel, _destDirModel, _removeOriginal));
}
return(ResultCommand.NoError);
}
catch (Exception ex)
{
return(ResultCommand.Error(ex));
}
}
public void Test_MultiLevel_Variable_Names()
{
IParameterDic dic = new ParameterDic();
IParameterDic subDic1, subDic2;
int dictionaryCount, subDic1Count, subDic2Count,
property1Value, property3Value, property5Value;
dic.Set("{SubDic1.Property1}", 1);
dic.Set("{SubDic1.SubDic2.Property3}", 3);
dic.Set("{SubDic1.SubDic2.Property5}", 3);
dic.Add("{SubDic1.SubDic2.Property5}", 2);
subDic1 = dic.Get<ParameterDic>("{SubDic1}");
property1Value = dic.Get("{SubDic1.Property1}", -1);
subDic2 = dic.Get<ParameterDic>("{SubDic1.SubDic2}");
property3Value = dic.Get("{SubDic1.SubDic2.Property3}", -1);
property5Value = dic.Get("{SubDic1.SubDic2.Property5}", -1);
dictionaryCount = dic.List().Count();
subDic1Count = subDic1.List().Count();
subDic2Count = subDic2.List().Count();
Assert.AreEqual(1, dictionaryCount, "dictionaryCount");
Assert.IsNotNull(subDic1, "subDic1");
Assert.IsNotNull(subDic2, "subDic2");
Assert.AreEqual(2, subDic1Count, "subDic1Count");
Assert.AreEqual(2, subDic2Count, "subDic2Count");
Assert.AreEqual(1, property1Value, "property1Value");
Assert.AreEqual(3, property3Value, "property3Value");
Assert.AreEqual(5, property5Value, "property5Value");
}
private FrameworkElement findLogicalAncestor(ParameterDic pm, FrameworkElement sender)
{
switch (FindMethod)
{
case UIEventHub.FindMethodType.Name:
string name = pm.ReplaceVariableInsideBracketed(FindParameterKey) ?? "";
return(UITools.FindLogicalAncestor <FrameworkElement>(sender, ele => name.Equals(ele.Name)));
case UIEventHub.FindMethodType.Type:
string type = pm.ReplaceVariableInsideBracketed(FindParameterKey) ?? "";
return(UITools.FindLogicalAncestor <FrameworkElement>(sender, ele => ele.GetType().Name.Equals(type, StringComparison.CurrentCultureIgnoreCase)));
case UIEventHub.FindMethodType.Level:
int level = pm.GetValue <int>(FindParameterKey, -1);
if (level == -1)
{
return(null);
}
FrameworkElement current = sender;
for (int i = 0; i < level; i++)
{
if (current != null)
{
current = LogicalTreeHelper.GetParent(current) as FrameworkElement;
}
}
return(current);
default: throw new NotSupportedException(FindMethod.ToString());
}
}
public override async Task <IScriptCommand> ExecuteAsync(ParameterDic pm)
{
Func <IEntryModel, bool> filter;
if (pm.ContainsKey("Mask"))
{
string mask = pm["Mask"] as string;
filter = (em => _filter(em) && PathFE.MatchFileMask(em.Name, mask));
}
else
{
filter = _filter;
}
_lookupFilter = _lookupFilter ?? (em => em.IsDirectory);
bool refresh = pm.ContainsKey("Refresh") && (bool)pm["Refresh"];
List <IEntryModel> result = new List <IEntryModel>();
foreach (var directory in _directories)
{
result.AddRange(await listAsync(directory, pm.CancellationToken, filter, _lookupFilter, refresh));
}
return(_nextCommandFunc(result.ToArray()));
}
