public void ResourcesChangedUpdatesResources()
{
var mockProperty = new Mock <IPropertyInfo> ();
mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonBrush));
var mockEditor = new MockObjectEditor(mockProperty.Object);
var resource1 = new Resource("first");
var resources = new List <Resource> {
resource1
};
var provider = new Mock <IResourceProvider>();
provider.Setup(p => p.GetResourceSourcesAsync(It.IsAny <object> ())).ReturnsAsync(new[] { MockResourceProvider.SystemResourcesSource });
provider.Setup(p => p.GetResourcesAsync(It.IsAny <object> (), mockProperty.Object, CancellationToken.None)).ReturnsAsync(resources);
var vm = new BrushPropertyViewModel(new TargetPlatform(new MockEditorProvider(), provider.Object), mockProperty.Object, new [] { mockEditor });
Assume.That(vm.ResourceSelector.Resources, Contains.Item(resource1));
var resource2 = new Resource("second");
resources.Add(resource2);
provider.Raise(rp => rp.ResourcesChanged += null, new ResourcesChangedEventArgs());
Assert.That(vm.ResourceSelector.Resources, Contains.Item(resource1));
Assert.That(vm.ResourceSelector.Resources, Contains.Item(resource2));
}
public async Task ResourceBrushMatchesMaterialStaysResource()
{
var platform = new TargetPlatform(new MockEditorProvider())
{
SupportsMaterialDesign = true
};
var mockProperty = new Mock <IPropertyInfo> ();
mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonSolidBrush));
var mockEditor = new MockObjectEditor(mockProperty.Object);
var provider = new MockResourceProvider();
var resources = await provider.GetResourcesAsync(mockEditor.Target, mockProperty.Object, CancellationToken.None);
var resource = resources.OfType <Resource <CommonSolidBrush> > ().First(r => r.Value == new CommonSolidBrush(0, 0, 0));
await mockEditor.SetValueAsync(mockProperty.Object, new ValueInfo <CommonSolidBrush> {
Source = ValueSource.Resource,
Value = resource.Value,
SourceDescriptor = resource
});
var vm = new BrushPropertyViewModel(platform, mockProperty.Object, new[] { mockEditor });
Assume.That(vm.ValueSource, Is.EqualTo(ValueSource.Resource));
Assert.That(vm.SelectedBrushType, Is.EqualTo(CommonBrushType.Resource));
}
public void ChangingEditorsUpdatesResources()
{
var mockProperty = new Mock <IPropertyInfo> ();
mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonBrush));
var mockEditor = new MockObjectEditor(mockProperty.Object);
var vm = new BrushPropertyViewModel(new TargetPlatform(new MockEditorProvider(), new MockResourceProvider()), mockProperty.Object, new [] { mockEditor });
var changed = false;
vm.PropertyChanged += (s, e) => {
if (e.PropertyName == nameof(BrushPropertyViewModel.ResourceSelector))
{
changed = true;
}
};
var rs1 = vm.ResourceSelector;
vm.Editors.Add(new MockObjectEditor());
var rs2 = vm.ResourceSelector;
Assert.IsTrue(changed);
Assert.AreNotEqual(rs1, rs2);
}
public void UpdatingHueOnSaturatedColorsCausesColorToChange()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
var blue = new CommonColor(20, 20, 255);
vm.Value = new CommonSolidBrush(blue);
var colorChanged = false;
var hueColorChanged = false;
var shadeChanged = false;
vm.Solid.PropertyChanged += (s, e) => {
switch (e.PropertyName)
{
case nameof(SolidBrushViewModel.Color):
colorChanged = true;
break;
case nameof(SolidBrushViewModel.HueColor):
hueColorChanged = true;
break;
case nameof(SolidBrushViewModel.Shade):
shadeChanged = true;
break;
}
};
vm.Solid.HueColor = new CommonColor(255, 0, 0);
Assert.IsTrue(colorChanged);
Assert.IsTrue(hueColorChanged);
Assert.IsFalse(shadeChanged);
}
public void UpdatingHueOnGreyDoesntCauseColorToChange()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
var grey = new CommonColor(20, 20, 20);
vm.Value = new CommonSolidBrush(grey);
var colorChanged = false;
var hueColorChanged = false;
var shadeChanged = false;
vm.Solid.PropertyChanged += (s, e) => {
switch (e.PropertyName)
{
case nameof(SolidBrushViewModel.Color):
colorChanged = true;
break;
case nameof(SolidBrushViewModel.HueColor):
hueColorChanged = true;
break;
case nameof(SolidBrushViewModel.Shade):
shadeChanged = true;
break;
}
};
vm.Solid.HueColor = new CommonColor(0, 0, 255);
Assert.IsFalse(colorChanged);
Assert.AreEqual(grey, vm.Solid.Color);
Assert.IsTrue(hueColorChanged);
Assert.IsFalse(shadeChanged);
}
public void ValueChangesTriggerPropertyChanges()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
var colorChanged = false;
var colorNameChanged = false;
var alphaChanged = false;
var accentChanged = false;
var normalChanged = false;
var accentScaleChanged = false;
var normalScaleChanged = false;
vm.MaterialDesign.PropertyChanged += (s, e) => {
switch (e.PropertyName)
{
case nameof(MaterialDesignColorViewModel.Color):
colorChanged = true;
break;
case nameof(MaterialDesignColorViewModel.ColorName):
colorNameChanged = true;
break;
case nameof(MaterialDesignColorViewModel.Alpha):
alphaChanged = true;
break;
case nameof(MaterialDesignColorViewModel.AccentColor):
accentChanged = true;
break;
case nameof(MaterialDesignColorViewModel.NormalColor):
normalChanged = true;
break;
case nameof(MaterialDesignColorViewModel.AccentColorScale):
accentScaleChanged = true;
break;
case nameof(MaterialDesignColorViewModel.NormalColorScale):
normalScaleChanged = true;
break;
}
};
CommonColor newColor = GetNewRandomColor(Random, vm.MaterialDesign.Color);
vm.Value = new CommonSolidBrush(newColor);
Assert.AreEqual(newColor, vm.MaterialDesign.Color);
Assert.IsTrue(colorChanged);
Assert.IsTrue(colorNameChanged);
Assert.IsTrue(alphaChanged);
Assert.IsTrue(accentChanged);
Assert.IsTrue(normalChanged);
Assert.IsTrue(accentScaleChanged);
Assert.IsTrue(normalScaleChanged);
}
public void ColorNameChangesScalesAndKeepsAlphaAndAccent()
{
// Set the color to some accent color
BrushPropertyViewModel vm = PrepareMockViewModel();
MaterialColorScale scale = GetRandomScale(Random, true); // Accent color
CommonColor scaledColor = GetNewRandomScaledColor(Random, scale, CommonColor.Black);
var color = new CommonColor(scaledColor.R, scaledColor.G, scaledColor.B, Random.NextByte());
vm.Value = new CommonSolidBrush(color);
Assert.AreEqual(scale.Colors, vm.MaterialDesign.AccentColorScale);
MaterialColorScale expectedNormalScale = MaterialDesignColorViewModel.MaterialPalettes
.First(p => !p.IsAccent && p.Name == scale.Name);
Assert.AreEqual(expectedNormalScale.Colors, vm.MaterialDesign.NormalColorScale);
Assert.AreEqual(color.A, vm.MaterialDesign.Alpha);
var accentIndex = Array.IndexOf(scale.Colors.ToArray(), scaledColor);
// Then change to another scale that has accents too
MaterialColorScale newScale = GetRandomScale(Random, true);
var newColorName = newScale.Name;
while (newColorName == scale.Name)
{
newColorName = GetRandomScale(Random, true).Name;
}
vm.MaterialDesign.ColorName = newColorName;
Assert.AreEqual(newColorName, vm.MaterialDesign.ColorName);
Assert.AreEqual(newScale.Colors, vm.MaterialDesign.AccentColorScale);
Assert.AreEqual(accentIndex, Array.IndexOf(newScale.Colors.ToArray(), vm.MaterialDesign.AccentColor));
expectedNormalScale = MaterialDesignColorViewModel.MaterialPalettes
.First(p => !p.IsAccent && p.Name == newScale.Name);
Assert.AreEqual(expectedNormalScale.Colors, vm.MaterialDesign.NormalColorScale);
Assert.AreEqual(color.A, vm.MaterialDesign.Alpha);
// Finally, change to grey, which has only normal nuances, but no accents,
// so color should snap to the closest normal.
var grey = Properties.Resources.MaterialColorGrey;
vm.MaterialDesign.ColorName = Properties.Resources.MaterialColorGrey;
Assert.AreEqual(grey, vm.MaterialDesign.ColorName);
Assert.AreEqual(MaterialDesignColorViewModel.EmptyColorScale, vm.MaterialDesign.AccentColorScale);
Assert.IsNull(vm.MaterialDesign.AccentColor);
Assert.AreEqual(MaterialDesignColorViewModel.MaterialPalettes.First(p => p.Name == grey).Colors,
vm.MaterialDesign.NormalColorScale);
Assert.IsNotNull(vm.MaterialDesign.NormalColor);
Assert.AreEqual(color.A, vm.MaterialDesign.Alpha);
}
public void ValueChangesTriggerSolidColorAndColorSpacePropertyChangesOnly()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
var colorChanged = false;
var colorSpaceChanged = false;
var hueColorChanged = false;
var shadeChanged = false;
CommonColor initialColor = vm.Solid.InitialColor;
CommonColor lastColor = vm.Solid.LastColor;
CommonColor shade = vm.Solid.Shade;
CommonColor hueColor = vm.Solid.HueColor;
vm.Solid.PropertyChanged += (s, e) => {
switch (e.PropertyName)
{
case nameof(SolidBrushViewModel.Color):
colorChanged = true;
break;
case nameof(SolidBrushViewModel.ColorSpace):
colorSpaceChanged = true;
break;
case nameof(SolidBrushViewModel.HueColor):
hueColorChanged = true;
break;
case nameof(SolidBrushViewModel.Shade):
shadeChanged = true;
break;
}
};
CommonColor newColor = GetNewRandomColor(Random, vm.Solid.Color);
vm.Value = new CommonSolidBrush(newColor);
Assert.IsTrue(colorChanged);
Assert.AreEqual(newColor, vm.Solid.Color);
Assert.IsTrue(colorSpaceChanged);
Assert.IsFalse(hueColorChanged);
Assert.AreEqual(hueColor, vm.Solid.HueColor);
Assert.IsFalse(shadeChanged);
Assert.AreEqual(shade, vm.Solid.Shade);
Assert.AreEqual(initialColor, vm.Solid.InitialColor);
Assert.AreEqual(lastColor, vm.Solid.LastColor);
}
public void InitialAndLastColorDontChangeOnceSet()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
vm.Value = GetRandomTestValue(Random);
CommonColor initialColor = vm.Solid.InitialColor;
CommonColor lastColor = vm.Solid.LastColor;
CommonColor newColor = GetNewRandomColor(Random, vm.Solid.Color);
vm.Solid.Color = newColor;
Assert.AreEqual(initialColor, vm.Solid.InitialColor);
Assert.AreEqual(lastColor, vm.Solid.InitialColor);
}
public void CommitLastColorChangesLastColorAndShade()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
vm.Value = GetRandomTestValue(Random);
CommonColor lastColor = vm.Solid.LastColor;
CommonColor newColor = GetNewRandomColor(Random, vm.Solid.Color);
vm.Solid.Color = newColor;
var colorChanged = false;
var hueColorChanged = false;
var shadeChanged = false;
var lastColorChanged = false;
vm.Solid.PropertyChanged += (s, e) => {
switch (e.PropertyName)
{
case nameof(SolidBrushViewModel.Color):
colorChanged = true;
break;
case nameof(SolidBrushViewModel.HueColor):
hueColorChanged = true;
break;
case nameof(SolidBrushViewModel.Shade):
shadeChanged = true;
break;
case nameof(SolidBrushViewModel.LastColor):
lastColorChanged = true;
break;
}
};
vm.Solid.CommitLastColor();
Assert.IsTrue(lastColorChanged);
Assert.IsTrue(shadeChanged);
Assert.IsFalse(colorChanged);
Assert.IsFalse(hueColorChanged);
Assert.AreEqual(newColor, vm.Solid.LastColor);
}
public void ColorsSnapBetweenBlackAndWhiteAndOtherPalettes()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
MaterialColorScale blackAndWhiteScale = MaterialDesignColorViewModel.MaterialPalettes.Last();
MaterialColorScale normalScale = MaterialDesignColorViewModel.MaterialPalettes[0];
MaterialColorScale accentScale = MaterialDesignColorViewModel.MaterialPalettes[1];
CommonColor lightNormalColor = normalScale.Colors[0];
CommonColor darkNormalColor = normalScale.Colors[9];
CommonColor lightAccentColor = accentScale.Colors[0];
CommonColor darkAccentColor = accentScale.Colors[3];
vm.Value = new CommonSolidBrush(lightNormalColor);
vm.MaterialDesign.ColorName = blackAndWhiteScale.Name;
Assert.That(vm.Solid.Color, Is.EqualTo(CommonColor.White));
vm.MaterialDesign.ColorName = normalScale.Name;
Assert.That(vm.Solid.Color, Is.EqualTo(lightNormalColor));
vm.Value = new CommonSolidBrush(darkNormalColor);
vm.MaterialDesign.ColorName = blackAndWhiteScale.Name;
Assert.That(vm.Solid.Color, Is.EqualTo(CommonColor.Black));
vm.MaterialDesign.ColorName = normalScale.Name;
Assert.That(vm.Solid.Color, Is.EqualTo(darkNormalColor));
vm.Value = new CommonSolidBrush(lightAccentColor);
vm.MaterialDesign.ColorName = blackAndWhiteScale.Name;
Assert.That(vm.Solid.Color, Is.EqualTo(CommonColor.White));
vm.MaterialDesign.ColorName = accentScale.Name;
Assert.That(vm.Solid.Color, Is.EqualTo(lightNormalColor));
vm.Value = new CommonSolidBrush(darkAccentColor);
vm.MaterialDesign.ColorName = blackAndWhiteScale.Name;
Assert.That(vm.Solid.Color, Is.EqualTo(CommonColor.Black));
vm.MaterialDesign.ColorName = accentScale.Name;
Assert.That(vm.Solid.Color, Is.EqualTo(darkNormalColor));
}
private NSView MakeValueView(Resource resource, NSTableView tableView)
{
var view = (NSView)tableView.MakeView(valueIdentifier, this);
if (view == null)
{
view = GetValueView(resource.RepresentationType);
}
CommonBrush commonBrush = BrushPropertyViewModel.GetCommonBrushForResource(resource);
if (commonBrush != null && view is CommonBrushView commonBrushView)
{
commonBrushView.Brush = commonBrush;
}
return(view);
}
public void SettingValueTriggersOpacityChange()
{
var mockProperty = new Mock <IPropertyInfo> ();
mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonBrush));
var mockEditor = new MockObjectEditor(mockProperty.Object);
var vm = new BrushPropertyViewModel(MockEditorProvider.MockPlatform, mockProperty.Object, new[] { mockEditor });
var changed = false;
vm.PropertyChanged += (s, e) => {
if (e.PropertyName == nameof(BrushPropertyViewModel.Opacity))
{
changed = true;
}
};
vm.Value = GetRandomTestValue();
Assert.IsTrue(changed);
}
public void UpdatingColorCausesParentValueToChangeAndInitialColorToBeSetOnTheFirstTime()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
vm.Value = GetRandomTestValue(Random);
var colorChanged = false;
var hueColorChanged = false;
var shadeChanged = false;
var parentChanged = false;
var alpha = vm.Solid.Color.A;
vm.Solid.PropertyChanged += (s, e) => {
switch (e.PropertyName)
{
case nameof(SolidBrushViewModel.Color):
colorChanged = true;
break;
case nameof(SolidBrushViewModel.HueColor):
hueColorChanged = true;
break;
case nameof(SolidBrushViewModel.Shade):
shadeChanged = true;
break;
}
};
vm.PropertyChanged += (s, e) => {
parentChanged = true;
};
CommonColor newColor = GetNewRandomColor(Random, vm.Solid.Color);
vm.Solid.Color = newColor;
Assert.IsTrue(parentChanged);
Assert.IsTrue(colorChanged);
Assert.IsFalse(hueColorChanged);
Assert.IsFalse(shadeChanged);
Assert.AreEqual(newColor, vm.Solid.Color);
Assert.AreEqual(newColor, vm.Solid.InitialColor);
}
public void NoValueToMaterialSets()
{
var platform = new TargetPlatform(new MockEditorProvider())
{
SupportsMaterialDesign = true
};
var mockProperty = new Mock <IPropertyInfo> ();
mockProperty.SetupGet(pi => pi.Type).Returns(typeof(CommonSolidBrush));
var mockEditor = new MockObjectEditor(mockProperty.Object);
var vm = new BrushPropertyViewModel(platform, mockProperty.Object, new[] { mockEditor });
Assume.That(vm.MaterialDesign.Color, Is.EqualTo(new CommonColor(0, 0, 0)));
Assume.That(vm.ValueSource, Is.EqualTo(ValueSource.Default).Or.EqualTo(ValueSource.Unset));
Assume.That(vm.SelectedBrushType, Is.EqualTo(CommonBrushType.NoBrush));
vm.SelectedBrushType = CommonBrushType.MaterialDesign;
Assert.That(vm.ValueSource, Is.EqualTo(ValueSource.Local));
}
public void UpdatingShadeCausesColorToChange()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
vm.Value = GetRandomTestValue(Random);
var colorChanged = false;
var hueColorChanged = false;
var shadeChanged = false;
var alpha = vm.Solid.Color.A;
vm.Solid.PropertyChanged += (s, e) => {
switch (e.PropertyName)
{
case nameof(SolidBrushViewModel.Color):
colorChanged = true;
break;
case nameof(SolidBrushViewModel.HueColor):
hueColorChanged = true;
break;
case nameof(SolidBrushViewModel.Shade):
shadeChanged = true;
break;
}
};
CommonColor newShade = GetNewRandomColor(Random, vm.Solid.Shade);
vm.Solid.Shade = newShade;
Assert.IsTrue(colorChanged);
Assert.IsFalse(hueColorChanged);
Assert.IsTrue(shadeChanged);
Assert.AreEqual(alpha, vm.Solid.Color.A);
Assert.AreEqual(newShade.R, vm.Solid.Color.R);
Assert.AreEqual(newShade.G, vm.Solid.Color.G);
Assert.AreEqual(newShade.B, vm.Solid.Color.B);
}
public override NSView GetView(NSOutlineView outlineView, NSTableColumn tableColumn, NSObject item)
{
var facade = item as NSObjectFacade;
var resource = facade?.Target as Resource;
switch (tableColumn.Identifier)
{
case ResourceOutlineView.ResourcePreviewColId:
var cbv = (CommonBrushView)outlineView.MakeView(resourceIdentifier, this);
if (cbv == null)
{
cbv = new CommonBrushView(this.hostResources)
{
Identifier = resourceIdentifier,
Frame = new CGRect(0, 0, 30, 18),
AutoresizingMask = NSViewResizingMask.WidthSizable
};
}
var commonBrush = BrushPropertyViewModel.GetCommonBrushForResource(resource);
if (commonBrush != null)
{
cbv.Brush = commonBrush;
}
return(cbv);
case ResourceOutlineView.ResourceNameColId:
default:
var utf = (UnfocusableTextField)outlineView.MakeView(labelIdentifier, this);
if (utf == null)
{
utf = new UnfocusableTextField {
Identifier = labelIdentifier,
};
}
utf.StringValue = resource.Name;
return(utf);
}
}
public void ColorSpaces()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
Assert.That(vm.Solid.ColorSpaces, new CollectionEquivalentConstraint(SampleColorSpaces));
}
public void AccentAndNormalChangesTriggerPropertyChanges()
{
BrushPropertyViewModel vm = PrepareMockViewModel();
var colorChanged = false;
var colorNameChanged = false;
var alphaChanged = false;
var accentChanged = false;
var normalChanged = false;
var accentScaleChanged = false;
var normalScaleChanged = false;
CommonColor originalColor = GetNewRandomColor(Random, vm.MaterialDesign.Color);
vm.Value = new CommonSolidBrush(originalColor);
vm.MaterialDesign.PropertyChanged += (s, e) => {
switch (e.PropertyName)
{
case nameof(MaterialDesignColorViewModel.Color):
colorChanged = true;
break;
case nameof(MaterialDesignColorViewModel.ColorName):
colorNameChanged = true;
break;
case nameof(MaterialDesignColorViewModel.Alpha):
alphaChanged = true;
break;
case nameof(MaterialDesignColorViewModel.AccentColor):
accentChanged = true;
break;
case nameof(MaterialDesignColorViewModel.NormalColor):
normalChanged = true;
break;
case nameof(MaterialDesignColorViewModel.AccentColorScale):
accentScaleChanged = true;
break;
case nameof(MaterialDesignColorViewModel.NormalColorScale):
normalScaleChanged = true;
break;
}
};
// First, set a normal color
MaterialColorScale scale = GetRandomScale(Random, false);
CommonColor newColor = GetNewRandomScaledColor(Random, scale, originalColor);
var newOpaqueColor = new CommonColor(newColor.R, newColor.G, newColor.B);
var newTransparentColor = new CommonColor(newColor.R, newColor.G, newColor.B, originalColor.A);
vm.MaterialDesign.NormalColor = newOpaqueColor;
Assert.AreEqual(newTransparentColor, vm.MaterialDesign.Color);
Assert.AreEqual(newOpaqueColor, vm.MaterialDesign.NormalColor);
Assert.AreEqual(scale.Name, vm.MaterialDesign.ColorName);
Assert.IsNull(vm.MaterialDesign.AccentColor);
Assert.IsTrue(colorChanged);
Assert.IsTrue(colorNameChanged);
Assert.IsTrue(alphaChanged);
Assert.IsTrue(accentChanged);
Assert.IsTrue(normalChanged);
Assert.IsTrue(accentScaleChanged);
Assert.IsTrue(normalScaleChanged);
colorChanged = false; colorNameChanged = false; alphaChanged = false; accentChanged = false;
normalChanged = false; accentScaleChanged = false; normalScaleChanged = false;
// Then set an accent color
scale = GetRandomScale(Random, true);
newColor = GetNewRandomScaledColor(Random, scale, originalColor);
newOpaqueColor = new CommonColor(newColor.R, newColor.G, newColor.B);
newTransparentColor = new CommonColor(newColor.R, newColor.G, newColor.B, originalColor.A);
vm.MaterialDesign.AccentColor = newOpaqueColor;
Assert.AreEqual(newTransparentColor, vm.MaterialDesign.Color);
Assert.AreEqual(newOpaqueColor, vm.MaterialDesign.AccentColor);
Assert.AreEqual(scale.Name, vm.MaterialDesign.ColorName);
Assert.IsNull(vm.MaterialDesign.NormalColor);
Assert.IsTrue(colorChanged);
Assert.IsTrue(colorNameChanged);
Assert.IsTrue(alphaChanged);
Assert.IsTrue(accentChanged);
Assert.IsTrue(normalChanged);
Assert.IsTrue(accentScaleChanged);
Assert.IsTrue(normalScaleChanged);
}
private void Initialize(IHostResourceProvider hostResources, object selectedValue)
{
this.selectedValue = selectedValue;
Frame = new CGRect(10, 35, 630, 305);
var FrameHeightHalf = (Frame.Height - 32) / 2;
var FrameWidthHalf = (Frame.Width - 32) / 2;
var FrameWidthThird = (Frame.Width - 32) / 3;
this.progressIndicator = new NSProgressIndicator(new CGRect(FrameWidthThird, FrameHeightHalf, 32, 32))
{
Hidden = true,
Style = NSProgressIndicatorStyle.Spinning,
TranslatesAutoresizingMaskIntoConstraints = false,
};
AddSubview(this.progressIndicator);
this.resourceTable = new FirstResponderTableView {
AutoresizingMask = NSViewResizingMask.WidthSizable,
HeaderView = null,
};
this.dataSource = new ResourceTableDataSource(viewModel);
var resourceTableDelegate = new ResourceTableDelegate(hostResources, dataSource);
resourceTableDelegate.ResourceSelected += (sender, e) => {
this.previewPanel.SelectedResource = SelectedResource;
this.selectedValue = BrushPropertyViewModel.GetCommonBrushForResource(SelectedResource);
ResourceSelected?.Invoke(this, EventArgs.Empty);
};
this.resourceTable.Delegate = resourceTableDelegate;
this.resourceTable.DataSource = dataSource;
NSTableColumn resourceImages = new NSTableColumn(ResourceImageColId)
{
Title = Properties.Resources.ResourceTableImageColumnTitle, Width = 32
};
this.resourceTable.AddColumn(resourceImages);
NSTableColumn resourceTypes = new NSTableColumn(ResourceTypeColId)
{
Title = Properties.Resources.ResourceTableTypeColumnTitle, Width = 150
};
this.resourceTable.AddColumn(resourceTypes);
NSTableColumn resourceName = new NSTableColumn(ResourceNameColId)
{
Title = Properties.Resources.ResourceTableNameColumnTitle, Width = 150
};
resourceTable.AddColumn(resourceName);
NSTableColumn resourceValue = new NSTableColumn(ResourceValueColId)
{
Title = Properties.Resources.ResourceTableValueColumnTitle, Width = 45
};
this.resourceTable.AddColumn(resourceValue);
this.resourceTable.DoubleClick += (object sender, EventArgs e) => {
DoubleClicked?.Invoke(this, EventArgs.Empty);
};
// create a table view and a scroll view
this.tableContainer = new NSScrollView(new CGRect(0, 0, resourceTable.TableColumns()[0].Width + resourceTable.TableColumns()[1].Width + resourceTable.TableColumns()[2].Width + 10, Frame.Height))
{
TranslatesAutoresizingMaskIntoConstraints = false,
};
this.tableContainer.DocumentView = resourceTable;
AddSubview(this.tableContainer);
this.previewPanel = new RequestResourcePreviewPanel(hostResources, new CGRect(Frame.Width - FrameWidthThird, 0, FrameWidthThird, Frame.Height));
AddSubview(this.previewPanel);
this.AddConstraints(new[] {
NSLayoutConstraint.Create(this.tableContainer, NSLayoutAttribute.Width, NSLayoutRelation.Equal, this, NSLayoutAttribute.Width, 1f, -190f),
NSLayoutConstraint.Create(this.tableContainer, NSLayoutAttribute.Height, NSLayoutRelation.Equal, this, NSLayoutAttribute.Height, 1f, 0f),
});
ReloadData();
}
