diff --git a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorHelpers.cs b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorHelpers.cs index cd2decf0a7..b912d39aba 100644 --- a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorHelpers.cs +++ b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorHelpers.cs @@ -26,9 +26,9 @@ namespace Avalonia.Controls.Primitives return string.Empty; } - public static Hsv IncrementColorChannel( + public static Hsv IncrementColorComponent( Hsv originalHsv, - HsvChannel channel, + HsvComponent component, IncrementDirection direction, IncrementAmount amount, bool shouldWrap, @@ -52,25 +52,25 @@ namespace Avalonia.Controls.Primitives // If we're adding a large increment, then we want to snap to the next // or previous major value - for hue, this is every increment of 30; // for saturation and value, this is every increment of 10. - switch (channel) + switch (component) { - case HsvChannel.Hue: + case HsvComponent.Hue: valueToIncrement = ref newHsv.H; incrementAmount = amount == IncrementAmount.Small ? 1 : 30; break; - case HsvChannel.Saturation: + case HsvComponent.Saturation: valueToIncrement = ref newHsv.S; incrementAmount = amount == IncrementAmount.Small ? 1 : 10; break; - case HsvChannel.Value: + case HsvComponent.Value: valueToIncrement = ref newHsv.V; incrementAmount = amount == IncrementAmount.Small ? 1 : 10; break; default: - throw new InvalidOperationException("Invalid HsvChannel."); + throw new InvalidOperationException("Invalid HsvComponent."); } double previousValue = valueToIncrement; @@ -99,14 +99,14 @@ namespace Avalonia.Controls.Primitives // While working with named colors, we're going to need to be working in actual HSV units, // so we'll divide the min bound and max bound by 100 in the case of saturation or value, // since we'll have received units between 0-100 and we need them within 0-1. - if (channel == HsvChannel.Saturation || - channel == HsvChannel.Value) + if (component == HsvComponent.Saturation || + component == HsvComponent.Value) { minBound /= 100; maxBound /= 100; } - newHsv = FindNextNamedColor(originalHsv, channel, direction, shouldWrap, minBound, maxBound); + newHsv = FindNextNamedColor(originalHsv, component, direction, shouldWrap, minBound, maxBound); } return newHsv; @@ -114,7 +114,7 @@ namespace Avalonia.Controls.Primitives public static Hsv FindNextNamedColor( Hsv originalHsv, - HsvChannel channel, + HsvComponent component, IncrementDirection direction, bool shouldWrap, double minBound, @@ -136,28 +136,28 @@ namespace Avalonia.Controls.Primitives ref double newValue = ref newHsv.H; double incrementAmount = 0.0; - switch (channel) + switch (component) { - case HsvChannel.Hue: + case HsvComponent.Hue: originalValue = originalHsv.H; newValue = ref newHsv.H; incrementAmount = 1; break; - case HsvChannel.Saturation: + case HsvComponent.Saturation: originalValue = originalHsv.S; newValue = ref newHsv.S; incrementAmount = 0.01; break; - case HsvChannel.Value: + case HsvComponent.Value: originalValue = originalHsv.V; newValue = ref newHsv.V; incrementAmount = 0.01; break; default: - throw new InvalidOperationException("Invalid HsvChannel."); + throw new InvalidOperationException("Invalid HsvComponent."); } bool shouldFindMidPoint = true; @@ -228,28 +228,28 @@ namespace Avalonia.Controls.Primitives ref double currentValue = ref currentHsv.H; double wrapIncrement = 0; - switch (channel) + switch (component) { - case HsvChannel.Hue: + case HsvComponent.Hue: startValue = ref startHsv.H; currentValue = ref currentHsv.H; wrapIncrement = 360.0; break; - case HsvChannel.Saturation: + case HsvComponent.Saturation: startValue = ref startHsv.S; currentValue = ref currentHsv.S; wrapIncrement = 1.0; break; - case HsvChannel.Value: + case HsvComponent.Value: startValue = ref startHsv.V; currentValue = ref currentHsv.V; wrapIncrement = 1.0; break; default: - throw new InvalidOperationException("Invalid HsvChannel."); + throw new InvalidOperationException("Invalid HsvComponent."); } while (newColorName == currentColorName) @@ -316,7 +316,7 @@ namespace Avalonia.Controls.Primitives return newHsv; } - public static double IncrementAlphaChannel( + public static double IncrementAlphaComponent( double originalAlpha, IncrementDirection direction, IncrementAmount amount, diff --git a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorSpectrum.Properties.cs b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorSpectrum.Properties.cs index 71fc887bee..824bf9ab05 100644 --- a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorSpectrum.Properties.cs +++ b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorSpectrum.Properties.cs @@ -32,24 +32,24 @@ namespace Avalonia.Controls.Primitives Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF)); /// - /// Gets or sets the two HSV color channels displayed by the spectrum. + /// Gets or sets the two HSV color components displayed by the spectrum. /// /// /// Internally, the uses the HSV color model. /// - public ColorSpectrumChannels Channels + public ColorSpectrumComponents Components { - get => GetValue(ChannelsProperty); - set => SetValue(ChannelsProperty, value); + get => GetValue(ComponentsProperty); + set => SetValue(ComponentsProperty, value); } /// - /// Defines the property. + /// Defines the property. /// - public static readonly StyledProperty ChannelsProperty = - AvaloniaProperty.Register( - nameof(Channels), - ColorSpectrumChannels.HueSaturation); + public static readonly StyledProperty ComponentsProperty = + AvaloniaProperty.Register( + nameof(Components), + ColorSpectrumComponents.HueSaturation); /// /// Gets or sets the currently selected color in the HSV color model. @@ -74,7 +74,7 @@ namespace Avalonia.Controls.Primitives new HsvColor(1, 0, 0, 1)); /// - /// Gets or sets the maximum value of the Hue channel in the range from 0..359. + /// Gets or sets the maximum value of the Hue component in the range from 0..359. /// This property must be greater than . /// /// @@ -93,7 +93,7 @@ namespace Avalonia.Controls.Primitives AvaloniaProperty.Register(nameof(MaxHue), 359); /// - /// Gets or sets the maximum value of the Saturation channel in the range from 0..100. + /// Gets or sets the maximum value of the Saturation component in the range from 0..100. /// This property must be greater than . /// /// @@ -112,7 +112,7 @@ namespace Avalonia.Controls.Primitives AvaloniaProperty.Register(nameof(MaxSaturation), 100); /// - /// Gets or sets the maximum value of the Value channel in the range from 0..100. + /// Gets or sets the maximum value of the Value component in the range from 0..100. /// This property must be greater than . /// /// @@ -131,7 +131,7 @@ namespace Avalonia.Controls.Primitives AvaloniaProperty.Register(nameof(MaxValue), 100); /// - /// Gets or sets the minimum value of the Hue channel in the range from 0..359. + /// Gets or sets the minimum value of the Hue component in the range from 0..359. /// This property must be less than . /// /// @@ -150,7 +150,7 @@ namespace Avalonia.Controls.Primitives AvaloniaProperty.Register(nameof(MinHue), 0); /// - /// Gets or sets the minimum value of the Saturation channel in the range from 0..100. + /// Gets or sets the minimum value of the Saturation component in the range from 0..100. /// This property must be less than . /// /// @@ -169,7 +169,7 @@ namespace Avalonia.Controls.Primitives AvaloniaProperty.Register(nameof(MinSaturation), 0); /// - /// Gets or sets the minimum value of the Value channel in the range from 0..100. + /// Gets or sets the minimum value of the Value component in the range from 0..100. /// This property must be less than . /// /// diff --git a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorSpectrum.cs b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorSpectrum.cs index 6779c54a1e..aecaa88f36 100644 --- a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorSpectrum.cs +++ b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/ColorSpectrum.cs @@ -80,7 +80,7 @@ namespace Avalonia.Controls.Primitives // in order to function properly while the asynchronous bitmap creation // is in progress. private ColorSpectrumShape _shapeFromLastBitmapCreation = ColorSpectrumShape.Box; - private ColorSpectrumChannels _componentsFromLastBitmapCreation = ColorSpectrumChannels.HueSaturation; + private ColorSpectrumComponents _componentsFromLastBitmapCreation = ColorSpectrumComponents.HueSaturation; private double _imageWidthFromLastBitmapCreation = 0.0; private double _imageHeightFromLastBitmapCreation = 0.0; private int _minHueFromLastBitmapCreation = 0; @@ -99,7 +99,7 @@ namespace Avalonia.Controls.Primitives public ColorSpectrum() { _shapeFromLastBitmapCreation = Shape; - _componentsFromLastBitmapCreation = Channels; + _componentsFromLastBitmapCreation = Components; _imageWidthFromLastBitmapCreation = 0; _imageHeightFromLastBitmapCreation = 0; _minHueFromLastBitmapCreation = MinHue; @@ -219,53 +219,53 @@ namespace Avalonia.Controls.Primitives bool isControlDown = e.KeyModifiers.HasFlag(KeyModifiers.Control); - HsvChannel incrementChannel = HsvChannel.Hue; + HsvComponent incrementComponent = HsvComponent.Hue; bool isSaturationValue = false; if (key == Key.Left || key == Key.Right) { - switch (Channels) + switch (Components) { - case ColorSpectrumChannels.HueSaturation: - case ColorSpectrumChannels.HueValue: - incrementChannel = HsvChannel.Hue; + case ColorSpectrumComponents.HueSaturation: + case ColorSpectrumComponents.HueValue: + incrementComponent = HsvComponent.Hue; break; - case ColorSpectrumChannels.SaturationValue: + case ColorSpectrumComponents.SaturationValue: isSaturationValue = true; - goto case ColorSpectrumChannels.SaturationHue; - case ColorSpectrumChannels.SaturationHue: - incrementChannel = HsvChannel.Saturation; + goto case ColorSpectrumComponents.SaturationHue; + case ColorSpectrumComponents.SaturationHue: + incrementComponent = HsvComponent.Saturation; break; - case ColorSpectrumChannels.ValueHue: - case ColorSpectrumChannels.ValueSaturation: - incrementChannel = HsvChannel.Value; + case ColorSpectrumComponents.ValueHue: + case ColorSpectrumComponents.ValueSaturation: + incrementComponent = HsvComponent.Value; break; } } else if (key == Key.Up || key == Key.Down) { - switch (Channels) + switch (Components) { - case ColorSpectrumChannels.SaturationHue: - case ColorSpectrumChannels.ValueHue: - incrementChannel = HsvChannel.Hue; + case ColorSpectrumComponents.SaturationHue: + case ColorSpectrumComponents.ValueHue: + incrementComponent = HsvComponent.Hue; break; - case ColorSpectrumChannels.HueSaturation: - case ColorSpectrumChannels.ValueSaturation: - incrementChannel = HsvChannel.Saturation; + case ColorSpectrumComponents.HueSaturation: + case ColorSpectrumComponents.ValueSaturation: + incrementComponent = HsvComponent.Saturation; break; - case ColorSpectrumChannels.SaturationValue: + case ColorSpectrumComponents.SaturationValue: isSaturationValue = true; - goto case ColorSpectrumChannels.HueValue; - case ColorSpectrumChannels.HueValue: - incrementChannel = HsvChannel.Value; + goto case ColorSpectrumComponents.HueValue; + case ColorSpectrumComponents.HueValue: + incrementComponent = HsvComponent.Value; break; } } @@ -273,19 +273,19 @@ namespace Avalonia.Controls.Primitives double minBound = 0.0; double maxBound = 0.0; - switch (incrementChannel) + switch (incrementComponent) { - case HsvChannel.Hue: + case HsvComponent.Hue: minBound = MinHue; maxBound = MaxHue; break; - case HsvChannel.Saturation: + case HsvComponent.Saturation: minBound = MinSaturation; maxBound = MaxSaturation; break; - case HsvChannel.Value: + case HsvComponent.Value: minBound = MinValue; maxBound = MaxValue; break; @@ -295,8 +295,8 @@ namespace Avalonia.Controls.Primitives // so we want left and up to be lower for hue, but higher for saturation and value. // This will ensure that the icon always moves in the direction of the key press. IncrementDirection direction = - (incrementChannel == HsvChannel.Hue && (key == Key.Left || key == Key.Up)) || - (incrementChannel != HsvChannel.Hue && (key == Key.Right || key == Key.Down)) ? + (incrementComponent == HsvComponent.Hue && (key == Key.Left || key == Key.Up)) || + (incrementComponent != HsvComponent.Hue && (key == Key.Right || key == Key.Down)) ? IncrementDirection.Lower : IncrementDirection.Higher; @@ -320,9 +320,9 @@ namespace Avalonia.Controls.Primitives IncrementAmount amount = isControlDown ? IncrementAmount.Large : IncrementAmount.Small; HsvColor hsvColor = HsvColor; - UpdateColor(ColorHelpers.IncrementColorChannel( + UpdateColor(ColorHelpers.IncrementColorComponent( new Hsv(hsvColor), - incrementChannel, + incrementComponent, direction, amount, shouldWrap: true, @@ -408,12 +408,12 @@ namespace Avalonia.Controls.Primitives throw new ArgumentException("MaxHue must be between 0 and 359."); } - ColorSpectrumChannels channels = Channels; + ColorSpectrumComponents components = Components; // If hue is one of the axes in the spectrum bitmap, then we'll need to regenerate it // if the maximum or minimum value has changed. - if (channels != ColorSpectrumChannels.SaturationValue && - channels != ColorSpectrumChannels.ValueSaturation) + if (components != ColorSpectrumComponents.SaturationValue && + components != ColorSpectrumComponents.ValueSaturation) { CreateBitmapsAndColorMap(); } @@ -433,12 +433,12 @@ namespace Avalonia.Controls.Primitives throw new ArgumentException("MaxSaturation must be between 0 and 100."); } - ColorSpectrumChannels channels = Channels; + ColorSpectrumComponents components = Components; // If value is one of the axes in the spectrum bitmap, then we'll need to regenerate it // if the maximum or minimum value has changed. - if (channels != ColorSpectrumChannels.HueValue && - channels != ColorSpectrumChannels.ValueHue) + if (components != ColorSpectrumComponents.HueValue && + components != ColorSpectrumComponents.ValueHue) { CreateBitmapsAndColorMap(); } @@ -458,12 +458,12 @@ namespace Avalonia.Controls.Primitives throw new ArgumentException("MaxValue must be between 0 and 100."); } - ColorSpectrumChannels channels = Channels; + ColorSpectrumComponents components = Components; // If value is one of the axes in the spectrum bitmap, then we'll need to regenerate it // if the maximum or minimum value has changed. - if (channels != ColorSpectrumChannels.HueSaturation && - channels != ColorSpectrumChannels.SaturationHue) + if (components != ColorSpectrumComponents.HueSaturation && + components != ColorSpectrumComponents.SaturationHue) { CreateBitmapsAndColorMap(); } @@ -472,7 +472,7 @@ namespace Avalonia.Controls.Primitives { CreateBitmapsAndColorMap(); } - else if (change.Property == ChannelsProperty) + else if (change.Property == ComponentsProperty) { CreateBitmapsAndColorMap(); } @@ -617,23 +617,22 @@ namespace Avalonia.Controls.Primitives // Note: This can sometimes cause a crash -- possibly due to differences in c# rounding. Therefore, index is now clamped. Hsv hsvAtPoint = _hsvValues[MathUtilities.Clamp((y * width + x), 0, _hsvValues.Count - 1)]; - var channels = Channels; var hsvColor = HsvColor; - switch (channels) + switch (Components) { - case ColorSpectrumChannels.HueValue: - case ColorSpectrumChannels.ValueHue: + case ColorSpectrumComponents.HueValue: + case ColorSpectrumComponents.ValueHue: hsvAtPoint.S = hsvColor.S; break; - case ColorSpectrumChannels.HueSaturation: - case ColorSpectrumChannels.SaturationHue: + case ColorSpectrumComponents.HueSaturation: + case ColorSpectrumComponents.SaturationHue: hsvAtPoint.V = hsvColor.V; break; - case ColorSpectrumChannels.ValueSaturation: - case ColorSpectrumChannels.SaturationValue: + case ColorSpectrumComponents.ValueSaturation: + case ColorSpectrumComponents.SaturationValue: hsvAtPoint.H = hsvColor.H; break; } @@ -681,8 +680,8 @@ namespace Avalonia.Controls.Primitives // In the case where saturation was an axis in the spectrum with hue, or value is an axis, full stop, // we inverted the direction of that axis in order to put more hue on the outside of the ring, // so we need to do similarly here when positioning the ellipse. - if (_componentsFromLastBitmapCreation == ColorSpectrumChannels.HueSaturation || - _componentsFromLastBitmapCreation == ColorSpectrumChannels.SaturationHue) + if (_componentsFromLastBitmapCreation == ColorSpectrumComponents.HueSaturation || + _componentsFromLastBitmapCreation == ColorSpectrumComponents.SaturationHue) { sPercent = 1 - sPercent; } @@ -693,32 +692,32 @@ namespace Avalonia.Controls.Primitives switch (_componentsFromLastBitmapCreation) { - case ColorSpectrumChannels.HueValue: + case ColorSpectrumComponents.HueValue: xPercent = hPercent; yPercent = vPercent; break; - case ColorSpectrumChannels.HueSaturation: + case ColorSpectrumComponents.HueSaturation: xPercent = hPercent; yPercent = sPercent; break; - case ColorSpectrumChannels.ValueHue: + case ColorSpectrumComponents.ValueHue: xPercent = vPercent; yPercent = hPercent; break; - case ColorSpectrumChannels.ValueSaturation: + case ColorSpectrumComponents.ValueSaturation: xPercent = vPercent; yPercent = sPercent; break; - case ColorSpectrumChannels.SaturationHue: + case ColorSpectrumComponents.SaturationHue: xPercent = sPercent; yPercent = hPercent; break; - case ColorSpectrumChannels.SaturationValue: + case ColorSpectrumComponents.SaturationValue: xPercent = sPercent; yPercent = vPercent; break; @@ -757,8 +756,8 @@ namespace Avalonia.Controls.Primitives // In the case where saturation was an axis in the spectrum with hue, or value is an axis, full stop, // we inverted the direction of that axis in order to put more hue on the outside of the ring, // so we need to do similarly here when positioning the ellipse. - if (_componentsFromLastBitmapCreation == ColorSpectrumChannels.HueSaturation || - _componentsFromLastBitmapCreation == ColorSpectrumChannels.SaturationHue) + if (_componentsFromLastBitmapCreation == ColorSpectrumComponents.HueSaturation || + _componentsFromLastBitmapCreation == ColorSpectrumComponents.SaturationHue) { sThetaValue = 360 - sThetaValue; sRValue = -sRValue - 1; @@ -771,32 +770,32 @@ namespace Avalonia.Controls.Primitives switch (_componentsFromLastBitmapCreation) { - case ColorSpectrumChannels.HueValue: + case ColorSpectrumComponents.HueValue: thetaValue = hThetaValue; rValue = vRValue; break; - case ColorSpectrumChannels.HueSaturation: + case ColorSpectrumComponents.HueSaturation: thetaValue = hThetaValue; rValue = sRValue; break; - case ColorSpectrumChannels.ValueHue: + case ColorSpectrumComponents.ValueHue: thetaValue = vThetaValue; rValue = hRValue; break; - case ColorSpectrumChannels.ValueSaturation: + case ColorSpectrumComponents.ValueSaturation: thetaValue = vThetaValue; rValue = sRValue; break; - case ColorSpectrumChannels.SaturationHue: + case ColorSpectrumComponents.SaturationHue: thetaValue = sThetaValue; rValue = hRValue; break; - case ColorSpectrumChannels.SaturationValue: + case ColorSpectrumComponents.SaturationValue: thetaValue = sThetaValue; rValue = vRValue; break; @@ -932,7 +931,7 @@ namespace Avalonia.Controls.Primitives int minValue = MinValue; int maxValue = MaxValue; ColorSpectrumShape shape = Shape; - ColorSpectrumChannels channels = Channels; + ColorSpectrumComponents components = Components; // If min >= max, then by convention, min is the only number that a property can have. if (minHue >= maxHue) @@ -967,8 +966,8 @@ namespace Avalonia.Controls.Primitives bgraMinPixelData.Capacity = pixelDataSize; // We'll only save pixel data for the middle bitmaps if our third dimension is hue. - if (channels == ColorSpectrumChannels.ValueSaturation || - channels == ColorSpectrumChannels.SaturationValue) + if (components == ColorSpectrumComponents.ValueSaturation || + components == ColorSpectrumComponents.SaturationValue) { bgraMiddle1PixelData.Capacity = pixelDataSize; bgraMiddle2PixelData.Capacity = pixelDataSize; @@ -1004,7 +1003,7 @@ namespace Avalonia.Controls.Primitives for (int y = minDimensionInt - 1; y >= 0; --y) { FillPixelForBox( - x, y, hsv, minDimensionInt, channels, minHue, maxHue, minSaturation, maxSaturation, minValue, maxValue, + x, y, hsv, minDimensionInt, components, minHue, maxHue, minSaturation, maxSaturation, minValue, maxValue, bgraMinPixelData, bgraMiddle1PixelData, bgraMiddle2PixelData, bgraMiddle3PixelData, bgraMiddle4PixelData, bgraMaxPixelData, newHsvValues); } @@ -1017,7 +1016,7 @@ namespace Avalonia.Controls.Primitives for (int x = 0; x < minDimensionInt; ++x) { FillPixelForRing( - x, y, minDimensionInt / 2.0, hsv, channels, minHue, maxHue, minSaturation, maxSaturation, minValue, maxValue, + x, y, minDimensionInt / 2.0, hsv, components, minHue, maxHue, minSaturation, maxSaturation, minValue, maxValue, bgraMinPixelData, bgraMiddle1PixelData, bgraMiddle2PixelData, bgraMiddle3PixelData, bgraMiddle4PixelData, bgraMaxPixelData, newHsvValues); } @@ -1030,24 +1029,24 @@ namespace Avalonia.Controls.Primitives int pixelWidth = (int)Math.Round(minDimension); int pixelHeight = (int)Math.Round(minDimension); - ColorSpectrumChannels channels2 = Channels; + ColorSpectrumComponents components2 = Components; WriteableBitmap minBitmap = ColorHelpers.CreateBitmapFromPixelData(pixelWidth, pixelHeight, bgraMinPixelData); WriteableBitmap maxBitmap = ColorHelpers.CreateBitmapFromPixelData(pixelWidth, pixelHeight, bgraMaxPixelData); - switch (channels2) + switch (components2) { - case ColorSpectrumChannels.HueValue: - case ColorSpectrumChannels.ValueHue: + case ColorSpectrumComponents.HueValue: + case ColorSpectrumComponents.ValueHue: _saturationMinimumBitmap = minBitmap; _saturationMaximumBitmap = maxBitmap; break; - case ColorSpectrumChannels.HueSaturation: - case ColorSpectrumChannels.SaturationHue: + case ColorSpectrumComponents.HueSaturation: + case ColorSpectrumComponents.SaturationHue: _valueBitmap = maxBitmap; break; - case ColorSpectrumChannels.ValueSaturation: - case ColorSpectrumChannels.SaturationValue: + case ColorSpectrumComponents.ValueSaturation: + case ColorSpectrumComponents.SaturationValue: _hueRedBitmap = minBitmap; _hueYellowBitmap = ColorHelpers.CreateBitmapFromPixelData(pixelWidth, pixelHeight, bgraMiddle1PixelData); _hueGreenBitmap = ColorHelpers.CreateBitmapFromPixelData(pixelWidth, pixelHeight, bgraMiddle2PixelData); @@ -1058,7 +1057,7 @@ namespace Avalonia.Controls.Primitives } _shapeFromLastBitmapCreation = Shape; - _componentsFromLastBitmapCreation = Channels; + _componentsFromLastBitmapCreation = Components; _imageWidthFromLastBitmapCreation = minDimension; _imageHeightFromLastBitmapCreation = minDimension; _minHueFromLastBitmapCreation = MinHue; @@ -1080,7 +1079,7 @@ namespace Avalonia.Controls.Primitives double y, Hsv baseHsv, double minDimension, - ColorSpectrumChannels channels, + ColorSpectrumComponents components, double minHue, double maxHue, double minSaturation, @@ -1112,30 +1111,30 @@ namespace Avalonia.Controls.Primitives double xPercent = (minDimension - 1 - x) / (minDimension - 1); double yPercent = (minDimension - 1 - y) / (minDimension - 1); - switch (channels) + switch (components) { - case ColorSpectrumChannels.HueValue: + case ColorSpectrumComponents.HueValue: hsvMin.H = hsvMiddle1.H = hsvMiddle2.H = hsvMiddle3.H = hsvMiddle4.H = hsvMax.H = hMin + yPercent * (hMax - hMin); hsvMin.V = hsvMiddle1.V = hsvMiddle2.V = hsvMiddle3.V = hsvMiddle4.V = hsvMax.V = vMin + xPercent * (vMax - vMin); hsvMin.S = 0; hsvMax.S = 1; break; - case ColorSpectrumChannels.HueSaturation: + case ColorSpectrumComponents.HueSaturation: hsvMin.H = hsvMiddle1.H = hsvMiddle2.H = hsvMiddle3.H = hsvMiddle4.H = hsvMax.H = hMin + yPercent * (hMax - hMin); hsvMin.S = hsvMiddle1.S = hsvMiddle2.S = hsvMiddle3.S = hsvMiddle4.S = hsvMax.S = sMin + xPercent * (sMax - sMin); hsvMin.V = 0; hsvMax.V = 1; break; - case ColorSpectrumChannels.ValueHue: + case ColorSpectrumComponents.ValueHue: hsvMin.V = hsvMiddle1.V = hsvMiddle2.V = hsvMiddle3.V = hsvMiddle4.V = hsvMax.V = vMin + yPercent * (vMax - vMin); hsvMin.H = hsvMiddle1.H = hsvMiddle2.H = hsvMiddle3.H = hsvMiddle4.H = hsvMax.H = hMin + xPercent * (hMax - hMin); hsvMin.S = 0; hsvMax.S = 1; break; - case ColorSpectrumChannels.ValueSaturation: + case ColorSpectrumComponents.ValueSaturation: hsvMin.V = hsvMiddle1.V = hsvMiddle2.V = hsvMiddle3.V = hsvMiddle4.V = hsvMax.V = vMin + yPercent * (vMax - vMin); hsvMin.S = hsvMiddle1.S = hsvMiddle2.S = hsvMiddle3.S = hsvMiddle4.S = hsvMax.S = sMin + xPercent * (sMax - sMin); hsvMin.H = 0; @@ -1146,14 +1145,14 @@ namespace Avalonia.Controls.Primitives hsvMax.H = 300; break; - case ColorSpectrumChannels.SaturationHue: + case ColorSpectrumComponents.SaturationHue: hsvMin.S = hsvMiddle1.S = hsvMiddle2.S = hsvMiddle3.S = hsvMiddle4.S = hsvMax.S = sMin + yPercent * (sMax - sMin); hsvMin.H = hsvMiddle1.H = hsvMiddle2.H = hsvMiddle3.H = hsvMiddle4.H = hsvMax.H = hMin + xPercent * (hMax - hMin); hsvMin.V = 0; hsvMax.V = 1; break; - case ColorSpectrumChannels.SaturationValue: + case ColorSpectrumComponents.SaturationValue: hsvMin.S = hsvMiddle1.S = hsvMiddle2.S = hsvMiddle3.S = hsvMiddle4.S = hsvMax.S = sMin + yPercent * (sMax - sMin); hsvMin.V = hsvMiddle1.V = hsvMiddle2.V = hsvMiddle3.V = hsvMiddle4.V = hsvMax.V = vMin + xPercent * (vMax - vMin); hsvMin.H = 0; @@ -1171,8 +1170,8 @@ namespace Avalonia.Controls.Primitives // so we'll invert the number before assigning the HSL value to the array. // Otherwise, we'll have a very narrow section in the middle that actually has meaningful hue // in the case of the ring configuration. - if (channels == ColorSpectrumChannels.HueSaturation || - channels == ColorSpectrumChannels.SaturationHue) + if (components == ColorSpectrumComponents.HueSaturation || + components == ColorSpectrumComponents.SaturationHue) { hsvMin.S = sMax - hsvMin.S + sMin; hsvMiddle1.S = sMax - hsvMiddle1.S + sMin; @@ -1200,8 +1199,8 @@ namespace Avalonia.Controls.Primitives bgraMinPixelData.Add(255); // a - ignored // We'll only save pixel data for the middle bitmaps if our third dimension is hue. - if (channels == ColorSpectrumChannels.ValueSaturation || - channels == ColorSpectrumChannels.SaturationValue) + if (components == ColorSpectrumComponents.ValueSaturation || + components == ColorSpectrumComponents.SaturationValue) { Rgb rgbMiddle1 = hsvMiddle1.ToRgb(); bgraMiddle1PixelData.Add((byte)Math.Round(rgbMiddle1.B * 255.0)); // b @@ -1240,7 +1239,7 @@ namespace Avalonia.Controls.Primitives double y, double radius, Hsv baseHsv, - ColorSpectrumChannels channels, + ColorSpectrumComponents components, double minHue, double maxHue, double minSaturation, @@ -1298,30 +1297,30 @@ namespace Avalonia.Controls.Primitives double thetaPercent = theta / 360; - switch (channels) + switch (components) { - case ColorSpectrumChannels.HueValue: + case ColorSpectrumComponents.HueValue: hsvMin.H = hsvMiddle1.H = hsvMiddle2.H = hsvMiddle3.H = hsvMiddle4.H = hsvMax.H = hMin + thetaPercent * (hMax - hMin); hsvMin.V = hsvMiddle1.V = hsvMiddle2.V = hsvMiddle3.V = hsvMiddle4.V = hsvMax.V = vMin + r * (vMax - vMin); hsvMin.S = 0; hsvMax.S = 1; break; - case ColorSpectrumChannels.HueSaturation: + case ColorSpectrumComponents.HueSaturation: hsvMin.H = hsvMiddle1.H = hsvMiddle2.H = hsvMiddle3.H = hsvMiddle4.H = hsvMax.H = hMin + thetaPercent * (hMax - hMin); hsvMin.S = hsvMiddle1.S = hsvMiddle2.S = hsvMiddle3.S = hsvMiddle4.S = hsvMax.S = sMin + r * (sMax - sMin); hsvMin.V = 0; hsvMax.V = 1; break; - case ColorSpectrumChannels.ValueHue: + case ColorSpectrumComponents.ValueHue: hsvMin.V = hsvMiddle1.V = hsvMiddle2.V = hsvMiddle3.V = hsvMiddle4.V = hsvMax.V = vMin + thetaPercent * (vMax - vMin); hsvMin.H = hsvMiddle1.H = hsvMiddle2.H = hsvMiddle3.H = hsvMiddle4.H = hsvMax.H = hMin + r * (hMax - hMin); hsvMin.S = 0; hsvMax.S = 1; break; - case ColorSpectrumChannels.ValueSaturation: + case ColorSpectrumComponents.ValueSaturation: hsvMin.V = hsvMiddle1.V = hsvMiddle2.V = hsvMiddle3.V = hsvMiddle4.V = hsvMax.V = vMin + thetaPercent * (vMax - vMin); hsvMin.S = hsvMiddle1.S = hsvMiddle2.S = hsvMiddle3.S = hsvMiddle4.S = hsvMax.S = sMin + r * (sMax - sMin); hsvMin.H = 0; @@ -1332,14 +1331,14 @@ namespace Avalonia.Controls.Primitives hsvMax.H = 300; break; - case ColorSpectrumChannels.SaturationHue: + case ColorSpectrumComponents.SaturationHue: hsvMin.S = hsvMiddle1.S = hsvMiddle2.S = hsvMiddle3.S = hsvMiddle4.S = hsvMax.S = sMin + thetaPercent * (sMax - sMin); hsvMin.H = hsvMiddle1.H = hsvMiddle2.H = hsvMiddle3.H = hsvMiddle4.H = hsvMax.H = hMin + r * (hMax - hMin); hsvMin.V = 0; hsvMax.V = 1; break; - case ColorSpectrumChannels.SaturationValue: + case ColorSpectrumComponents.SaturationValue: hsvMin.S = hsvMiddle1.S = hsvMiddle2.S = hsvMiddle3.S = hsvMiddle4.S = hsvMax.S = sMin + thetaPercent * (sMax - sMin); hsvMin.V = hsvMiddle1.V = hsvMiddle2.V = hsvMiddle3.V = hsvMiddle4.V = hsvMax.V = vMin + r * (vMax - vMin); hsvMin.H = 0; @@ -1357,8 +1356,8 @@ namespace Avalonia.Controls.Primitives // so we'll invert the number before assigning the HSL value to the array. // Otherwise, we'll have a very narrow section in the middle that actually has meaningful hue // in the case of the ring configuration. - if (channels == ColorSpectrumChannels.HueSaturation || - channels == ColorSpectrumChannels.SaturationHue) + if (components == ColorSpectrumComponents.HueSaturation || + components == ColorSpectrumComponents.SaturationHue) { hsvMin.S = sMax - hsvMin.S + sMin; hsvMiddle1.S = sMax - hsvMiddle1.S + sMin; @@ -1386,8 +1385,8 @@ namespace Avalonia.Controls.Primitives bgraMinPixelData.Add(255); // a // We'll only save pixel data for the middle bitmaps if our third dimension is hue. - if (channels == ColorSpectrumChannels.ValueSaturation || - channels == ColorSpectrumChannels.SaturationValue) + if (components == ColorSpectrumComponents.ValueSaturation || + components == ColorSpectrumComponents.SaturationValue) { Rgb rgbMiddle1 = hsvMiddle1.ToRgb(); bgraMiddle1PixelData.Add((byte)Math.Round(rgbMiddle1.B * 255)); // b @@ -1432,7 +1431,7 @@ namespace Avalonia.Controls.Primitives } HsvColor hsvColor = HsvColor; - ColorSpectrumChannels channels = Channels; + ColorSpectrumComponents components = Components; // We'll set the base image and the overlay image based on which component is our third dimension. // If it's saturation or luminosity, then the base image is that dimension at its minimum value, @@ -1440,10 +1439,10 @@ namespace Avalonia.Controls.Primitives // If it's hue, then we'll figure out where in the color wheel we are, and then use the two // colors on either side of our position as our base image and overlay image. // For example, if our hue is orange, then the base image would be red and the overlay image yellow. - switch (channels) + switch (components) { - case ColorSpectrumChannels.HueValue: - case ColorSpectrumChannels.ValueHue: + case ColorSpectrumComponents.HueValue: + case ColorSpectrumComponents.ValueHue: { if (_saturationMinimumBitmap == null || _saturationMaximumBitmap == null) @@ -1463,8 +1462,8 @@ namespace Avalonia.Controls.Primitives } break; - case ColorSpectrumChannels.HueSaturation: - case ColorSpectrumChannels.SaturationHue: + case ColorSpectrumComponents.HueSaturation: + case ColorSpectrumComponents.SaturationHue: { if (_valueBitmap == null) { @@ -1483,8 +1482,8 @@ namespace Avalonia.Controls.Primitives } break; - case ColorSpectrumChannels.ValueSaturation: - case ColorSpectrumChannels.SaturationValue: + case ColorSpectrumComponents.ValueSaturation: + case ColorSpectrumComponents.SaturationValue: { if (_hueRedBitmap == null || _hueYellowBitmap == null || @@ -1554,13 +1553,13 @@ namespace Avalonia.Controls.Primitives // To find how much something contrasts with white, we use the equation // for relative luminance. // - // If the third channel is value, then we won't be updating the spectrum's displayed colors, + // If the third component is value, then we won't be updating the spectrum's displayed colors, // so in that case we should use a value of 1 when considering the backdrop // for the selection ellipse. Color displayedColor; - if (Channels == ColorSpectrumChannels.HueSaturation || - Channels == ColorSpectrumChannels.SaturationHue) + if (Components == ColorSpectrumComponents.HueSaturation || + Components == ColorSpectrumComponents.SaturationHue) { HsvColor hsvColor = HsvColor; Rgb color = (new Hsv(hsvColor.H, hsvColor.S, 1.0)).ToRgb(); diff --git a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/Hsv.cs b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/Hsv.cs index d44e6b3a9f..8a425b9581 100644 --- a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/Hsv.cs +++ b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/Hsv.cs @@ -8,39 +8,39 @@ using Avalonia.Media; namespace Avalonia.Controls.Primitives { /// - /// Contains and allows modification of Hue, Saturation and Value channel values. + /// Contains and allows modification of Hue, Saturation and Value components. /// /// /// The is a specialized struct optimized for permanence and memory: /// /// This is not a read-only struct like and allows editing the fields /// Removes the alpha component unnecessary in core calculations - /// No channel value bounds checks or clamping is done. + /// No component bounds checks or clamping is done. /// /// internal struct Hsv { /// - /// The Hue channel value in the range from 0..359. + /// The Hue component in the range from 0..359. /// public double H; /// - /// The Saturation channel value in the range from 0..1. + /// The Saturation component in the range from 0..1. /// public double S; /// - /// The Value channel value in the range from 0..1. + /// The Value component in the range from 0..1. /// public double V; /// /// Initializes a new instance of the struct. /// - /// The Hue channel value in the range from 0..360. - /// The Saturation channel value in the range from 0..1. - /// The Value channel value in the range from 0..1. + /// The Hue component in the range from 0..360. + /// The Saturation component in the range from 0..1. + /// The Value component in the range from 0..1. public Hsv(double h, double s, double v) { H = h; @@ -62,7 +62,7 @@ namespace Avalonia.Controls.Primitives /// /// Converts this struct into a standard . /// - /// The Alpha channel value in the range from 0..1. + /// The Alpha component in the range from 0..1. /// A new representing this struct. public HsvColor ToHsvColor(double alpha = 1.0) { diff --git a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/IncrementAmount.cs b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/IncrementAmount.cs index fd749cd7dc..12aca593d5 100644 --- a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/IncrementAmount.cs +++ b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/IncrementAmount.cs @@ -6,7 +6,7 @@ namespace Avalonia.Controls.Primitives { /// - /// Defines a relative amount that a color channel should be incremented. + /// Defines a relative amount that a color component should be incremented. /// internal enum IncrementAmount { diff --git a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/IncrementDirection.cs b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/IncrementDirection.cs index 8002a44fc9..df9c1e3350 100644 --- a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/IncrementDirection.cs +++ b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/IncrementDirection.cs @@ -6,7 +6,7 @@ namespace Avalonia.Controls.Primitives { /// - /// Defines the direction a color channel should be incremented. + /// Defines the direction a color component should be incremented. /// internal enum IncrementDirection { diff --git a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/Rgb.cs b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/Rgb.cs index 616ab9e9ac..72e3821c2b 100644 --- a/src/Avalonia.Controls.ColorPicker/ColorSpectrum/Rgb.cs +++ b/src/Avalonia.Controls.ColorPicker/ColorSpectrum/Rgb.cs @@ -9,40 +9,40 @@ using Avalonia.Utilities; namespace Avalonia.Controls.Primitives { /// - /// Contains and allows modification of Red, Green and Blue channel values. + /// Contains and allows modification of Red, Green and Blue components. /// /// /// The is a specialized struct optimized for permanence and memory: /// /// This is not a read-only struct like and allows editing the fields /// Removes the alpha component unnecessary in core calculations - /// Normalizes RGB channel values in the range of 0..1 to simplify calculations. - /// No channel value bounds checks or clamping is done. + /// Normalizes RGB components in the range of 0..1 to simplify calculations. + /// No component bounds checks or clamping is done. /// /// internal struct Rgb { /// - /// The Red channel value in the range from 0..1. + /// The Red component in the range from 0..1. /// public double R; /// - /// The Green channel value in the range from 0..1. + /// The Green component in the range from 0..1. /// public double G; /// - /// The Blue channel value in the range from 0..1. + /// The Blue component in the range from 0..1. /// public double B; /// /// Initializes a new instance of the struct. /// - /// The Red channel value in the range from 0..1. - /// The Green channel value in the range from 0..1. - /// The Blue channel value in the range from 0..1. + /// The Red component in the range from 0..1. + /// The Green component in the range from 0..1. + /// The Blue component in the range from 0..1. public Rgb(double r, double g, double b) { R = r; @@ -64,7 +64,7 @@ namespace Avalonia.Controls.Primitives /// /// Converts this struct into a standard . /// - /// The Alpha channel value in the range from 0..1. + /// The Alpha component in the range from 0..1. /// A new representing this struct. public Color ToColor(double alpha = 1.0) { diff --git a/src/Avalonia.Controls.ColorPicker/ColorSpectrumChannels.cs b/src/Avalonia.Controls.ColorPicker/ColorSpectrumComponents.cs similarity index 81% rename from src/Avalonia.Controls.ColorPicker/ColorSpectrumChannels.cs rename to src/Avalonia.Controls.ColorPicker/ColorSpectrumComponents.cs index a31586d175..164089096e 100644 --- a/src/Avalonia.Controls.ColorPicker/ColorSpectrumChannels.cs +++ b/src/Avalonia.Controls.ColorPicker/ColorSpectrumComponents.cs @@ -8,16 +8,16 @@ using Avalonia.Controls.Primitives; namespace Avalonia.Controls { /// - /// Defines the two HSV color channels displayed by a . + /// Defines the two HSV color components displayed by a . /// /// - /// Order of the color channels is important and correspond with an X/Y axis in Box + /// Order of the color components is important and correspond with an X/Y axis in Box /// shape or a degree/radius in Ring shape. /// - public enum ColorSpectrumChannels + public enum ColorSpectrumComponents { /// - /// The Hue and Value channels. + /// The Hue and Value components. /// /// /// In Box shape, Hue is mapped to the X-axis and Value is mapped to the Y-axis. @@ -26,7 +26,7 @@ namespace Avalonia.Controls HueValue, /// - /// The Value and Hue channels. + /// The Value and Hue components. /// /// /// In Box shape, Value is mapped to the X-axis and Hue is mapped to the Y-axis. @@ -35,7 +35,7 @@ namespace Avalonia.Controls ValueHue, /// - /// The Hue and Saturation channels. + /// The Hue and Saturation components. /// /// /// In Box shape, Hue is mapped to the X-axis and Saturation is mapped to the Y-axis. @@ -44,7 +44,7 @@ namespace Avalonia.Controls HueSaturation, /// - /// The Saturation and Hue channels. + /// The Saturation and Hue components. /// /// /// In Box shape, Saturation is mapped to the X-axis and Hue is mapped to the Y-axis. @@ -53,7 +53,7 @@ namespace Avalonia.Controls SaturationHue, /// - /// The Saturation and Value channels. + /// The Saturation and Value components. /// /// /// In Box shape, Saturation is mapped to the X-axis and Value is mapped to the Y-axis. @@ -62,7 +62,7 @@ namespace Avalonia.Controls SaturationValue, /// - /// The Value and Saturation channels. + /// The Value and Saturation components. /// /// /// In Box shape, Value is mapped to the X-axis and Saturation is mapped to the Y-axis. diff --git a/src/Avalonia.Controls.ColorPicker/HsvChannel.cs b/src/Avalonia.Controls.ColorPicker/HsvChannel.cs deleted file mode 100644 index 18f96fe70b..0000000000 --- a/src/Avalonia.Controls.ColorPicker/HsvChannel.cs +++ /dev/null @@ -1,33 +0,0 @@ -// This source file is adapted from the WinUI project. -// (https://github.com/microsoft/microsoft-ui-xaml) -// -// Licensed to The Avalonia Project under the MIT License. - -namespace Avalonia.Controls -{ - /// - /// Defines a specific HSV color model channel. - /// - public enum HsvChannel - { - /// - /// The Hue channel. - /// - Hue, - - /// - /// The Saturation channel. - /// - Saturation, - - /// - /// The Value channel. - /// - Value, - - /// - /// The Alpha channel. - /// - Alpha - }; -} diff --git a/src/Avalonia.Controls.ColorPicker/HsvComponent.cs b/src/Avalonia.Controls.ColorPicker/HsvComponent.cs new file mode 100644 index 0000000000..1132bd7bbb --- /dev/null +++ b/src/Avalonia.Controls.ColorPicker/HsvComponent.cs @@ -0,0 +1,47 @@ +// This source file is adapted from the WinUI project. +// (https://github.com/microsoft/microsoft-ui-xaml) +// +// Licensed to The Avalonia Project under the MIT License. + +using Avalonia.Media; + +namespace Avalonia.Controls +{ + /// + /// Defines a specific component in the HSV color model. + /// + public enum HsvComponent + { + /// + /// The Hue component. + /// + /// + /// Also see: + /// + Hue, + + /// + /// The Saturation component. + /// + /// + /// Also see: + /// + Saturation, + + /// + /// The Value component. + /// + /// + /// Also see: + /// + Value, + + /// + /// The Alpha component. + /// + /// + /// Also see: + /// + Alpha + }; +}