protected virtual void itemsListView_DragDrop(object sender, DragEventArgs e)
{
if (e.Effect != DragDropEffects.None)
{
if (e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat) is T)
{
T item = (T)e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat);
Content.Add(e.Effect.HasFlag(DragDropEffects.Copy) ? (T)item.Clone() : item);
}
else if (e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat) is IEnumerable)
{
IEnumerable <T> items = ((IEnumerable)e.Data.GetData(HeuristicLab.Common.Constants.DragDropDataFormat)).Cast <T>();
if (e.Effect.HasFlag(DragDropEffects.Copy))
{
Cloner cloner = new Cloner();
items = items.Select(x => cloner.Clone(x));
}
if (ItemCollection != null)
{
ItemCollection.AddRange(items);
}
else
{
foreach (T item in items)
{
Content.Add(item);
}
}
}
}
}
public void ItemCollectionGetRange()
{
tlog.Debug(tag, $"ItemCollectionGetRange START");
using (ItemCollection itemCollection = new ItemCollection(5))
{
var testingTarget = new ItemCollection();
Assert.IsNotNull(testingTarget, "Should be not null!");
Assert.IsInstanceOf <ItemCollection>(testingTarget, "Should be an Instance of ItemCollection!");
testingTarget.AddRange(itemCollection);
try
{
var result = testingTarget.GetRange(0, 0);
Assert.IsInstanceOf <ItemCollection>(result, "Should be an Instance of ItemCollection!");
}
catch (Exception e)
{
tlog.Debug(tag, e.Message.ToString());
Assert.Fail("Caught Exception: Failed!");
}
testingTarget.Dispose();
}
tlog.Debug(tag, $"ItemCollectionGetRange END (OK)");
}
public override void Start()
{
this._crudActionModelExtension.Add.SetClickHandler(new ClickHandlerDelegate(this.Add));
this._crudActionModelExtension.Edit.SetClickHandler(new ClickHandlerDelegate(this.Edit));
this._crudActionModelExtension.Delete.SetClickHandler(new ClickHandlerDelegate(this.DeleteDicomPrinter));
this._crudActionModelExtension.Click.SetClickHandler(new ClickHandlerDelegate(this.VerificationDicomPrinter));
this._crudActionModelExtension.Edit.Enabled = false;
this._crudActionModelExtension.Delete.Enabled = false;
this._crudActionModelExtension.Click.Enabled = false;
ItemCollection <Checkable <DicomPrinter> > items = this._dicomPrinterTable.Items;
if (_converter == null)
{
_converter = new Converter <DicomPrinter, Checkable <DicomPrinter> >(DicomPrinterSummaryComponent.ToCheckable);
}
List <Checkable <DicomPrinter> > enumerable = CollectionUtils.Map <DicomPrinter, Checkable <DicomPrinter> >(DicomPrintSettings.LocalDicomPrinterCollection, _converter);
items.AddRange(enumerable);
this._dicomPrinterTable.SelectDicomPrinter(DicomPrintSettings.Default.DefaultPrinterName);
this._dicomPrinterTable.PropertyChanged += new EventHandler <EventArgs>(this.LocalPropertyChanged);
if (items.Count > 0)
{
this.SelectedItem = new Selection(this._dicomPrinterTable.Items[0]);
}
base.Start();
}
public override void Start()
{
this._dicomPrinterConfigurationEditorComponent = new DicomPrinterConfigurationEditorComponent();
this._childComponentHost = new ChildComponentHost(base.Host, this._dicomPrinterConfigurationEditorComponent);
this._dicomPrinterConfigurationEditorComponent.PropertyChanged += new PropertyChangedEventHandler(this.LocalPropertyChanged);
this._dicomPrinterConfigurationEditorComponent.Validation.Add(new ValidationRule("HaveModalityPixelSpacing", new ValidationRule.ValidationDelegate(this.GetValidtionResult)));
ItemCollection <Checkable <DicomPrinter> > items = this._dicomPrinterTable.Items;
if (Convert == null)
{
Convert = new Converter <DicomPrinter, Checkable <DicomPrinter> >(DciomPrintApplicationComponent.WrapperDicomPrinterToCheckable);
}
items.AddRange(CollectionUtils.Map <DicomPrinter, Checkable <DicomPrinter> >(DicomPrintSettings.LocalDicomPrinterCollection, Convert));
this._dicomPrinterTable.SelectDicomPrinter(DicomPrintSettings.LocalDefaultPrinterName);
if (items.Count > 0)
{
if (this._dicomPrinterTable.SelectFirstCheckedCheckableDicomPrinter == null)
{
this.SelectedItem = new Selection(items[0]);
}
}
if (this._dicomPrinter == null)
{
this._dicomPrinterConfigurationEditorComponent.Configuration = new DicomPrinter.Configuration();
}
else
{
this._dicomPrinterConfigurationEditorComponent.Configuration = this._dicomPrinter.Item.Config;
}
base.Start();
this._childComponentHost.StartComponent();
}
public ClassificationEnsembleSolution(IEnumerable <IClassificationModel> models, IClassificationProblemData problemData, IEnumerable <IntRange> trainingPartitions, IEnumerable <IntRange> testPartitions)
: base(new ClassificationEnsembleModel(Enumerable.Empty <IClassificationModel>()), new ClassificationEnsembleProblemData(problemData))
{
this.trainingPartitions = new Dictionary <IClassificationModel, IntRange>();
this.testPartitions = new Dictionary <IClassificationModel, IntRange>();
this.classificationSolutions = new ItemCollection <IClassificationSolution>();
List <IClassificationSolution> solutions = new List <IClassificationSolution>();
var modelEnumerator = models.GetEnumerator();
var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
var testPartitionEnumerator = testPartitions.GetEnumerator();
while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext())
{
var p = (IClassificationProblemData)problemData.Clone();
p.TrainingPartition.Start = trainingPartitionEnumerator.Current.Start;
p.TrainingPartition.End = trainingPartitionEnumerator.Current.End;
p.TestPartition.Start = testPartitionEnumerator.Current.Start;
p.TestPartition.End = testPartitionEnumerator.Current.End;
solutions.Add(modelEnumerator.Current.CreateClassificationSolution(p));
}
if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext())
{
throw new ArgumentException();
}
trainingEvaluationCache = new Dictionary <int, double>(problemData.TrainingIndices.Count());
testEvaluationCache = new Dictionary <int, double>(problemData.TestIndices.Count());
RegisterClassificationSolutionsEventHandler();
classificationSolutions.AddRange(solutions);
}
public static ItemCollection ToItemCollection(this IEnumerable <Item> Items)
{
var ic = new ItemCollection();
ic.AddRange(Items);
return(ic);
}
public void AddClassificationSolutions(IEnumerable <IClassificationSolution> solutions)
{
classificationSolutions.AddRange(solutions);
trainingEvaluationCache.Clear();
testEvaluationCache.Clear();
evaluationCache.Clear();
}
public void AddRegressionSolutions(IEnumerable <IRegressionSolution> solutions)
{
regressionSolutions.AddRange(solutions);
trainingEvaluationCache.Clear();
testEvaluationCache.Clear();
evaluationCache.Clear();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="binding">The tree item binding.</param>
/// <param name="items">The set of items that are initially contained in this tree.</param>
public Tree(ITreeItemBinding binding, IEnumerable <TItem> items)
{
_binding = binding;
_items = new ItemCollection <TItem>();
if (items != null)
{
_items.AddRange(items);
}
}
public ItemCollection GetValues()
{
var result = new ItemCollection();
result.AddRange(VirtualPieses.CreateVirtualPieseInfoArray()
.Select(o => new Item()
{
DisplayName = o.Caption, Value = o
}));
return(result);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
JsonSerializer serializer)
{
var collection = new List <Item>();
var itemsCollection = new ItemCollection();
serializer.Populate(reader, collection);
itemsCollection.AddRange(collection);
return(itemsCollection);
}
public void Test_FindInsertionPoint_non_existant_item()
{
var items = new ItemCollection<Foo>();
items.AddRange(new []{ new Foo("b"), new Foo("b"), new Foo("d")});
var comparison = new Comparison<Foo>((x, y) => string.CompareOrdinal(x.Name, y.Name));
Assert.AreEqual(0, items.FindInsertionPoint(new Foo("a"), comparison));
Assert.AreEqual(2, items.FindInsertionPoint(new Foo("c"), comparison));
Assert.AreEqual(3, items.FindInsertionPoint(new Foo("e"), comparison));
}
public void Test_FindInsertionPoint_non_existant_item()
{
var items = new ItemCollection <Foo>();
items.AddRange(new [] { new Foo("b"), new Foo("b"), new Foo("d") });
var comparison = new Comparison <Foo>((x, y) => string.CompareOrdinal(x.Name, y.Name));
Assert.AreEqual(0, items.FindInsertionPoint(new Foo("a"), comparison));
Assert.AreEqual(2, items.FindInsertionPoint(new Foo("c"), comparison));
Assert.AreEqual(3, items.FindInsertionPoint(new Foo("e"), comparison));
}
public void Test_FindInsertionPoint_non_existing_item()
{
var items = new ItemCollection<Foo>();
items.AddRange(new[] { new Foo("b"), new Foo("b"), new Foo("d") });
var comparison = new Comparison<Foo>((x, y) => string.CompareOrdinal(x.Name, y.Name));
var b = items.FindInsertionPoint(new Foo("b"), comparison);
Assert.IsTrue(b == 0 || b == 1);
var d = items.FindInsertionPoint(new Foo("d"), comparison);
Assert.IsTrue(d == 2);
}
public ActionResult Save(Bam.Net.Data.Tests.Item[] values)
{
try
{
ItemCollection saver = new ItemCollection();
saver.AddRange(values);
saver.Save();
return(Json(new { Success = true, Message = "", Dao = "" }));
}
catch (Exception ex)
{
return(GetErrorResult(ex));
}
}
public ItemCollection GetValues()
{
var items = new ItemCollection();
var interfaces = from @interface in NetworkInterface.GetAllNetworkInterfaces()
select new Xceed.Wpf.Toolkit.PropertyGrid.Attributes.Item()
{
DisplayName = @interface.Name,
Value = @interface.Id
};
items.AddRange(interfaces);
return(items);
}
public ItemCollection GetValues()
{
var items = ModelViewerPlugin.GetExportFormats()
.Select(id => new Item
{
Value = id,
DisplayName = ModelViewerPlugin.GetFormatDescription(id)
})
.OrderBy(i => i.DisplayName);
var result = new ItemCollection();
result.AddRange(items);
return(result);
}
public void Test_FindInsertionPoint_non_existing_item()
{
var items = new ItemCollection <Foo>();
items.AddRange(new[] { new Foo("b"), new Foo("b"), new Foo("d") });
var comparison = new Comparison <Foo>((x, y) => string.CompareOrdinal(x.Name, y.Name));
var b = items.FindInsertionPoint(new Foo("b"), comparison);
Assert.IsTrue(b == 0 || b == 1);
var d = items.FindInsertionPoint(new Foo("d"), comparison);
Assert.IsTrue(d == 2);
}
ItemCollection IItemsSource.GetValues()
{
var result = new ItemCollection();
result.AddRange(
LogicManager.Instance.Logics.Select(
info => new Item
{
DisplayName = string.Format(
CultureInfo.InvariantCulture,
"{0} ({1})",
info.Caption,
info.Type.Name),
Value = info
}));
return(result);
}
public void Test_sorting_update_nonsort_property_retains_order()
{
var item1 = new ActivityMonitorComponent.WorkItem(new WorkItemData {
Identifier = 1, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal
});
var item2 = new ActivityMonitorComponent.WorkItem(new WorkItemData {
Identifier = 2, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal
});
var item3 = new ActivityMonitorComponent.WorkItem(new WorkItemData {
Identifier = 3, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal
});
var item4 = new ActivityMonitorComponent.WorkItem(new WorkItemData {
Identifier = 4, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal
});
var item5 = new ActivityMonitorComponent.WorkItem(new WorkItemData {
Identifier = 5, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal
});
var items = new ItemCollection <ActivityMonitorComponent.WorkItem>();
items.AddRange(new[] { item1, item2, item3, item4, item5 });
// the idea here is that if an item is updated, but the sorty property (Status) has not changed,
// then the item does not move around in the list, but is updated in place
var manager = new ActivityMonitorComponent.WorkItemUpdateManager(items, NoFilter, () => { });
// item 1 Priority changes - should not cause a change in list order
var x = new ActivityMonitorComponent.WorkItem(new WorkItemData {
Identifier = 1, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Stat
});
manager.Update(new[] { x }, StatusComparison);
Assert.IsTrue(items.SequenceEqual(new[] { item1, item2, item3, item4, item5 }));
// item 4 Priority changes - should not cause a change in list order
var y = new ActivityMonitorComponent.WorkItem(new WorkItemData {
Identifier = 4, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.High
});
manager.Update(new[] { y }, StatusComparison);
Assert.IsTrue(items.SequenceEqual(new[] { item1, item2, item3, item4, item5 }));
}
public void Refresh()
{
OnRefreshing();
platforms = new OKBItemCollection <Platform>();
algorithmClasses = new OKBItemCollection <AlgorithmClass>();
algorithms = new OKBItemCollection <Algorithm>();
problemClasses = new OKBItemCollection <ProblemClass>();
problems = new OKBItemCollection <Problem>();
try {
platforms.AddRange(CallAdministrationService <List <Platform> >(s => s.GetPlatforms()).OrderBy(x => x.Name));
algorithmClasses.AddRange(CallAdministrationService <List <AlgorithmClass> >(s => s.GetAlgorithmClasses()).OrderBy(x => x.Name));
algorithms.AddRange(CallAdministrationService <List <Algorithm> >(s => s.GetAlgorithms()).OrderBy(x => x.Name));
problemClasses.AddRange(CallAdministrationService <List <ProblemClass> >(s => s.GetProblemClasses()).OrderBy(x => x.Name));
problems.AddRange(CallAdministrationService <List <Problem> >(s => s.GetProblems()).OrderBy(x => x.Name));
}
finally {
OnRefreshed();
}
}
public void AddRegressionSolutions(IEnumerable <IRegressionSolution> solutions)
{
regressionSolutions.AddRange(solutions);
}
public ClassificationEnsembleSolution(IEnumerable<IClassificationModel> models, IClassificationProblemData problemData, IEnumerable<IntRange> trainingPartitions, IEnumerable<IntRange> testPartitions)
: base(new ClassificationEnsembleModel(Enumerable.Empty<IClassificationModel>()), new ClassificationEnsembleProblemData(problemData)) {
this.trainingPartitions = new Dictionary<IClassificationModel, IntRange>();
this.testPartitions = new Dictionary<IClassificationModel, IntRange>();
this.classificationSolutions = new ItemCollection<IClassificationSolution>();
List<IClassificationSolution> solutions = new List<IClassificationSolution>();
var modelEnumerator = models.GetEnumerator();
var trainingPartitionEnumerator = trainingPartitions.GetEnumerator();
var testPartitionEnumerator = testPartitions.GetEnumerator();
while (modelEnumerator.MoveNext() & trainingPartitionEnumerator.MoveNext() & testPartitionEnumerator.MoveNext()) {
var p = (IClassificationProblemData)problemData.Clone();
p.TrainingPartition.Start = trainingPartitionEnumerator.Current.Start;
p.TrainingPartition.End = trainingPartitionEnumerator.Current.End;
p.TestPartition.Start = testPartitionEnumerator.Current.Start;
p.TestPartition.End = testPartitionEnumerator.Current.End;
solutions.Add(modelEnumerator.Current.CreateClassificationSolution(p));
}
if (modelEnumerator.MoveNext() | trainingPartitionEnumerator.MoveNext() | testPartitionEnumerator.MoveNext()) {
throw new ArgumentException();
}
trainingEvaluationCache = new Dictionary<int, double>(problemData.TrainingIndices.Count());
testEvaluationCache = new Dictionary<int, double>(problemData.TestIndices.Count());
RegisterClassificationSolutionsEventHandler();
classificationSolutions.AddRange(solutions);
}
public bool Update(IList <WorkItem> items, Comparison <WorkItem> sortComparison)
{
// if we're dealing with a batch (e.g. via Refresh), we need to do things differently
// than for a few items
var isBatch = items.Count > 10;
var batchAddList = new List <WorkItem>();
foreach (var item in items)
{
var index = _items.FindIndex(w => w.Id == item.Id);
if (index > -1)
{
// the item is currently in the list
// if the item is marked deleted, or if it no longer meets the filter criteria, remove it
// otherwise update it
if (item.Status == WorkItemStatusEnum.Deleted || item.Status == WorkItemStatusEnum.DeleteInProgress || !Include(item))
{
_items.RemoveAt(index);
}
else
{
UpdateItem(item, index, sortComparison, isBatch);
}
}
else
{
// the item is not currently in the list
// if not deleted and it meets the filter criteria, add it
if (item.Status != WorkItemStatusEnum.Deleted && item.Status != WorkItemStatusEnum.DeleteInProgress && Include(item))
{
if (isBatch)
{
batchAddList.Add(item);
}
else
{
AddItem(item, sortComparison);
}
}
}
var failureCount = _failures.Count;
if (item.Status != WorkItemStatusEnum.Failed) //remove anything that's not failed, which includes restarted items.
{
_failures.Remove(item.Id);
}
else
{
_failures[item.Id] = item;
}
if (_failures.Count != failureCount)
{
_failedItemCountChanged();
}
}
if (isBatch && batchAddList.Count > 0)
{
_items.AddRange(batchAddList);
}
// return a value indicating whether a sort is required
return(isBatch);
}
public void Test_sorting_update_nonsort_property_retains_order()
{
var item1 = new ActivityMonitorComponent.WorkItem(new WorkItemData { Identifier = 1, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal });
var item2 = new ActivityMonitorComponent.WorkItem(new WorkItemData { Identifier = 2, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal });
var item3 = new ActivityMonitorComponent.WorkItem(new WorkItemData { Identifier = 3, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal });
var item4 = new ActivityMonitorComponent.WorkItem(new WorkItemData { Identifier = 4, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal });
var item5 = new ActivityMonitorComponent.WorkItem(new WorkItemData { Identifier = 5, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Normal });
var items = new ItemCollection<ActivityMonitorComponent.WorkItem>();
items.AddRange(new[] { item1, item2, item3, item4, item5 });
// the idea here is that if an item is updated, but the sorty property (Status) has not changed,
// then the item does not move around in the list, but is updated in place
var manager = new ActivityMonitorComponent.WorkItemUpdateManager(items, NoFilter, () => { });
// item 1 Priority changes - should not cause a change in list order
var x = new ActivityMonitorComponent.WorkItem(new WorkItemData { Identifier = 1, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.Stat});
manager.Update(new[] { x }, StatusComparison);
Assert.IsTrue(items.SequenceEqual(new[] { item1, item2, item3, item4, item5 }));
// item 4 Priority changes - should not cause a change in list order
var y = new ActivityMonitorComponent.WorkItem(new WorkItemData { Identifier = 4, Status = WorkItemStatusEnum.Pending, Priority = WorkItemPriorityEnum.High});
manager.Update(new[] { y }, StatusComparison);
Assert.IsTrue(items.SequenceEqual(new[] { item1, item2, item3, item4, item5 }));
}