private void OnDrawCompleted(MapViewEventArgs e)
{
IReadOnlyList <Layer> layers = e.MapView.Map.GetLayersAsFlattenedList();
foreach (string name in _registry.GetNames())
{
// todo daro: need a more robust layer identifier
// check first whether work list layer is in TOC
FeatureLayer workListLayer = layers.OfType <FeatureLayer>()
.FirstOrDefault(
layer => string.Equals(layer.Name, name));
if (workListLayer == null)
{
continue;
}
IWorkList workList = _registry.Get(name);
Assert.NotNull(workList);
// safety check, a new work list is already added
if (_layerByWorkList.ContainsKey(workList))
{
continue;
}
_layerByWorkList.Add(workList, workListLayer);
WireEvents(workList);
// todo daro: maybe we need a dictionary of synchronizers
_synchronizer = new EditEventsRowCacheSynchronizer(workList);
}
}
public override PluginTableTemplate OpenTable([NotNull] string name)
{
Assert.ArgumentNotNull(name, nameof(name));
Assert.ArgumentCondition(_tableNames.Contains(name), $"Unknown table name {name}");
// The given name is one of those returned by GetTableNames()
_msg.Debug($"Open table '{name}'");
ParseLayer(name, out string listName);
_workList = WorkListRegistry.Instance.Get(name);
if (_workList != null)
{
return(new WorkItemTable(_workList, listName));
}
var message = $"Cannot find data source of work list: {name}";
_msg.Error(message);
// The exception is not going to crash Pro. It results in a broken
// data source of the work list layer.
throw new ArgumentException(message);
}
protected void RunAnalysis()
{
switch (_worklistMethodName)
{
case "FIFOWorklist":
_worklist = new FIFOWorklist(_flow);
break;
case "LIFOWorklist":
_worklist = new LIFOWorklist(_flow);
break;
case "ChaoticIteration":
_worklist = new ChaoticIteration(_flow.Shuffle(3));
break;
case "RoundRobin":
DepthFirstSpanningTree dfst = new DepthFirstSpanningTree(new FlowGraph(_program));
_worklist = new RoundRobin(_flow, dfst.GetRP());
break;
default:
break;
}
WorkThroughWorklist(_worklist);
var labels = FlowUtil.Labels(_blocks);
foreach (var lab in labels)
{
var edges = _flow.Where(x => x.Dest == lab);
_analysisFilled[lab] = TransferFunctions(lab);
}
}
public async Task CreateWorkListAsync([NotNull] WorkEnvironmentBase environment)
{
try
{
// is this worklist already loaded?
if (_registry.Exists(environment.GetWorklistId()))
{
_msg.Debug("Worklist is already loaded");
return;
}
IWorkList workList = await environment.CreateWorkListAsync(this);
RegisterObserver(new WorkListObserver());
// wiring work list events, etc. is done in OnDrawComplete
// register work list before creating the layer
_registry.Add(workList);
foreach (var observer in _observers)
{
observer.WorkListAdded(workList);
}
CreateLayer(environment, workList.Name);
}
catch (Exception e)
{
_msg.Error("Create work list failed", e);
}
}
public WorkListObserver(IWorkList worklist, WorklistItem item)
{
Assert.ArgumentNotNull(worklist, nameof(worklist));
_worklist = worklist;
_item = item;
}
public void WorkListAdded(IWorkList workList)
{
if (WorkList != null)
{
return;
}
RunOnUIThread(() =>
{
var tuple = WorkListViewFactory.CreateView(workList);
_view = tuple.Item1;
ViewModel = tuple.Item2;
WorkList = workList;
//if (workList is SelectionWorkList)
//{
// _viewModel = new SelectionWorkListVm(workList);
// _view = new WorkListView(_viewModel as SelectionWorkListVm)
// {Title = workList.Name};
// _workList = workList;
//}
//if (workList is IssueWorkList)
//{
// _viewModel = new IssueWorkListVm(workList);
// _view = new IssueWorkListView(_viewModel as IssueWorkListVm)
// {Title = workList.Name};
// _workList = workList;
//}
});
}
private void OnProjectItemsChanged(ProjectItemsChangedEventArgs e)
{
if (e.ProjectItemsCollection != null)
{
foreach (var item in e.ProjectItemsCollection.OfType <WorklistItem>())
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Replace:
Assert.NotNullOrEmpty(item.WorklistName);
Assert.True(_registry.Exists(item.WorklistName),
$"Cannot find work list {item.WorklistName} in registry");
IWorkList workList = _registry.Get(item.WorklistName);
Assert.NotNull(workList);
workList.Repository.UpdateStateRepository(item.Path);
break;
case NotifyCollectionChangedAction.Add:
case NotifyCollectionChangedAction.Remove:
case NotifyCollectionChangedAction.Move:
case NotifyCollectionChangedAction.Reset:
throw new NotImplementedException();
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
private static bool EnsureWorkListsMatch(IWorkList workList, IWorkList compareWorkList)
{
if (workList != null && compareWorkList != null)
{
return(workList.Name == compareWorkList.Name);
}
return(false);
}
public bool Remove(IWorkList workList)
{
if (workList == null)
{
throw new ArgumentNullException(nameof(workList));
}
return(Remove(workList.Name));
}
//[CanBeNull]
//private IWorkListObserver GetObserverByWorklistName(string name)
//{
//}
public void ShowView([NotNull] string uniqueName)
{
IWorkList list = _registry.Get(uniqueName);
foreach (IWorkListObserver observer in _observers)
{
observer.Show(list);
}
}
public void Can_create_worklist_with_SDE_workspace_from_definition_file()
{
XmlWorkListDefinition definition = XmlWorkItemStateRepository.Import(_path);
IWorkList worklist = WorkListUtils.Create(definition);
Assert.NotNull(worklist);
Assert.AreEqual(2, worklist.Count());
}
private int WorkThroughWorklist(IWorkList _workList)
{
int numberOfOperations = 0;
List <(int, string)> analysisCircleList = new List <(int, string)>();
foreach (int lab in FlowUtil.Labels(_blocks))
{
analysisCircleList.Add((lab, _analysisCircle[lab].ToString()));
public void Show(IWorkList workList)
{
if (ViewModel == null)
{
return;
}
if (EnsureWorkListsMatch(workList, ViewModel.CurrentWorkList))
{
RunOnUIThread(() => _view?.Show());
}
}
public bool TryAdd(IWorkList worklist)
{
lock (_registryLock)
{
if (_map.ContainsKey(worklist.Name))
{
return(false);
}
}
Add(worklist);
return(true);
}
public void WorkListModified(IWorkList workList)
{
if (ViewModel == null)
{
return;
}
if (!EnsureWorkListsMatch(workList, ViewModel.CurrentWorkList))
{
return;
}
WorkList = workList;
ViewModel.CurrentWorkList = workList;
}
private void Unload([NotNull] IWorkList workList)
{
if (_viewsByWorklistName.ContainsKey(workList.Name))
{
_viewsByWorklistName[workList.Name].Close();
_viewsByWorklistName.Remove(workList.Name);
}
// ensure folder exists before commit
FileSystemUtils.EnsureFolderExists(GetLocalWorklistsFolder());
UnwireEvents(workList);
_layersByWorklistName.Remove(workList.Name);
}
// todo daro: move to OnMapViewInitialized?
private void OnDrawCompleted(MapViewEventArgs e)
{
string uri = null;
foreach (string name in _registry.GetNames()
.Where(name => _uriByWorklistName.TryGetValue(
name, out uri)))
{
// Can be null because it's from module settings and those cannot be deleted but only
// set to null.
if (string.IsNullOrEmpty(uri))
{
continue;
}
var worklistLayer = e.MapView.Map.FindLayer(uri) as FeatureLayer;
// todo daro Read the custom project settings and the URI of the created work list layers.
// Don't do layer name comparison.
// Stop giving the work list layer the name of the work list. The map (work list uri <> work list name)
// is managed with the custom project settings.
// For the moment the work list layers data source remains the work list file name. It feels the right way, e.g.
// in ArcGIS the data source is broken too if its name changes.
//LayerUtils.GetLayer("work list uri");
if (worklistLayer == null)
{
continue;
}
IWorkList workList = _registry.Get(name);
Assert.NotNull(workList);
// safety check, a new work list is already added
if (_layersByWorklistName.ContainsKey(workList.Name))
{
continue;
}
_layersByWorklistName.Add(workList.Name, worklistLayer);
WireEvents(workList);
// todo daro: maybe we need a dictionary of synchronizers
_synchronizer = new EditEventsRowCacheSynchronizer(workList);
}
}
public static ProWindow CreateView([NotNull] IWorkList workList)
{
Assert.ArgumentNotNull(workList, nameof(workList));
switch (workList)
{
case SelectionWorkList _:
return(new SelectionWorkListView(new SelectionWorkListVm(workList)));
case IssueWorkList _:
return(new IssueWorkListView(new IssueWorkListVm(workList)));
default:
throw new ArgumentOutOfRangeException(
$"Unkown work list type {workList.GetType()}");
}
}
public void Add(IWorkList workList)
{
if (workList == null)
{
throw new ArgumentNullException(nameof(workList));
}
lock (_registryLock)
{
string name = workList.Name;
if (_map.ContainsKey(name))
{
throw new InvalidOperationException(
$"WorkList by that name already registered: '{name}'");
}
_map.Add(name, new WorkListFactory(workList));
}
}
public static Tuple <ProWindow, WorkListViewModelBase> CreateView(IWorkList workList)
{
if (workList is SelectionWorkList)
{
var vm = new SelectionWorkListVm(workList);
var view = new WorkListView(vm as SelectionWorkListVm);
return(new Tuple <ProWindow, WorkListViewModelBase>(view, vm));
}
if (workList is IssueWorkList)
{
var vm = new IssueWorkListVm(workList);
var view = new IssueWorkListView(vm as IssueWorkListVm);
return(new Tuple <ProWindow, WorkListViewModelBase>(view, vm));
}
else
{
return(new Tuple <ProWindow, WorkListViewModelBase>(null, null));
}
}
public void WorkListRemoved(IWorkList workList)
{
if (ViewModel == null)
{
return;
}
if (!EnsureWorkListsMatch(workList, ViewModel.CurrentWorkList))
{
return;
}
RunOnUIThread(() =>
{
_view?.Close();
WorkList = null;
ViewModel = null;
_view = null;
});
}
public async Task CreateWorkListAsync([NotNull] WorkEnvironmentBase environment,
[NotNull] string name)
{
Assert.ArgumentNotNull(environment, nameof(environment));
Assert.ArgumentNotNullOrEmpty(name, nameof(name));
Assert.False(_registry.Exists(name), $"work list {name} already exists");
Uri uri = WorkListUtils.GetDatasource(GetProject().HomeFolderPath, name,
environment.FileSuffix);
IWorkList worklist = await environment.CreateWorkListAsync(uri.LocalPath, name);
if (worklist == null)
{
return;
}
// after creation go to nearest item
worklist.GoNearest(MapView.Active.Extent);
// Commit writes work list definition to disk.
// Necessary for adding project item.
worklist.Commit();
// wiring work list events, etc. is done in OnDrawComplete
// register work list before creating the layer
_registry.TryAdd(worklist);
Assert.True(ProjectItemUtils.TryAdd(uri.LocalPath, out WorklistItem item),
$"cannot add item {worklist.Name}");
if (!_viewsByWorklistName.ContainsKey(worklist.Name))
{
_viewsByWorklistName.Add(worklist.Name, new WorkListObserver(worklist, item));
}
FeatureLayer layer = AddLayer(uri, name, worklist.DisplayName);
LayerUtils.ApplyRenderer(layer, environment.GetLayerDocument());
}
public WorkItemTable(IWorkList workList, string tableName)
{
_workList = workList ?? throw new ArgumentNullException(nameof(workList));
_tableName = tableName ?? throw new ArgumentNullException(nameof(tableName));
_fields = new ReadOnlyCollection <PluginField>(GetSchema());
}
public IssueWorkListVm(IWorkList workList)
{
CurrentWorkList = workList;
CurrentWorkItem = new IssueWorkItemVm(CurrentWorkList.Current as IssueItem);
}
public SelectionWorkListVm(IWorkList workList)
{
CurrentWorkList = workList;
CurrentWorkItem = new SelectionWorkItemVm(CurrentWorkList.Current as SelectionItem);
}
public override void Close()
{
_workList = null;
}
public WorkListFactory(IWorkList workList)
{
WorkList = workList;
}
private void WireEvents(IWorkList workList)
{
workList.WorkListChanged += WorkList_WorkListChanged;
}
private void UnwireEvents(IWorkList workList)
{
workList.WorkListChanged -= WorkList_WorkListChanged;
}
