/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public IColorRepository ForDefaultCulture()
{
var colorConverter = new ColorConverter();
var colorModelConverter = new ColorModelConverter(colorConverter);
var colorPaletteConverter = new ColorPaletteConverter(colorConverter, colorModelConverter);
var colorPaletteCollectionConverter = new ColorPaletteCollectionConverter(colorPaletteConverter);
return new ColorRepository(this.serviceClient, colorPaletteCollectionConverter);
}
/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public IColorRepository ForDefaultCulture()
{
var colorConverter = new ColorConverter();
var colorModelConverter = new ColorModelConverter(colorConverter);
var colorPaletteConverter = new ColorPaletteConverter(colorConverter, colorModelConverter);
var colorPaletteCollectionConverter = new ColorPaletteCollectionConverter(colorPaletteConverter);
return(new ColorRepository(this.serviceClient, colorPaletteCollectionConverter));
}
/// <summary>Creates an instance for the given language.</summary>
/// <param name="culture">The culture.</param>
/// <returns>A repository.</returns>
public IColorRepository ForCulture(CultureInfo culture)
{
var colorConverter = new ColorConverter();
var colorModelConverter = new ColorModelConverter(colorConverter);
var colorPaletteConverter = new ColorPaletteConverter(colorConverter, colorModelConverter);
var colorPaletteCollectionConverter = new ColorPaletteCollectionConverter(colorPaletteConverter);
IColorRepository repository = new ColorRepository(this.serviceClient, colorPaletteCollectionConverter);
repository.Culture = culture;
return(repository);
}
/// <summary>Creates an instance for the default language.</summary>
/// <returns>A repository.</returns>
public override IColorRepository ForDefaultCulture()
{
var colorConverter = new ColorConverter();
var colorModelConverter = new ColorModelConverter(colorConverter);
var colorPaletteConverter = new ColorPaletteConverter(colorConverter, colorModelConverter);
var identifiersResponseConverter = new ResponseConverter <ICollection <int>, ICollection <int> >(new ConverterAdapter <ICollection <int> >());
var responseConverter = new ResponseConverter <ColorPaletteDTO, ColorPalette>(colorPaletteConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <ColorPaletteDTO, int, ColorPalette>(colorPaletteConverter, color => color.ColorId);
var pageResponseConverter = new CollectionPageResponseConverter <ColorPaletteDTO, ColorPalette>(colorPaletteConverter);
return(new ColorRepository(this.serviceClient, identifiersResponseConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
/// <summary>
// Try to parse a color given in different flavours (hex, rgb, name)
/// </summary>
public static bool TryParseColor(string strVal, double alpha, out Color color)
{
// 1: color is specified in rgb values
if (strVal.StartsWith("rgb(", StringComparison.OrdinalIgnoreCase))
{
var str = strVal.Substring(4, strVal.Length - 5);
string[] parts = str.Split(',');
if (parts.Length != 3)
{
color = Colors.Black;
return(false);
}
try
{
string redStr = parts[0].Trim();
string greenStr = parts[1].Trim();
string blueStr = parts[2].Trim();
byte red;
byte green;
byte blue;
if (string.IsNullOrWhiteSpace(redStr) ||
string.IsNullOrWhiteSpace(greenStr) ||
string.IsNullOrWhiteSpace(blueStr))
{
red = 0;
green = 0;
blue = 0;
}
else
{
red = (byte)ParseColorValue(redStr);
green = (byte)ParseColorValue(greenStr);
blue = (byte)ParseColorValue(blueStr);
}
color = Color.FromArgb((byte)(alpha * 255), red, green, blue);
return(true);
}
catch
{
}
color = Colors.Black;
return(false);
}
// 2: color is specified in rgba values
if (strVal.StartsWith("rgba(", StringComparison.OrdinalIgnoreCase))
{
var str = strVal.Substring(5, strVal.Length - 6);
string[] parts = str.Split(',');
if (parts.Length != 4)
{
color = Colors.Black;
return(false);
}
try
{
string redStr = parts[0].Trim();
string greenStr = parts[1].Trim();
string blueStr = parts[2].Trim();
string alphaStr = parts[3].Trim();
byte red;
byte green;
byte blue;
double alphaD;
if (string.IsNullOrWhiteSpace(alphaStr) ||
string.IsNullOrWhiteSpace(redStr) ||
string.IsNullOrWhiteSpace(greenStr) ||
string.IsNullOrWhiteSpace(blueStr))
{
alphaD = 1;
red = 0;
green = 0;
blue = 0;
}
else
{
red = (byte)ParseColorValue(redStr);
green = (byte)ParseColorValue(greenStr);
blue = (byte)ParseColorValue(blueStr);
alphaD = DoubleWithUnitParser.Parse(alphaStr);
}
color = Color.FromArgb((byte)(alpha * alphaD * 255), red, green, blue);
return(true);
}
catch
{
}
color = Colors.Black;
return(false);
}
// 3: color is specified in hsl values
if (strVal.StartsWith("hsl(", StringComparison.OrdinalIgnoreCase))
{
var str = strVal.Substring(4, strVal.Length - 5);
string[] parts = str.Split(',');
if (parts.Length != 3)
{
color = Colors.Black;
return(false);
}
try
{
string hueStr = parts[0].Trim();
string saturationStr = parts[1].Trim();
string luminosityStr = parts[2].Trim();
if (string.IsNullOrWhiteSpace(hueStr) ||
string.IsNullOrWhiteSpace(saturationStr) ||
string.IsNullOrWhiteSpace(luminosityStr))
{
color = Colors.Black;
return(true);
}
else
{
var hue = DoubleWithUnitParser.Parse(hueStr);
var saturation = DoubleWithUnitParser.Parse(saturationStr);
var luminosity = DoubleWithUnitParser.Parse(luminosityStr);
color = ColorModelConverter.ConvertHlsToRgb(alpha, hue, saturation, luminosity);
return(true);
}
}
catch
{
}
color = Colors.Black;
return(false);
}
// 4: color is either given as name or hex values
try
{
var color2 = (Color)ColorConverter.ConvertFromString(strVal);
color = Color.FromArgb((byte)(alpha * 255), color2.R, color2.G, color2.B);
return(true);
}
catch
{
}
color = Colors.Black;
return(false);
}
public static sRgbColor TosRgbColor(this RgbColor rgbColor)
{
return(ColorModelConverter.RgbTosRgb(rgbColor));
}
public static RgbColor ToRgbColor(this sRgbColor srgbColor)
{
return(ColorModelConverter.sRgbToRgb(srgbColor));
}
public static RgbColor ToRgbColor(this HslColor hslColor)
{
return(ColorModelConverter.HslColorToRgbColor(hslColor));
}
public static HslColor ToHslColor(this HsvColor hsvColor)
{
return(ColorModelConverter.HsvColorToHslColor(hsvColor));
}
public ColorModelConverterTests()
{
this.colorConverter = new ColorConverterMock();
this.converter = new ColorModelConverter(this.colorConverter);
}
public void HSLtoRGB_ArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() => ColorModelConverter.HSLtoRGB(null));
}
public void HSLtoRGB_CorrectCalculation(HSL hsl, RGB expected)
{
RGB result = ColorModelConverter.HSLtoRGB(hsl);
Assert.That(result, Is.EqualTo(expected));
}
public void RGBtoHSL_ArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() => ColorModelConverter.RGBtoHSL(null));
}
public void RGBtoHSL_CorrectCalculation(RGB rgb, HSL expected)
{
HSL result = ColorModelConverter.RGBtoHSL(rgb);
Assert.That(result, Is.EqualTo(expected));
}
/// <summary>Creates an instance for the given language.</summary>
/// <param name="culture">The culture.</param>
/// <returns>A repository.</returns>
public IColorRepository ForCulture(CultureInfo culture)
{
var colorConverter = new ColorConverter();
var colorModelConverter = new ColorModelConverter(colorConverter);
var colorPaletteConverter = new ColorPaletteConverter(colorConverter, colorModelConverter);
var colorPaletteCollectionConverter = new ColorPaletteCollectionConverter(colorPaletteConverter);
IColorRepository repository = new ColorRepository(this.serviceClient, colorPaletteCollectionConverter);
repository.Culture = culture;
return repository;
}
