private static void testConvertHSB(float h, float s, float b, int R, int G, int B)
{
Color actual = ColorBuilder.ConvertHSBToColor(h, s, b);
Color expected = Color.FromArgb(255, R, G, B);
String message = String.Format("Colors converting ({0:F2}, {1:F2}, {2:F2}) don't match", h, s, b);
Assert.AreEqual(expected, actual, message);
}
/// <include file='doc\BordersPage.uex' path='docs/doc[@for="BordersPage.OnClickColorPicker"]/*' />
/// <devdoc>
/// Invokes the color picker to pick the grid color.
/// </devdoc>
private void OnClickColorPicker(object source, EventArgs e)
{
string color = borderColorCombo.Color;
color = ColorBuilder.BuildColor(GetBaseControl(), this, color);
if (color != null)
{
borderColorCombo.Color = color;
OnBordersChanged(borderColorCombo, EventArgs.Empty);
}
}
private void OnClickForeColorPicker(object source, EventArgs e)
{
string color = this.foreColorCombo.Color;
color = ColorBuilder.BuildColor(base.GetBaseControl(), this, color);
if (color != null)
{
this.foreColorCombo.Color = color;
this.OnFormatChanged(this.foreColorCombo, EventArgs.Empty);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnSuggestColors(object sender, EventArgs e)
{
Color forwardColor, backwardColor;
ColorBuilder.SuggestColors(data.ReferenceColor1, data.ReferenceColor2, out forwardColor, out backwardColor);
data.ForwardColor = forwardColor;
data.BackwardColor = backwardColor;
data.AutoColors = false;
dataBindingSource.ResetCurrentItem();
}
public static void DrawTextBoxes <TPixel>(Image <TPixel> image, Font font, IEnumerable <TextBox> boxes) where TPixel : struct, IPixel <TPixel>
{
image.Mutate(context =>
{
foreach (var box in boxes)
{
var boxBounds = new RectangleF(
x: (float)(image.Width * box.X / 100),
y: (float)(image.Height * box.Y / 100),
width: (float)(image.Width * box.Width / 100),
height: (float)(image.Height * box.Height / 100)
);
var scaledFont = ScaleFont(new Font(font, image.Height / 8), box.Text, boxBounds.Width - 2 * outlineSize, boxBounds.Height - 2 * outlineSize);
var wrapWidth = ScaleWidth(scaledFont, box.Text, boxBounds.Width - 2 * outlineSize);
var lineColor = ColorBuilder <TPixel> .FromRGBA(box.LineColor.R, box.LineColor.G, box.LineColor.B, box.LineColor.A);
var fillColor = ColorBuilder <TPixel> .FromRGBA(box.FillColor.R, box.FillColor.G, box.FillColor.B, box.FillColor.A);
var pen = Pens.Solid(lineColor, 3f);
var brush = Brushes.Solid(fillColor);
var textBounds = TextMeasurer.MeasureBounds(box.Text, new RendererOptions(scaledFont)
{
WrappingWidth = wrapWidth,
HorizontalAlignment = ConvertHorizontalAlignment(box.Horizontal),
});
var drawLocation = GetLocation(box, boxBounds, textBounds);
// draw outline
context.DrawText(
new TextGraphicsOptions(true)
{
WrapTextWidth = wrapWidth,
HorizontalAlignment = ConvertHorizontalAlignment(box.Horizontal),
},
box.Text,
scaledFont,
pen,
drawLocation);
// draw fill
context.DrawText(new TextGraphicsOptions(true)
{
WrapTextWidth = wrapWidth,
HorizontalAlignment = ConvertHorizontalAlignment(box.Horizontal),
},
box.Text,
scaledFont,
brush,
drawLocation);
}
});
}
/// <inheritdoc/>
public override object ConvertFrom(CultureInfo culture, string value, Type propertyType)
{
if (string.IsNullOrWhiteSpace(value))
{
return(base.ConvertFrom(culture, value, propertyType));
}
// Special case. HTML requires LightGrey, but NamedColors has LightGray to conform with System.Drawing
// Check early on.
if (value.Equals("LightGrey", StringComparison.OrdinalIgnoreCase))
{
return(Rgba32.LightGray);
}
// Numeric r,g,b - r,g,b,a
char separator = culture.TextInfo.ListSeparator[0];
if (value.Contains(separator.ToString()))
{
string[] components = value.Split(separator);
bool convert = true;
foreach (string component in components)
{
if (!NumberRegex.IsMatch(component))
{
convert = false;
}
}
if (convert)
{
List <byte> rgba = CommandParser.Instance.ParseValue <List <byte> >(value);
return(rgba.Count == 4
? ColorBuilder <Rgba32> .FromRGBA(rgba[0], rgba[1], rgba[2], rgba[3])
: ColorBuilder <Rgba32> .FromRGB(rgba[0], rgba[1], rgba[2]));
}
}
// Hex colors rgb, rrggbb, rrggbbaa
if (HexColorRegex.IsMatch(value))
{
return(Rgba32.FromHex(value));
}
// Named colors
IDictionary <string, Rgba32> table = ColorConstantsTable.Value;
return(table.ContainsKey(value) ? table[value] : base.ConvertFrom(culture, value, propertyType));
}
public static void ToImage(this MatrixData input, string fileName)
{
using (Image <Rgba32> image = new Image <Rgba32>(input.NumberOfRows, input.NumberOfColumns))
{
for (int r = 0; r < input.NumberOfRows; r++)
{
for (int c = 0; c < input.NumberOfColumns; c++)
{
byte b = byte.Parse(((double)input[r, c]).ToString());
image[r, c] = ColorBuilder <Rgba32> .FromRGB(b, b, b);
}
}
image.SaveAsBmp(File.OpenWrite(fileName));
}
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
foreach (var property in builder.Model.GetEntityTypes().SelectMany(t => t.GetProperties()).Where(p => p.ClrType == typeof(decimal)))
{
property.Relational().ColumnType = "decimal(18, 2)";
}
var brandBuilder = new BrandBuilder(builder.Entity <Brand>());
var colorBuilder = new ColorBuilder(builder.Entity <Color>());
var fileBuilder = new FileBuilder(builder.Entity <File>());
var languageBuilder = new LanguageBuilder(builder.Entity <Language>());
var pageBuilder = new PageBuilder(builder.Entity <Page>());
var postBuilder = new PostBuilder(builder.Entity <Post>());
var postCategoryBuilder = new PostCategoryBuilder(builder.Entity <PostCategory>());
var postPostCategoryBuilder = new PostPostCategoryBuilder(builder.Entity <PostPostCategory>());
var productBuilder = new ProductBuilder(builder.Entity <Product>());
var productCategoryBuilder = new ProductCategoryBuilder(builder.Entity <ProductCategory>());
var productColorBuilder = new ProductColorBuilder(builder.Entity <ProductColor>());
var productPhotoBuilder = new ProductPhotoBuilder(builder.Entity <ProductPhoto>());
var reviewBuilder = new ReviewBuilder(builder.Entity <Review>());
var slideBuilder = new SlideBuilder(builder.Entity <Slide>());
var sliderBuilder = new SliderBuilder(builder.Entity <Slider>());
var advertisementBuilder = new AdvertisementBuilder(builder.Entity <Advertisement>());
var storeBuilder = new StoreBuilder(builder.Entity <Store>());
var storeBrandBuilder = new StoreBrandBuilder(builder.Entity <StoreBrand>());
var wishlistBuilder = new WishlistBuilder(builder.Entity <Wishlist>());
var orderBuilder = new OrderBuilder(builder.Entity <Order>());
var orderItemBuilder = new OrderItemBuilder(builder.Entity <OrderItem>());
var addressBuilder = new AddressBuilder(builder.Entity <Address>());
var cityBuilder = new CityBuilder(builder.Entity <City>());
var countryBuilder = new CountryBuilder(builder.Entity <Country>());
var couponBuilder = new CouponBuilder(builder.Entity <Coupon>());
var districtBuilder = new DistrictBuilder(builder.Entity <District>());
var productQuestionBuilder = new ProductQuestionBuilder(builder.Entity <ProductQuestion>());
var questionCategoryBuilder = new QuestionCategoryBuilder(builder.Entity <QuestionCategory>());
var shipperBuilder = new ShipperBuilder(builder.Entity <Shipper>());
var cartBuilder = new CartBuilder(builder.Entity <Cart>());
var cartItemBuilder = new CartItemBuilder(builder.Entity <CartItem>());
// data seeding
ApplicationDbContextSeed.Seed(builder);
}
private static string ColorToMarkup(Color color)
{
if (ColorBuilder == null)
{
ColorBuilder = new StringBuilder();
}
lock (ColorBuilder)
{
var r = (int)(color.r * 255);
var g = (int)(color.g * 255);
var b = (int)(color.b * 255);
var a = (int)(color.a * 255);
ColorBuilder.Clear();
ColorBuilder.Append("#");
ColorBuilder.Append(r.ToString("x2"));
ColorBuilder.Append(g.ToString("x2"));
ColorBuilder.Append(b.ToString("x2"));
ColorBuilder.Append(a.ToString("x2"));
var result = ColorBuilder.ToString();
return(result);
}
}
public void CB_SuggestColorsTest_01()
{
Color ref1 = Color.Brown, ref2 = Color.GreenYellow;
Color fc, bc;
for (int i = 0; i < 20; i++)
{
ColorBuilder.SuggestColors(ref1, ref2, out fc, out bc);
Assert.IsTrue(ref1.GetSaturation() <= bc.GetSaturation(), "backward color saturation too low");
Assert.IsTrue(bc.GetSaturation() <= ref2.GetSaturation(), "backward color saturation too high");
Assert.IsTrue(ref1.GetBrightness() <= bc.GetBrightness(), "backward color brightness too low");
Assert.IsTrue(bc.GetBrightness() <= ref2.GetBrightness(), "backward color brightness too high");
Assert.IsTrue(ref1.GetSaturation() <= fc.GetSaturation(), "forward color saturation too low");
Assert.IsTrue(fc.GetSaturation() <= ref2.GetSaturation(), "forward color saturation too high");
Assert.IsTrue(ref1.GetBrightness() <= fc.GetBrightness(), "forward color brightness too low");
Assert.IsTrue(fc.GetBrightness() <= ref2.GetBrightness(), "forward color brightness too high");
Assert.IsTrue(bc.GetSaturation() <= fc.GetSaturation(), "saturation not ordered");
Assert.IsTrue(bc.GetBrightness() <= fc.GetBrightness(), "brightness not ordered");
}
}
public void ParseHexThrowsOnNull()
{
Assert.Throws <ArgumentNullException>(() => ColorBuilder <Rgb24> .FromHex(null));
}
public void ParseHexThrowsOnEmpty()
{
Assert.Throws <ArgumentException>(() => ColorBuilder <Rgb24> .FromHex(""));
}
public void ParseHexLeadingPoundIsOptional()
{
Assert.Equal(new Rgb24(0, 128, 128), ColorBuilder <Rgb24> .FromHex("#008080"));
Assert.Equal(new Rgb24(0, 128, 128), ColorBuilder <Rgb24> .FromHex("008080"));
}
public void ParseShortHex()
{
Assert.Equal(new Rgb24(255, 255, 255), ColorBuilder <Rgb24> .FromHex("#fff"));
Assert.Equal(new Rgb24(255, 255, 255), ColorBuilder <Rgb24> .FromHex("fff"));
Assert.Equal(new Rgba32(0, 0, 0, 255), ColorBuilder <Rgba32> .FromHex("000f"));
}
public AnsiStringColorBuilder(string text)
{
CurrentValue = text;
Builder = new ColorBuilder(this);
}
