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; }